Branch data Line data Source code
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 : 49245 : file_rule(Parser *p)
1042 : : {
1043 [ - + ]: 49245 : if (p->level++ == MAXSTACK) {
1044 : 0 : p->error_indicator = 1;
1045 : : PyErr_NoMemory();
1046 : : }
1047 [ + + ]: 49245 : if (p->error_indicator) {
1048 : 184 : p->level--;
1049 : 184 : return NULL;
1050 : : }
1051 : 49061 : mod_ty _res = NULL;
1052 : 49061 : int _mark = p->mark;
1053 : : { // statements? $
1054 [ - + ]: 49061 : if (p->error_indicator) {
1055 : 0 : p->level--;
1056 : 0 : 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 : 49061 : if (
1062 [ + + ]: 49061 : (a = statements_rule(p), !p->error_indicator) // statements?
1063 [ + + ]: 48679 : &&
1064 : 48679 : (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1065 : : )
1066 : : {
1067 : : D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements? $"));
1068 : 47877 : _res = _PyPegen_make_module ( p , a );
1069 [ - + - - ]: 47877 : if (_res == NULL && PyErr_Occurred()) {
1070 : 0 : p->error_indicator = 1;
1071 : 0 : p->level--;
1072 : 0 : return NULL;
1073 : : }
1074 : 47877 : goto done;
1075 : : }
1076 : 1184 : 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 : 1184 : _res = NULL;
1081 : 49061 : done:
1082 : 49061 : p->level--;
1083 : 49061 : return _res;
1084 : : }
1085 : :
1086 : : // interactive: statement_newline
1087 : : static mod_ty
1088 : 5077 : interactive_rule(Parser *p)
1089 : : {
1090 [ - + ]: 5077 : if (p->level++ == MAXSTACK) {
1091 : 0 : p->error_indicator = 1;
1092 : : PyErr_NoMemory();
1093 : : }
1094 [ + + ]: 5077 : if (p->error_indicator) {
1095 : 17 : p->level--;
1096 : 17 : return NULL;
1097 : : }
1098 : 5060 : mod_ty _res = NULL;
1099 : 5060 : int _mark = p->mark;
1100 : : { // statement_newline
1101 [ - + ]: 5060 : if (p->error_indicator) {
1102 : 0 : p->level--;
1103 : 0 : 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 [ + + ]: 5060 : if (
1108 : 5060 : (a = statement_newline_rule(p)) // statement_newline
1109 : : )
1110 : : {
1111 : : D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement_newline"));
1112 : 4160 : _res = _PyAST_Interactive ( a , p -> arena );
1113 [ - + - - ]: 4160 : if (_res == NULL && PyErr_Occurred()) {
1114 : 0 : p->error_indicator = 1;
1115 : 0 : p->level--;
1116 : 0 : return NULL;
1117 : : }
1118 : 4160 : goto done;
1119 : : }
1120 : 900 : 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 : 900 : _res = NULL;
1125 : 5060 : done:
1126 : 5060 : p->level--;
1127 : 5060 : return _res;
1128 : : }
1129 : :
1130 : : // eval: expressions NEWLINE* $
1131 : : static mod_ty
1132 : 73802 : eval_rule(Parser *p)
1133 : : {
1134 [ - + ]: 73802 : if (p->level++ == MAXSTACK) {
1135 : 0 : p->error_indicator = 1;
1136 : : PyErr_NoMemory();
1137 : : }
1138 [ + + ]: 73802 : if (p->error_indicator) {
1139 : 848 : p->level--;
1140 : 848 : return NULL;
1141 : : }
1142 : 72954 : mod_ty _res = NULL;
1143 : 72954 : int _mark = p->mark;
1144 : : { // expressions NEWLINE* $
1145 [ - + ]: 72954 : if (p->error_indicator) {
1146 : 0 : p->level--;
1147 : 0 : 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 [ + + ]: 72954 : if (
1154 : 72954 : (a = expressions_rule(p)) // expressions
1155 [ + - ]: 72068 : &&
1156 : 72068 : (_loop0_1_var = _loop0_1_rule(p)) // NEWLINE*
1157 [ + + ]: 72068 : &&
1158 : 72068 : (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1159 : : )
1160 : : {
1161 : : D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));
1162 : 71904 : _res = _PyAST_Expression ( a , p -> arena );
1163 [ - + - - ]: 71904 : if (_res == NULL && PyErr_Occurred()) {
1164 : 0 : p->error_indicator = 1;
1165 : 0 : p->level--;
1166 : 0 : return NULL;
1167 : : }
1168 : 71904 : goto done;
1169 : : }
1170 : 1050 : 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 : 1050 : _res = NULL;
1175 : 72954 : done:
1176 : 72954 : p->level--;
1177 : 72954 : return _res;
1178 : : }
1179 : :
1180 : : // func_type: '(' type_expressions? ')' '->' expression NEWLINE* $
1181 : : static mod_ty
1182 : 18 : func_type_rule(Parser *p)
1183 : : {
1184 [ - + ]: 18 : if (p->level++ == MAXSTACK) {
1185 : 0 : p->error_indicator = 1;
1186 : : PyErr_NoMemory();
1187 : : }
1188 [ - + ]: 18 : if (p->error_indicator) {
1189 : 0 : p->level--;
1190 : 0 : return NULL;
1191 : : }
1192 : 18 : mod_ty _res = NULL;
1193 : 18 : int _mark = p->mark;
1194 : : { // '(' type_expressions? ')' '->' expression NEWLINE* $
1195 [ - + ]: 18 : if (p->error_indicator) {
1196 : 0 : p->level--;
1197 : 0 : 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 [ + - ]: 18 : if (
1208 : 18 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
1209 : 18 : &&
1210 [ + - ]: 18 : (a = type_expressions_rule(p), !p->error_indicator) // type_expressions?
1211 [ + + ]: 18 : &&
1212 : 18 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
1213 [ + - ]: 12 : &&
1214 : 12 : (_literal_2 = _PyPegen_expect_token(p, 51)) // token='->'
1215 [ + - ]: 12 : &&
1216 : 12 : (b = expression_rule(p)) // expression
1217 [ + - ]: 12 : &&
1218 : 12 : (_loop0_2_var = _loop0_2_rule(p)) // NEWLINE*
1219 [ + - ]: 12 : &&
1220 : 12 : (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1221 : : )
1222 : : {
1223 : : D(fprintf(stderr, "%*c+ func_type[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $"));
1224 : 12 : _res = _PyAST_FunctionType ( a , b , p -> arena );
1225 [ - + - - ]: 12 : if (_res == NULL && PyErr_Occurred()) {
1226 : 0 : p->error_indicator = 1;
1227 : 0 : p->level--;
1228 : 0 : return NULL;
1229 : : }
1230 : 12 : goto done;
1231 : : }
1232 : 6 : 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 : 6 : _res = NULL;
1237 : 18 : done:
1238 : 18 : p->level--;
1239 : 18 : return _res;
1240 : : }
1241 : :
1242 : : // fstring: star_expressions
1243 : : static expr_ty
1244 : 96084 : fstring_rule(Parser *p)
1245 : : {
1246 [ - + ]: 96084 : if (p->level++ == MAXSTACK) {
1247 : 0 : p->error_indicator = 1;
1248 : : PyErr_NoMemory();
1249 : : }
1250 [ + + ]: 96084 : if (p->error_indicator) {
1251 : 4 : p->level--;
1252 : 4 : return NULL;
1253 : : }
1254 : 96080 : expr_ty _res = NULL;
1255 : 96080 : int _mark = p->mark;
1256 : : { // star_expressions
1257 [ - + ]: 96080 : if (p->error_indicator) {
1258 : 0 : p->level--;
1259 : 0 : 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 [ + + ]: 96080 : if (
1264 : 96080 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
1265 : : )
1266 : : {
1267 : : D(fprintf(stderr, "%*c+ fstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
1268 : 96052 : _res = star_expressions_var;
1269 : 96052 : goto done;
1270 : : }
1271 : 28 : 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 : 28 : _res = NULL;
1276 : 96080 : done:
1277 : 96080 : p->level--;
1278 : 96080 : return _res;
1279 : : }
1280 : :
1281 : : // statements: statement+
1282 : : static asdl_stmt_seq*
1283 : 1038152 : statements_rule(Parser *p)
1284 : : {
1285 [ - + ]: 1038152 : if (p->level++ == MAXSTACK) {
1286 : 0 : p->error_indicator = 1;
1287 : : PyErr_NoMemory();
1288 : : }
1289 [ - + ]: 1038152 : if (p->error_indicator) {
1290 : 0 : p->level--;
1291 : 0 : return NULL;
1292 : : }
1293 : 1038152 : asdl_stmt_seq* _res = NULL;
1294 : 1038152 : int _mark = p->mark;
1295 : : { // statement+
1296 [ - + ]: 1038152 : if (p->error_indicator) {
1297 : 0 : p->level--;
1298 : 0 : return NULL;
1299 : : }
1300 : : D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+"));
1301 : : asdl_seq * a;
1302 [ + + ]: 1038152 : if (
1303 : 1038152 : (a = _loop1_3_rule(p)) // statement+
1304 : : )
1305 : : {
1306 : : D(fprintf(stderr, "%*c+ statements[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement+"));
1307 : 1036171 : _res = ( asdl_stmt_seq* ) _PyPegen_seq_flatten ( p , a );
1308 [ - + - - ]: 1036171 : if (_res == NULL && PyErr_Occurred()) {
1309 : 0 : p->error_indicator = 1;
1310 : 0 : p->level--;
1311 : 0 : return NULL;
1312 : : }
1313 : 1036171 : goto done;
1314 : : }
1315 : 1981 : 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 : 1981 : _res = NULL;
1320 : 1038152 : done:
1321 : 1038152 : p->level--;
1322 : 1038152 : return _res;
1323 : : }
1324 : :
1325 : : // statement: compound_stmt | simple_stmts
1326 : : static asdl_stmt_seq*
1327 : 4032083 : statement_rule(Parser *p)
1328 : : {
1329 [ - + ]: 4032083 : if (p->level++ == MAXSTACK) {
1330 : 0 : p->error_indicator = 1;
1331 : : PyErr_NoMemory();
1332 : : }
1333 [ - + ]: 4032083 : if (p->error_indicator) {
1334 : 0 : p->level--;
1335 : 0 : return NULL;
1336 : : }
1337 : 4032083 : asdl_stmt_seq* _res = NULL;
1338 : 4032083 : int _mark = p->mark;
1339 : : { // compound_stmt
1340 [ - + ]: 4032083 : if (p->error_indicator) {
1341 : 0 : p->level--;
1342 : 0 : 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 [ + + ]: 4032083 : if (
1347 : 4032083 : (a = compound_stmt_rule(p)) // compound_stmt
1348 : : )
1349 : : {
1350 : : D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt"));
1351 : 1045074 : _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a );
1352 [ - + - - ]: 1045074 : if (_res == NULL && PyErr_Occurred()) {
1353 : 0 : p->error_indicator = 1;
1354 : 0 : p->level--;
1355 : 0 : return NULL;
1356 : : }
1357 : 1045074 : goto done;
1358 : : }
1359 : 2987009 : 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 [ + + ]: 2987009 : if (p->error_indicator) {
1365 : 186 : p->level--;
1366 : 186 : 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 [ + + ]: 2986823 : if (
1371 : 2986823 : (a = (asdl_stmt_seq*)simple_stmts_rule(p)) // simple_stmts
1372 : : )
1373 : : {
1374 : : D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1375 : 1948857 : _res = a;
1376 [ - + - - ]: 1948857 : if (_res == NULL && PyErr_Occurred()) {
1377 : 0 : p->error_indicator = 1;
1378 : 0 : p->level--;
1379 : 0 : return NULL;
1380 : : }
1381 : 1948857 : goto done;
1382 : : }
1383 : 1037966 : 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 : 1037966 : _res = NULL;
1388 : 4031897 : done:
1389 : 4031897 : p->level--;
1390 : 4031897 : return _res;
1391 : : }
1392 : :
1393 : : // statement_newline: compound_stmt NEWLINE | simple_stmts | NEWLINE | $
1394 : : static asdl_stmt_seq*
1395 : 5060 : statement_newline_rule(Parser *p)
1396 : : {
1397 [ - + ]: 5060 : if (p->level++ == MAXSTACK) {
1398 : 0 : p->error_indicator = 1;
1399 : : PyErr_NoMemory();
1400 : : }
1401 [ - + ]: 5060 : if (p->error_indicator) {
1402 : 0 : p->level--;
1403 : 0 : return NULL;
1404 : : }
1405 : 5060 : asdl_stmt_seq* _res = NULL;
1406 : 5060 : int _mark = p->mark;
1407 [ + + - + ]: 5060 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
1408 : 0 : p->error_indicator = 1;
1409 : 0 : p->level--;
1410 : 0 : return NULL;
1411 : : }
1412 : 5060 : int _start_lineno = p->tokens[_mark]->lineno;
1413 : : UNUSED(_start_lineno); // Only used by EXTRA macro
1414 : 5060 : int _start_col_offset = p->tokens[_mark]->col_offset;
1415 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
1416 : : { // compound_stmt NEWLINE
1417 [ - + ]: 5060 : if (p->error_indicator) {
1418 : 0 : p->level--;
1419 : 0 : 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 [ + + ]: 5060 : if (
1425 : 5060 : (a = compound_stmt_rule(p)) // compound_stmt
1426 [ + + ]: 628 : &&
1427 : 628 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1428 : : )
1429 : : {
1430 : : D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE"));
1431 : 596 : _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a );
1432 [ - + - - ]: 596 : if (_res == NULL && PyErr_Occurred()) {
1433 : 0 : p->error_indicator = 1;
1434 : 0 : p->level--;
1435 : 0 : return NULL;
1436 : : }
1437 : 596 : goto done;
1438 : : }
1439 : 4464 : 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 [ + + ]: 4464 : if (p->error_indicator) {
1445 : 159 : p->level--;
1446 : 159 : 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 [ + + ]: 4305 : if (
1451 : 4305 : (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts
1452 : : )
1453 : : {
1454 : : D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1455 : 3562 : _res = simple_stmts_var;
1456 : 3562 : goto done;
1457 : : }
1458 : 743 : 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 [ + + ]: 743 : if (p->error_indicator) {
1464 : 245 : p->level--;
1465 : 245 : 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 [ + + ]: 498 : if (
1470 : 498 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1471 : : )
1472 : : {
1473 : : D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
1474 : 2 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1475 [ - + ]: 2 : if (_token == NULL) {
1476 : 0 : p->level--;
1477 : 0 : return NULL;
1478 : : }
1479 : 2 : int _end_lineno = _token->end_lineno;
1480 : : UNUSED(_end_lineno); // Only used by EXTRA macro
1481 : 2 : int _end_col_offset = _token->end_col_offset;
1482 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
1483 : 2 : _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , CHECK ( stmt_ty , _PyAST_Pass ( EXTRA ) ) );
1484 [ - + - - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
1485 : 0 : p->error_indicator = 1;
1486 : 0 : p->level--;
1487 : 0 : return NULL;
1488 : : }
1489 : 2 : goto done;
1490 : : }
1491 : 496 : 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 [ - + ]: 496 : if (p->error_indicator) {
1497 : 0 : p->level--;
1498 : 0 : return NULL;
1499 : : }
1500 : : D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "$"));
1501 : : Token * endmarker_var;
1502 [ + + ]: 496 : if (
1503 : 496 : (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1504 : : )
1505 : : {
1506 : : D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "$"));
1507 : 14 : _res = _PyPegen_interactive_exit ( p );
1508 [ + - - + ]: 14 : if (_res == NULL && PyErr_Occurred()) {
1509 : 0 : p->error_indicator = 1;
1510 : 0 : p->level--;
1511 : 0 : return NULL;
1512 : : }
1513 : 14 : goto done;
1514 : : }
1515 : 482 : 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 : 482 : _res = NULL;
1520 : 4656 : done:
1521 : 4656 : p->level--;
1522 : 4656 : return _res;
1523 : : }
1524 : :
1525 : : // simple_stmts: simple_stmt !';' NEWLINE | ';'.simple_stmt+ ';'? NEWLINE
1526 : : static asdl_stmt_seq*
1527 : 3203076 : simple_stmts_rule(Parser *p)
1528 : : {
1529 [ - + ]: 3203076 : if (p->level++ == MAXSTACK) {
1530 : 0 : p->error_indicator = 1;
1531 : : PyErr_NoMemory();
1532 : : }
1533 [ - + ]: 3203076 : if (p->error_indicator) {
1534 : 0 : p->level--;
1535 : 0 : return NULL;
1536 : : }
1537 : 3203076 : asdl_stmt_seq* _res = NULL;
1538 : 3203076 : int _mark = p->mark;
1539 : : { // simple_stmt !';' NEWLINE
1540 [ - + ]: 3203076 : if (p->error_indicator) {
1541 : 0 : p->level--;
1542 : 0 : 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 [ + + ]: 3203076 : if (
1548 : 3203076 : (a = simple_stmt_rule(p)) // simple_stmt
1549 [ + + ]: 2164576 : &&
1550 : 2164576 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13) // token=';'
1551 [ + + ]: 2162402 : &&
1552 : 2162402 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1553 : : )
1554 : : {
1555 : : D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt !';' NEWLINE"));
1556 : 2161852 : _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a );
1557 [ - + - - ]: 2161852 : if (_res == NULL && PyErr_Occurred()) {
1558 : 0 : p->error_indicator = 1;
1559 : 0 : p->level--;
1560 : 0 : return NULL;
1561 : : }
1562 : 2161852 : goto done;
1563 : : }
1564 : 1041224 : 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 [ + + ]: 1041224 : if (p->error_indicator) {
1570 : 476 : p->level--;
1571 : 476 : 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 [ + + ]: 1040748 : if (
1579 : 1040748 : (a = (asdl_stmt_seq*)_gather_4_rule(p)) // ';'.simple_stmt+
1580 : 2724 : &&
1581 [ + + ]: 2724 : (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'?
1582 [ + + ]: 2722 : &&
1583 : 2722 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1584 : : )
1585 : : {
1586 : : D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE"));
1587 : 2164 : _res = a;
1588 [ - + - - ]: 2164 : if (_res == NULL && PyErr_Occurred()) {
1589 : 0 : p->error_indicator = 1;
1590 : 0 : p->level--;
1591 : 0 : return NULL;
1592 : : }
1593 : 2164 : goto done;
1594 : : }
1595 : 1038584 : 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 : 1038584 : _res = NULL;
1600 : 3202600 : done:
1601 : 3202600 : p->level--;
1602 : 3202600 : 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 : 4251610 : simple_stmt_rule(Parser *p)
1621 : : {
1622 [ - + ]: 4251610 : if (p->level++ == MAXSTACK) {
1623 : 0 : p->error_indicator = 1;
1624 : : PyErr_NoMemory();
1625 : : }
1626 [ - + ]: 4251610 : if (p->error_indicator) {
1627 : 0 : p->level--;
1628 : 0 : return NULL;
1629 : : }
1630 : 4251610 : stmt_ty _res = NULL;
1631 [ + + ]: 4251610 : if (_PyPegen_is_memoized(p, simple_stmt_type, &_res)) {
1632 : 1040748 : p->level--;
1633 : 1040748 : return _res;
1634 : : }
1635 : 3210862 : int _mark = p->mark;
1636 [ - + - - ]: 3210862 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
1637 : 0 : p->error_indicator = 1;
1638 : 0 : p->level--;
1639 : 0 : return NULL;
1640 : : }
1641 : 3210862 : int _start_lineno = p->tokens[_mark]->lineno;
1642 : : UNUSED(_start_lineno); // Only used by EXTRA macro
1643 : 3210862 : int _start_col_offset = p->tokens[_mark]->col_offset;
1644 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
1645 : : { // assignment
1646 [ - + ]: 3210862 : if (p->error_indicator) {
1647 : 0 : p->level--;
1648 : 0 : 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 [ + + ]: 3210862 : if (
1653 : 3210862 : (assignment_var = assignment_rule(p)) // assignment
1654 : : )
1655 : : {
1656 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment"));
1657 : 840196 : _res = assignment_var;
1658 : 840196 : goto done;
1659 : : }
1660 : 2370666 : 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 [ + + ]: 2370666 : if (p->error_indicator) {
1666 : 412 : p->level--;
1667 : 412 : 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 [ + + ]: 2370254 : if (
1672 : 2370254 : (e = star_expressions_rule(p)) // star_expressions
1673 : : )
1674 : : {
1675 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
1676 : 859293 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1677 [ - + ]: 859293 : if (_token == NULL) {
1678 : 0 : p->level--;
1679 : 0 : return NULL;
1680 : : }
1681 : 859293 : int _end_lineno = _token->end_lineno;
1682 : : UNUSED(_end_lineno); // Only used by EXTRA macro
1683 : 859293 : int _end_col_offset = _token->end_col_offset;
1684 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
1685 : 859293 : _res = _PyAST_Expr ( e , EXTRA );
1686 [ - + - - ]: 859293 : if (_res == NULL && PyErr_Occurred()) {
1687 : 0 : p->error_indicator = 1;
1688 : 0 : p->level--;
1689 : 0 : return NULL;
1690 : : }
1691 : 859293 : goto done;
1692 : : }
1693 : 1510961 : 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 [ + + ]: 1510961 : if (p->error_indicator) {
1699 : 14 : p->level--;
1700 : 14 : 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 [ + + ]: 1510947 : if (
1705 : 1510947 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 519) // token='return'
1706 [ + + ]: 239070 : &&
1707 : 239070 : (return_stmt_var = return_stmt_rule(p)) // return_stmt
1708 : : )
1709 : : {
1710 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt"));
1711 : 239069 : _res = return_stmt_var;
1712 : 239069 : goto done;
1713 : : }
1714 : 1271878 : 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 [ + + ]: 1271878 : if (p->error_indicator) {
1720 : 1 : p->level--;
1721 : 1 : 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 [ + + ]: 1271877 : if (
1726 : 1271877 : _PyPegen_lookahead(1, _tmp_6_rule, p)
1727 [ + + ]: 90627 : &&
1728 : 90627 : (import_stmt_var = import_stmt_rule(p)) // import_stmt
1729 : : )
1730 : : {
1731 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt"));
1732 : 90571 : _res = import_stmt_var;
1733 : 90571 : goto done;
1734 : : }
1735 : 1181306 : 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 [ + + ]: 1181306 : if (p->error_indicator) {
1741 : 21 : p->level--;
1742 : 21 : 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 [ + + ]: 1181285 : if (
1747 : 1181285 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 522) // token='raise'
1748 [ + - ]: 61013 : &&
1749 : 61013 : (raise_stmt_var = raise_stmt_rule(p)) // raise_stmt
1750 : : )
1751 : : {
1752 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt"));
1753 : 61013 : _res = raise_stmt_var;
1754 : 61013 : goto done;
1755 : : }
1756 : 1120272 : 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 [ - + ]: 1120272 : if (p->error_indicator) {
1762 : 0 : p->level--;
1763 : 0 : return NULL;
1764 : : }
1765 : : D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'"));
1766 : : Token * _keyword;
1767 [ + + ]: 1120272 : if (
1768 : 1120272 : (_keyword = _PyPegen_expect_token(p, 504)) // token='pass'
1769 : : )
1770 : : {
1771 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pass'"));
1772 : 27152 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1773 [ - + ]: 27152 : if (_token == NULL) {
1774 : 0 : p->level--;
1775 : 0 : return NULL;
1776 : : }
1777 : 27152 : int _end_lineno = _token->end_lineno;
1778 : : UNUSED(_end_lineno); // Only used by EXTRA macro
1779 : 27152 : int _end_col_offset = _token->end_col_offset;
1780 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
1781 : 27152 : _res = _PyAST_Pass ( EXTRA );
1782 [ - + - - ]: 27152 : if (_res == NULL && PyErr_Occurred()) {
1783 : 0 : p->error_indicator = 1;
1784 : 0 : p->level--;
1785 : 0 : return NULL;
1786 : : }
1787 : 27152 : goto done;
1788 : : }
1789 : 1093120 : 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 [ - + ]: 1093120 : if (p->error_indicator) {
1795 : 0 : p->level--;
1796 : 0 : 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 [ + + ]: 1093120 : if (
1801 : 1093120 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 603) // token='del'
1802 [ + + ]: 8844 : &&
1803 : 8844 : (del_stmt_var = del_stmt_rule(p)) // del_stmt
1804 : : )
1805 : : {
1806 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt"));
1807 : 8764 : _res = del_stmt_var;
1808 : 8764 : goto done;
1809 : : }
1810 : 1084356 : 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 [ + + ]: 1084356 : if (p->error_indicator) {
1816 : 30 : p->level--;
1817 : 30 : 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 [ + + ]: 1084326 : if (
1822 : 1084326 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 573) // token='yield'
1823 [ + - ]: 15191 : &&
1824 : 15191 : (yield_stmt_var = yield_stmt_rule(p)) // yield_stmt
1825 : : )
1826 : : {
1827 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt"));
1828 : 15191 : _res = yield_stmt_var;
1829 : 15191 : goto done;
1830 : : }
1831 : 1069135 : 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 [ - + ]: 1069135 : if (p->error_indicator) {
1837 : 0 : p->level--;
1838 : 0 : 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 [ + + ]: 1069135 : if (
1843 : 1069135 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 526) // token='assert'
1844 [ + + ]: 9810 : &&
1845 : 9810 : (assert_stmt_var = assert_stmt_rule(p)) // assert_stmt
1846 : : )
1847 : : {
1848 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt"));
1849 : 9808 : _res = assert_stmt_var;
1850 : 9808 : goto done;
1851 : : }
1852 : 1059327 : 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 [ - + ]: 1059327 : if (p->error_indicator) {
1858 : 0 : p->level--;
1859 : 0 : return NULL;
1860 : : }
1861 : : D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'"));
1862 : : Token * _keyword;
1863 [ + + ]: 1059327 : if (
1864 : 1059327 : (_keyword = _PyPegen_expect_token(p, 508)) // token='break'
1865 : : )
1866 : : {
1867 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'break'"));
1868 : 9747 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1869 [ - + ]: 9747 : if (_token == NULL) {
1870 : 0 : p->level--;
1871 : 0 : return NULL;
1872 : : }
1873 : 9747 : int _end_lineno = _token->end_lineno;
1874 : : UNUSED(_end_lineno); // Only used by EXTRA macro
1875 : 9747 : int _end_col_offset = _token->end_col_offset;
1876 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
1877 : 9747 : _res = _PyAST_Break ( EXTRA );
1878 [ - + - - ]: 9747 : if (_res == NULL && PyErr_Occurred()) {
1879 : 0 : p->error_indicator = 1;
1880 : 0 : p->level--;
1881 : 0 : return NULL;
1882 : : }
1883 : 9747 : goto done;
1884 : : }
1885 : 1049580 : 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 [ - + ]: 1049580 : if (p->error_indicator) {
1891 : 0 : p->level--;
1892 : 0 : return NULL;
1893 : : }
1894 : : D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'"));
1895 : : Token * _keyword;
1896 [ + + ]: 1049580 : if (
1897 : 1049580 : (_keyword = _PyPegen_expect_token(p, 509)) // token='continue'
1898 : : )
1899 : : {
1900 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'continue'"));
1901 : 8669 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1902 [ - + ]: 8669 : if (_token == NULL) {
1903 : 0 : p->level--;
1904 : 0 : return NULL;
1905 : : }
1906 : 8669 : int _end_lineno = _token->end_lineno;
1907 : : UNUSED(_end_lineno); // Only used by EXTRA macro
1908 : 8669 : int _end_col_offset = _token->end_col_offset;
1909 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
1910 : 8669 : _res = _PyAST_Continue ( EXTRA );
1911 [ - + - - ]: 8669 : if (_res == NULL && PyErr_Occurred()) {
1912 : 0 : p->error_indicator = 1;
1913 : 0 : p->level--;
1914 : 0 : return NULL;
1915 : : }
1916 : 8669 : goto done;
1917 : : }
1918 : 1040911 : 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 [ - + ]: 1040911 : if (p->error_indicator) {
1924 : 0 : p->level--;
1925 : 0 : 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 [ + + ]: 1040911 : if (
1930 : 1040911 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 523) // token='global'
1931 [ + + ]: 1818 : &&
1932 : 1818 : (global_stmt_var = global_stmt_rule(p)) // global_stmt
1933 : : )
1934 : : {
1935 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt"));
1936 : 1816 : _res = global_stmt_var;
1937 : 1816 : goto done;
1938 : : }
1939 : 1039095 : 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 [ - + ]: 1039095 : if (p->error_indicator) {
1945 : 0 : p->level--;
1946 : 0 : 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 [ + + ]: 1039095 : if (
1951 : 1039095 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 524) // token='nonlocal'
1952 [ + + ]: 930 : &&
1953 : 930 : (nonlocal_stmt_var = nonlocal_stmt_rule(p)) // nonlocal_stmt
1954 : : )
1955 : : {
1956 : : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
1957 : 928 : _res = nonlocal_stmt_var;
1958 : 928 : goto done;
1959 : : }
1960 : 1038167 : 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 : 1038167 : _res = NULL;
1965 : 3210384 : done:
1966 : 3210384 : _PyPegen_insert_memo(p, _mark, simple_stmt_type, _res);
1967 : 3210384 : p->level--;
1968 : 3210384 : 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 : 4037143 : compound_stmt_rule(Parser *p)
1982 : : {
1983 [ - + ]: 4037143 : if (p->level++ == MAXSTACK) {
1984 : 0 : p->error_indicator = 1;
1985 : : PyErr_NoMemory();
1986 : : }
1987 [ - + ]: 4037143 : if (p->error_indicator) {
1988 : 0 : p->level--;
1989 : 0 : return NULL;
1990 : : }
1991 : 4037143 : stmt_ty _res = NULL;
1992 : 4037143 : int _mark = p->mark;
1993 : : { // &('def' | '@' | ASYNC) function_def
1994 [ - + ]: 4037143 : if (p->error_indicator) {
1995 : 0 : p->level--;
1996 : 0 : 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 [ + + ]: 4037143 : if (
2001 : 4037143 : _PyPegen_lookahead(1, _tmp_7_rule, p)
2002 [ + + ]: 344359 : &&
2003 : 344359 : (function_def_var = function_def_rule(p)) // function_def
2004 : : )
2005 : : {
2006 : : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def"));
2007 : 340159 : _res = function_def_var;
2008 : 340159 : goto done;
2009 : : }
2010 : 3696984 : 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 [ + + ]: 3696984 : if (p->error_indicator) {
2016 : 204 : p->level--;
2017 : 204 : 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 [ + + ]: 3696780 : if (
2022 : 3696780 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 634) // token='if'
2023 [ + + ]: 487179 : &&
2024 : 487179 : (if_stmt_var = if_stmt_rule(p)) // if_stmt
2025 : : )
2026 : : {
2027 : : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt"));
2028 : 487088 : _res = if_stmt_var;
2029 : 487088 : goto done;
2030 : : }
2031 : 3209692 : 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 [ + + ]: 3209692 : if (p->error_indicator) {
2037 : 30 : p->level--;
2038 : 30 : 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 [ + + ]: 3209662 : if (
2043 : 3209662 : _PyPegen_lookahead(1, _tmp_8_rule, p)
2044 [ + + ]: 56490 : &&
2045 : 56490 : (class_def_var = class_def_rule(p)) // class_def
2046 : : )
2047 : : {
2048 : : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def"));
2049 : 56449 : _res = class_def_var;
2050 : 56449 : goto done;
2051 : : }
2052 : 3153213 : 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 [ + + ]: 3153213 : if (p->error_indicator) {
2058 : 8 : p->level--;
2059 : 8 : 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 [ + + ]: 3153205 : if (
2064 : 3153205 : _PyPegen_lookahead(1, _tmp_9_rule, p)
2065 [ + + ]: 39282 : &&
2066 : 39282 : (with_stmt_var = with_stmt_rule(p)) // with_stmt
2067 : : )
2068 : : {
2069 : : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt"));
2070 : 38946 : _res = with_stmt_var;
2071 : 38946 : goto done;
2072 : : }
2073 : 3114259 : 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 [ + + ]: 3114259 : if (p->error_indicator) {
2079 : 28 : p->level--;
2080 : 28 : 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 [ + + ]: 3114231 : if (
2085 : 3114231 : _PyPegen_lookahead(1, _tmp_10_rule, p)
2086 [ + + ]: 61364 : &&
2087 : 61364 : (for_stmt_var = for_stmt_rule(p)) // for_stmt
2088 : : )
2089 : : {
2090 : : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt"));
2091 : 61237 : _res = for_stmt_var;
2092 : 61237 : goto done;
2093 : : }
2094 : 3052994 : 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 [ + + ]: 3052994 : if (p->error_indicator) {
2100 : 17 : p->level--;
2101 : 17 : 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 [ + + ]: 3052977 : if (
2106 : 3052977 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 618) // token='try'
2107 [ + + ]: 49059 : &&
2108 : 49059 : (try_stmt_var = try_stmt_rule(p)) // try_stmt
2109 : : )
2110 : : {
2111 : : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt"));
2112 : 48962 : _res = try_stmt_var;
2113 : 48962 : goto done;
2114 : : }
2115 : 3004015 : 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 [ + + ]: 3004015 : if (p->error_indicator) {
2121 : 35 : p->level--;
2122 : 35 : 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 [ + + ]: 3003980 : if (
2127 : 3003980 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 639) // token='while'
2128 [ + + ]: 11686 : &&
2129 : 11686 : (while_stmt_var = while_stmt_rule(p)) // while_stmt
2130 : : )
2131 : : {
2132 : : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt"));
2133 : 11638 : _res = while_stmt_var;
2134 : 11638 : goto done;
2135 : : }
2136 : 2992342 : 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 [ + + ]: 2992342 : if (p->error_indicator) {
2142 : 4 : p->level--;
2143 : 4 : 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 [ + + ]: 2992338 : if (
2148 : 2992338 : (match_stmt_var = match_stmt_rule(p)) // match_stmt
2149 : : )
2150 : : {
2151 : : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "match_stmt"));
2152 : 1223 : _res = match_stmt_var;
2153 : 1223 : goto done;
2154 : : }
2155 : 2991115 : 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 : 2991115 : _res = NULL;
2160 : 4036817 : done:
2161 : 4036817 : p->level--;
2162 : 4036817 : 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 : 3210862 : assignment_rule(Parser *p)
2173 : : {
2174 [ - + ]: 3210862 : if (p->level++ == MAXSTACK) {
2175 : 0 : p->error_indicator = 1;
2176 : : PyErr_NoMemory();
2177 : : }
2178 [ - + ]: 3210862 : if (p->error_indicator) {
2179 : 0 : p->level--;
2180 : 0 : return NULL;
2181 : : }
2182 : 3210862 : stmt_ty _res = NULL;
2183 : 3210862 : int _mark = p->mark;
2184 [ - + - - ]: 3210862 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
2185 : 0 : p->error_indicator = 1;
2186 : 0 : p->level--;
2187 : 0 : return NULL;
2188 : : }
2189 : 3210862 : int _start_lineno = p->tokens[_mark]->lineno;
2190 : : UNUSED(_start_lineno); // Only used by EXTRA macro
2191 : 3210862 : 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 [ - + ]: 3210862 : if (p->error_indicator) {
2195 : 0 : p->level--;
2196 : 0 : 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 [ + + ]: 3210862 : if (
2204 : 3210862 : (a = _PyPegen_name_token(p)) // NAME
2205 [ + + ]: 1574727 : &&
2206 : 1574727 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
2207 [ + + ]: 9490 : &&
2208 : 9490 : (b = expression_rule(p)) // expression
2209 : 9486 : &&
2210 [ + - ]: 9486 : (c = _tmp_11_rule(p), !p->error_indicator) // ['=' annotated_rhs]
2211 : : )
2212 : : {
2213 : : D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
2214 : 9486 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2215 [ - + ]: 9486 : if (_token == NULL) {
2216 : 0 : p->level--;
2217 : 0 : return NULL;
2218 : : }
2219 : 9486 : int _end_lineno = _token->end_lineno;
2220 : : UNUSED(_end_lineno); // Only used by EXTRA macro
2221 : 9486 : int _end_col_offset = _token->end_col_offset;
2222 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
2223 : 9486 : _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 [ - + - - ]: 9486 : if (_res == NULL && PyErr_Occurred()) {
2225 : 0 : p->error_indicator = 1;
2226 : 0 : p->level--;
2227 : 0 : return NULL;
2228 : : }
2229 : 9486 : goto done;
2230 : : }
2231 : 3201376 : 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 [ + + ]: 3201376 : if (p->error_indicator) {
2237 : 3 : p->level--;
2238 : 3 : 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 [ + + ]: 3201373 : if (
2246 : 3201373 : (a = _tmp_12_rule(p)) // '(' single_target ')' | single_subscript_attribute_target
2247 [ + + ]: 178230 : &&
2248 : 178230 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
2249 [ + - ]: 1969 : &&
2250 : 1969 : (b = expression_rule(p)) // expression
2251 : 1969 : &&
2252 [ + - ]: 1969 : (c = _tmp_13_rule(p), !p->error_indicator) // ['=' annotated_rhs]
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 : 1969 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2257 [ - + ]: 1969 : if (_token == NULL) {
2258 : 0 : p->level--;
2259 : 0 : return NULL;
2260 : : }
2261 : 1969 : int _end_lineno = _token->end_lineno;
2262 : : UNUSED(_end_lineno); // Only used by EXTRA macro
2263 : 1969 : int _end_col_offset = _token->end_col_offset;
2264 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
2265 : 1969 : _res = CHECK_VERSION ( stmt_ty , 6 , "Variable annotations syntax is" , _PyAST_AnnAssign ( a , b , c , 0 , EXTRA ) );
2266 [ - + - - ]: 1969 : if (_res == NULL && PyErr_Occurred()) {
2267 : 0 : p->error_indicator = 1;
2268 : 0 : p->level--;
2269 : 0 : return NULL;
2270 : : }
2271 : 1969 : goto done;
2272 : : }
2273 : 3199404 : 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 [ + + ]: 3199404 : if (p->error_indicator) {
2279 : 224 : p->level--;
2280 : 224 : 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 [ + + ]: 3199180 : if (
2287 : 3199180 : (a = (asdl_expr_seq*)_loop1_14_rule(p)) // ((star_targets '='))+
2288 [ + + ]: 803173 : &&
2289 : 803173 : (b = _tmp_15_rule(p)) // yield_expr | star_expressions
2290 [ + + ]: 803157 : &&
2291 : 803157 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='='
2292 : 803153 : &&
2293 [ + - ]: 803153 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
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 : 803153 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2298 [ - + ]: 803153 : if (_token == NULL) {
2299 : 0 : p->level--;
2300 : 0 : return NULL;
2301 : : }
2302 : 803153 : int _end_lineno = _token->end_lineno;
2303 : : UNUSED(_end_lineno); // Only used by EXTRA macro
2304 : 803153 : int _end_col_offset = _token->end_col_offset;
2305 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
2306 : 803153 : _res = _PyAST_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
2307 [ - + - - ]: 803153 : if (_res == NULL && PyErr_Occurred()) {
2308 : 0 : p->error_indicator = 1;
2309 : 0 : p->level--;
2310 : 0 : return NULL;
2311 : : }
2312 : 803153 : goto done;
2313 : : }
2314 : 2396027 : 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 [ + + ]: 2396027 : if (p->error_indicator) {
2320 : 41 : p->level--;
2321 : 41 : 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 : 2395986 : int _cut_var = 0;
2325 : : expr_ty a;
2326 : : AugOperator* b;
2327 : : void *c;
2328 [ + + ]: 2395986 : if (
2329 : 2395986 : (a = single_target_rule(p)) // single_target
2330 [ + + ]: 761806 : &&
2331 : 761806 : (b = augassign_rule(p)) // augassign
2332 : : &&
2333 : 25588 : (_cut_var = 1)
2334 [ + - ]: 25588 : &&
2335 : 25588 : (c = _tmp_16_rule(p)) // yield_expr | star_expressions
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 : 25588 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2340 [ - + ]: 25588 : if (_token == NULL) {
2341 : 0 : p->level--;
2342 : 0 : return NULL;
2343 : : }
2344 : 25588 : int _end_lineno = _token->end_lineno;
2345 : : UNUSED(_end_lineno); // Only used by EXTRA macro
2346 : 25588 : int _end_col_offset = _token->end_col_offset;
2347 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
2348 : 25588 : _res = _PyAST_AugAssign ( a , b -> kind , c , EXTRA );
2349 [ - + - - ]: 25588 : if (_res == NULL && PyErr_Occurred()) {
2350 : 0 : p->error_indicator = 1;
2351 : 0 : p->level--;
2352 : 0 : return NULL;
2353 : : }
2354 : 25588 : goto done;
2355 : : }
2356 : 2370398 : 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 [ - + ]: 2370398 : if (_cut_var) {
2360 : 0 : p->level--;
2361 : 0 : return NULL;
2362 : : }
2363 : : }
2364 [ + + ]: 2370398 : if (p->call_invalid_rules) { // invalid_assignment
2365 [ - + ]: 901 : if (p->error_indicator) {
2366 : 0 : p->level--;
2367 : 0 : 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 [ - + ]: 901 : if (
2372 : 901 : (invalid_assignment_var = invalid_assignment_rule(p)) // invalid_assignment
2373 : : )
2374 : : {
2375 : : D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_assignment"));
2376 : 0 : _res = invalid_assignment_var;
2377 : 0 : goto done;
2378 : : }
2379 : 901 : 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 : 2370398 : _res = NULL;
2384 : 3210594 : done:
2385 : 3210594 : p->level--;
2386 : 3210594 : return _res;
2387 : : }
2388 : :
2389 : : // annotated_rhs: yield_expr | star_expressions
2390 : : static expr_ty
2391 : 7604 : annotated_rhs_rule(Parser *p)
2392 : : {
2393 [ - + ]: 7604 : if (p->level++ == MAXSTACK) {
2394 : 0 : p->error_indicator = 1;
2395 : : PyErr_NoMemory();
2396 : : }
2397 [ - + ]: 7604 : if (p->error_indicator) {
2398 : 0 : p->level--;
2399 : 0 : return NULL;
2400 : : }
2401 : 7604 : expr_ty _res = NULL;
2402 : 7604 : int _mark = p->mark;
2403 : : { // yield_expr
2404 [ - + ]: 7604 : if (p->error_indicator) {
2405 : 0 : p->level--;
2406 : 0 : 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 [ + + ]: 7604 : if (
2411 : 7604 : (yield_expr_var = yield_expr_rule(p)) // yield_expr
2412 : : )
2413 : : {
2414 : : D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
2415 : 1 : _res = yield_expr_var;
2416 : 1 : goto done;
2417 : : }
2418 : 7603 : 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 [ - + ]: 7603 : if (p->error_indicator) {
2424 : 0 : p->level--;
2425 : 0 : 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 [ + - ]: 7603 : if (
2430 : 7603 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
2431 : : )
2432 : : {
2433 : : D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
2434 : 7603 : _res = star_expressions_var;
2435 : 7603 : goto done;
2436 : : }
2437 : 0 : 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 : 0 : _res = NULL;
2442 : 7604 : done:
2443 : 7604 : p->level--;
2444 : 7604 : return _res;
2445 : : }
2446 : :
2447 : : // augassign:
2448 : : // | '+='
2449 : : // | '-='
2450 : : // | '*='
2451 : : // | '@='
2452 : : // | '/='
2453 : : // | '%='
2454 : : // | '&='
2455 : : // | '|='
2456 : : // | '^='
2457 : : // | '<<='
2458 : : // | '>>='
2459 : : // | '**='
2460 : : // | '//='
2461 : : static AugOperator*
2462 : 761937 : augassign_rule(Parser *p)
2463 : : {
2464 [ - + ]: 761937 : if (p->level++ == MAXSTACK) {
2465 : 0 : p->error_indicator = 1;
2466 : : PyErr_NoMemory();
2467 : : }
2468 [ - + ]: 761937 : if (p->error_indicator) {
2469 : 0 : p->level--;
2470 : 0 : return NULL;
2471 : : }
2472 : 761937 : AugOperator* _res = NULL;
2473 : 761937 : int _mark = p->mark;
2474 : : { // '+='
2475 [ - + ]: 761937 : if (p->error_indicator) {
2476 : 0 : p->level--;
2477 : 0 : return NULL;
2478 : : }
2479 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='"));
2480 : : Token * _literal;
2481 [ + + ]: 761937 : if (
2482 : 761937 : (_literal = _PyPegen_expect_token(p, 36)) // token='+='
2483 : : )
2484 : : {
2485 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+='"));
2486 : 18834 : _res = _PyPegen_augoperator ( p , Add );
2487 [ - + - - ]: 18834 : if (_res == NULL && PyErr_Occurred()) {
2488 : 0 : p->error_indicator = 1;
2489 : 0 : p->level--;
2490 : 0 : return NULL;
2491 : : }
2492 : 18834 : goto done;
2493 : : }
2494 : 743103 : 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 [ - + ]: 743103 : if (p->error_indicator) {
2500 : 0 : p->level--;
2501 : 0 : return NULL;
2502 : : }
2503 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='"));
2504 : : Token * _literal;
2505 [ + + ]: 743103 : if (
2506 : 743103 : (_literal = _PyPegen_expect_token(p, 37)) // token='-='
2507 : : )
2508 : : {
2509 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-='"));
2510 : 2726 : _res = _PyPegen_augoperator ( p , Sub );
2511 [ - + - - ]: 2726 : if (_res == NULL && PyErr_Occurred()) {
2512 : 0 : p->error_indicator = 1;
2513 : 0 : p->level--;
2514 : 0 : return NULL;
2515 : : }
2516 : 2726 : goto done;
2517 : : }
2518 : 740377 : 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 [ - + ]: 740377 : if (p->error_indicator) {
2524 : 0 : p->level--;
2525 : 0 : return NULL;
2526 : : }
2527 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='"));
2528 : : Token * _literal;
2529 [ + + ]: 740377 : if (
2530 : 740377 : (_literal = _PyPegen_expect_token(p, 38)) // token='*='
2531 : : )
2532 : : {
2533 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*='"));
2534 : 651 : _res = _PyPegen_augoperator ( p , Mult );
2535 [ - + - - ]: 651 : if (_res == NULL && PyErr_Occurred()) {
2536 : 0 : p->error_indicator = 1;
2537 : 0 : p->level--;
2538 : 0 : return NULL;
2539 : : }
2540 : 651 : goto done;
2541 : : }
2542 : 739726 : 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 [ - + ]: 739726 : if (p->error_indicator) {
2548 : 0 : p->level--;
2549 : 0 : return NULL;
2550 : : }
2551 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='"));
2552 : : Token * _literal;
2553 [ + + ]: 739726 : if (
2554 : 739726 : (_literal = _PyPegen_expect_token(p, 50)) // token='@='
2555 : : )
2556 : : {
2557 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@='"));
2558 : 45 : _res = CHECK_VERSION ( AugOperator* , 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) );
2559 [ - + - - ]: 45 : if (_res == NULL && PyErr_Occurred()) {
2560 : 0 : p->error_indicator = 1;
2561 : 0 : p->level--;
2562 : 0 : return NULL;
2563 : : }
2564 : 45 : goto done;
2565 : : }
2566 : 739681 : 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 [ - + ]: 739681 : if (p->error_indicator) {
2572 : 0 : p->level--;
2573 : 0 : return NULL;
2574 : : }
2575 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='"));
2576 : : Token * _literal;
2577 [ + + ]: 739681 : if (
2578 : 739681 : (_literal = _PyPegen_expect_token(p, 39)) // token='/='
2579 : : )
2580 : : {
2581 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/='"));
2582 : 126 : _res = _PyPegen_augoperator ( p , Div );
2583 [ - + - - ]: 126 : if (_res == NULL && PyErr_Occurred()) {
2584 : 0 : p->error_indicator = 1;
2585 : 0 : p->level--;
2586 : 0 : return NULL;
2587 : : }
2588 : 126 : goto done;
2589 : : }
2590 : 739555 : 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 [ - + ]: 739555 : if (p->error_indicator) {
2596 : 0 : p->level--;
2597 : 0 : return NULL;
2598 : : }
2599 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='"));
2600 : : Token * _literal;
2601 [ + + ]: 739555 : if (
2602 : 739555 : (_literal = _PyPegen_expect_token(p, 40)) // token='%='
2603 : : )
2604 : : {
2605 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%='"));
2606 : 73 : _res = _PyPegen_augoperator ( p , Mod );
2607 [ - + - - ]: 73 : if (_res == NULL && PyErr_Occurred()) {
2608 : 0 : p->error_indicator = 1;
2609 : 0 : p->level--;
2610 : 0 : return NULL;
2611 : : }
2612 : 73 : goto done;
2613 : : }
2614 : 739482 : 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 [ - + ]: 739482 : if (p->error_indicator) {
2620 : 0 : p->level--;
2621 : 0 : return NULL;
2622 : : }
2623 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='"));
2624 : : Token * _literal;
2625 [ + + ]: 739482 : if (
2626 : 739482 : (_literal = _PyPegen_expect_token(p, 41)) // token='&='
2627 : : )
2628 : : {
2629 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'&='"));
2630 : 477 : _res = _PyPegen_augoperator ( p , BitAnd );
2631 [ - + - - ]: 477 : if (_res == NULL && PyErr_Occurred()) {
2632 : 0 : p->error_indicator = 1;
2633 : 0 : p->level--;
2634 : 0 : return NULL;
2635 : : }
2636 : 477 : goto done;
2637 : : }
2638 : 739005 : 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 [ - + ]: 739005 : if (p->error_indicator) {
2644 : 0 : p->level--;
2645 : 0 : return NULL;
2646 : : }
2647 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='"));
2648 : : Token * _literal;
2649 [ + + ]: 739005 : if (
2650 : 739005 : (_literal = _PyPegen_expect_token(p, 42)) // token='|='
2651 : : )
2652 : : {
2653 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|='"));
2654 : 1692 : _res = _PyPegen_augoperator ( p , BitOr );
2655 [ - + - - ]: 1692 : if (_res == NULL && PyErr_Occurred()) {
2656 : 0 : p->error_indicator = 1;
2657 : 0 : p->level--;
2658 : 0 : return NULL;
2659 : : }
2660 : 1692 : goto done;
2661 : : }
2662 : 737313 : 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 [ - + ]: 737313 : if (p->error_indicator) {
2668 : 0 : p->level--;
2669 : 0 : return NULL;
2670 : : }
2671 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='"));
2672 : : Token * _literal;
2673 [ + + ]: 737313 : if (
2674 : 737313 : (_literal = _PyPegen_expect_token(p, 43)) // token='^='
2675 : : )
2676 : : {
2677 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'^='"));
2678 : 212 : _res = _PyPegen_augoperator ( p , BitXor );
2679 [ - + - - ]: 212 : if (_res == NULL && PyErr_Occurred()) {
2680 : 0 : p->error_indicator = 1;
2681 : 0 : p->level--;
2682 : 0 : return NULL;
2683 : : }
2684 : 212 : goto done;
2685 : : }
2686 : 737101 : 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 [ - + ]: 737101 : if (p->error_indicator) {
2692 : 0 : p->level--;
2693 : 0 : return NULL;
2694 : : }
2695 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='"));
2696 : : Token * _literal;
2697 [ + + ]: 737101 : if (
2698 : 737101 : (_literal = _PyPegen_expect_token(p, 44)) // token='<<='
2699 : : )
2700 : : {
2701 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<<='"));
2702 : 269 : _res = _PyPegen_augoperator ( p , LShift );
2703 [ - + - - ]: 269 : if (_res == NULL && PyErr_Occurred()) {
2704 : 0 : p->error_indicator = 1;
2705 : 0 : p->level--;
2706 : 0 : return NULL;
2707 : : }
2708 : 269 : goto done;
2709 : : }
2710 : 736832 : 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 [ - + ]: 736832 : if (p->error_indicator) {
2716 : 0 : p->level--;
2717 : 0 : return NULL;
2718 : : }
2719 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='"));
2720 : : Token * _literal;
2721 [ + + ]: 736832 : if (
2722 : 736832 : (_literal = _PyPegen_expect_token(p, 45)) // token='>>='
2723 : : )
2724 : : {
2725 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>>='"));
2726 : 82 : _res = _PyPegen_augoperator ( p , RShift );
2727 [ - + - - ]: 82 : if (_res == NULL && PyErr_Occurred()) {
2728 : 0 : p->error_indicator = 1;
2729 : 0 : p->level--;
2730 : 0 : return NULL;
2731 : : }
2732 : 82 : goto done;
2733 : : }
2734 : 736750 : 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 [ - + ]: 736750 : if (p->error_indicator) {
2740 : 0 : p->level--;
2741 : 0 : return NULL;
2742 : : }
2743 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='"));
2744 : : Token * _literal;
2745 [ + + ]: 736750 : if (
2746 : 736750 : (_literal = _PyPegen_expect_token(p, 46)) // token='**='
2747 : : )
2748 : : {
2749 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**='"));
2750 : 58 : _res = _PyPegen_augoperator ( p , Pow );
2751 [ - + - - ]: 58 : if (_res == NULL && PyErr_Occurred()) {
2752 : 0 : p->error_indicator = 1;
2753 : 0 : p->level--;
2754 : 0 : return NULL;
2755 : : }
2756 : 58 : goto done;
2757 : : }
2758 : 736692 : 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 [ - + ]: 736692 : if (p->error_indicator) {
2764 : 0 : p->level--;
2765 : 0 : return NULL;
2766 : : }
2767 : : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='"));
2768 : : Token * _literal;
2769 [ + + ]: 736692 : if (
2770 : 736692 : (_literal = _PyPegen_expect_token(p, 48)) // token='//='
2771 : : )
2772 : : {
2773 : : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//='"));
2774 : 357 : _res = _PyPegen_augoperator ( p , FloorDiv );
2775 [ - + - - ]: 357 : if (_res == NULL && PyErr_Occurred()) {
2776 : 0 : p->error_indicator = 1;
2777 : 0 : p->level--;
2778 : 0 : return NULL;
2779 : : }
2780 : 357 : goto done;
2781 : : }
2782 : 736335 : 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 : 736335 : _res = NULL;
2787 : 761937 : done:
2788 : 761937 : p->level--;
2789 : 761937 : return _res;
2790 : : }
2791 : :
2792 : : // return_stmt: 'return' star_expressions?
2793 : : static stmt_ty
2794 : 239070 : return_stmt_rule(Parser *p)
2795 : : {
2796 [ - + ]: 239070 : if (p->level++ == MAXSTACK) {
2797 : 0 : p->error_indicator = 1;
2798 : : PyErr_NoMemory();
2799 : : }
2800 [ - + ]: 239070 : if (p->error_indicator) {
2801 : 0 : p->level--;
2802 : 0 : return NULL;
2803 : : }
2804 : 239070 : stmt_ty _res = NULL;
2805 : 239070 : int _mark = p->mark;
2806 [ - + - - ]: 239070 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
2807 : 0 : p->error_indicator = 1;
2808 : 0 : p->level--;
2809 : 0 : return NULL;
2810 : : }
2811 : 239070 : int _start_lineno = p->tokens[_mark]->lineno;
2812 : : UNUSED(_start_lineno); // Only used by EXTRA macro
2813 : 239070 : int _start_col_offset = p->tokens[_mark]->col_offset;
2814 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
2815 : : { // 'return' star_expressions?
2816 [ - + ]: 239070 : if (p->error_indicator) {
2817 : 0 : p->level--;
2818 : 0 : 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 [ + - ]: 239070 : if (
2824 : 239070 : (_keyword = _PyPegen_expect_token(p, 519)) // token='return'
2825 : 239070 : &&
2826 [ + + ]: 239070 : (a = star_expressions_rule(p), !p->error_indicator) // star_expressions?
2827 : : )
2828 : : {
2829 : : D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?"));
2830 : 239069 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2831 [ - + ]: 239069 : if (_token == NULL) {
2832 : 0 : p->level--;
2833 : 0 : return NULL;
2834 : : }
2835 : 239069 : int _end_lineno = _token->end_lineno;
2836 : : UNUSED(_end_lineno); // Only used by EXTRA macro
2837 : 239069 : int _end_col_offset = _token->end_col_offset;
2838 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
2839 : 239069 : _res = _PyAST_Return ( a , EXTRA );
2840 [ - + - - ]: 239069 : if (_res == NULL && PyErr_Occurred()) {
2841 : 0 : p->error_indicator = 1;
2842 : 0 : p->level--;
2843 : 0 : return NULL;
2844 : : }
2845 : 239069 : goto done;
2846 : : }
2847 : 1 : 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 : 1 : _res = NULL;
2852 : 239070 : done:
2853 : 239070 : p->level--;
2854 : 239070 : return _res;
2855 : : }
2856 : :
2857 : : // raise_stmt: 'raise' expression ['from' expression] | 'raise'
2858 : : static stmt_ty
2859 : 61013 : raise_stmt_rule(Parser *p)
2860 : : {
2861 [ - + ]: 61013 : if (p->level++ == MAXSTACK) {
2862 : 0 : p->error_indicator = 1;
2863 : : PyErr_NoMemory();
2864 : : }
2865 [ - + ]: 61013 : if (p->error_indicator) {
2866 : 0 : p->level--;
2867 : 0 : return NULL;
2868 : : }
2869 : 61013 : stmt_ty _res = NULL;
2870 : 61013 : int _mark = p->mark;
2871 [ - + - - ]: 61013 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
2872 : 0 : p->error_indicator = 1;
2873 : 0 : p->level--;
2874 : 0 : return NULL;
2875 : : }
2876 : 61013 : int _start_lineno = p->tokens[_mark]->lineno;
2877 : : UNUSED(_start_lineno); // Only used by EXTRA macro
2878 : 61013 : 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 [ - + ]: 61013 : if (p->error_indicator) {
2882 : 0 : p->level--;
2883 : 0 : 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 [ + - ]: 61013 : if (
2890 : 61013 : (_keyword = _PyPegen_expect_token(p, 522)) // token='raise'
2891 [ + + ]: 61013 : &&
2892 : 61013 : (a = expression_rule(p)) // expression
2893 : 56377 : &&
2894 [ + - ]: 56377 : (b = _tmp_17_rule(p), !p->error_indicator) // ['from' expression]
2895 : : )
2896 : : {
2897 : : D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]"));
2898 : 56377 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2899 [ - + ]: 56377 : if (_token == NULL) {
2900 : 0 : p->level--;
2901 : 0 : return NULL;
2902 : : }
2903 : 56377 : int _end_lineno = _token->end_lineno;
2904 : : UNUSED(_end_lineno); // Only used by EXTRA macro
2905 : 56377 : int _end_col_offset = _token->end_col_offset;
2906 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
2907 : 56377 : _res = _PyAST_Raise ( a , b , EXTRA );
2908 [ - + - - ]: 56377 : if (_res == NULL && PyErr_Occurred()) {
2909 : 0 : p->error_indicator = 1;
2910 : 0 : p->level--;
2911 : 0 : return NULL;
2912 : : }
2913 : 56377 : goto done;
2914 : : }
2915 : 4636 : 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 [ - + ]: 4636 : if (p->error_indicator) {
2921 : 0 : p->level--;
2922 : 0 : return NULL;
2923 : : }
2924 : : D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'"));
2925 : : Token * _keyword;
2926 [ + - ]: 4636 : if (
2927 : 4636 : (_keyword = _PyPegen_expect_token(p, 522)) // token='raise'
2928 : : )
2929 : : {
2930 : : D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise'"));
2931 : 4636 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2932 [ - + ]: 4636 : if (_token == NULL) {
2933 : 0 : p->level--;
2934 : 0 : return NULL;
2935 : : }
2936 : 4636 : int _end_lineno = _token->end_lineno;
2937 : : UNUSED(_end_lineno); // Only used by EXTRA macro
2938 : 4636 : int _end_col_offset = _token->end_col_offset;
2939 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
2940 : 4636 : _res = _PyAST_Raise ( NULL , NULL , EXTRA );
2941 [ - + - - ]: 4636 : if (_res == NULL && PyErr_Occurred()) {
2942 : 0 : p->error_indicator = 1;
2943 : 0 : p->level--;
2944 : 0 : return NULL;
2945 : : }
2946 : 4636 : goto done;
2947 : : }
2948 : 0 : 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 : 0 : _res = NULL;
2953 : 61013 : done:
2954 : 61013 : p->level--;
2955 : 61013 : return _res;
2956 : : }
2957 : :
2958 : : // global_stmt: 'global' ','.NAME+
2959 : : static stmt_ty
2960 : 1818 : global_stmt_rule(Parser *p)
2961 : : {
2962 [ - + ]: 1818 : if (p->level++ == MAXSTACK) {
2963 : 0 : p->error_indicator = 1;
2964 : : PyErr_NoMemory();
2965 : : }
2966 [ - + ]: 1818 : if (p->error_indicator) {
2967 : 0 : p->level--;
2968 : 0 : return NULL;
2969 : : }
2970 : 1818 : stmt_ty _res = NULL;
2971 : 1818 : int _mark = p->mark;
2972 [ - + - - ]: 1818 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
2973 : 0 : p->error_indicator = 1;
2974 : 0 : p->level--;
2975 : 0 : return NULL;
2976 : : }
2977 : 1818 : int _start_lineno = p->tokens[_mark]->lineno;
2978 : : UNUSED(_start_lineno); // Only used by EXTRA macro
2979 : 1818 : int _start_col_offset = p->tokens[_mark]->col_offset;
2980 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
2981 : : { // 'global' ','.NAME+
2982 [ - + ]: 1818 : if (p->error_indicator) {
2983 : 0 : p->level--;
2984 : 0 : 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 [ + - ]: 1818 : if (
2990 : 1818 : (_keyword = _PyPegen_expect_token(p, 523)) // token='global'
2991 [ + + ]: 1818 : &&
2992 : 1818 : (a = (asdl_expr_seq*)_gather_18_rule(p)) // ','.NAME+
2993 : : )
2994 : : {
2995 : : D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+"));
2996 : 1816 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2997 [ - + ]: 1816 : if (_token == NULL) {
2998 : 0 : p->level--;
2999 : 0 : return NULL;
3000 : : }
3001 : 1816 : int _end_lineno = _token->end_lineno;
3002 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3003 : 1816 : int _end_col_offset = _token->end_col_offset;
3004 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3005 : 1816 : _res = _PyAST_Global ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
3006 [ - + - - ]: 1816 : if (_res == NULL && PyErr_Occurred()) {
3007 : 0 : p->error_indicator = 1;
3008 : 0 : p->level--;
3009 : 0 : return NULL;
3010 : : }
3011 : 1816 : goto done;
3012 : : }
3013 : 2 : 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 : 2 : _res = NULL;
3018 : 1818 : done:
3019 : 1818 : p->level--;
3020 : 1818 : return _res;
3021 : : }
3022 : :
3023 : : // nonlocal_stmt: 'nonlocal' ','.NAME+
3024 : : static stmt_ty
3025 : 930 : nonlocal_stmt_rule(Parser *p)
3026 : : {
3027 [ - + ]: 930 : if (p->level++ == MAXSTACK) {
3028 : 0 : p->error_indicator = 1;
3029 : : PyErr_NoMemory();
3030 : : }
3031 [ - + ]: 930 : if (p->error_indicator) {
3032 : 0 : p->level--;
3033 : 0 : return NULL;
3034 : : }
3035 : 930 : stmt_ty _res = NULL;
3036 : 930 : int _mark = p->mark;
3037 [ - + - - ]: 930 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3038 : 0 : p->error_indicator = 1;
3039 : 0 : p->level--;
3040 : 0 : return NULL;
3041 : : }
3042 : 930 : int _start_lineno = p->tokens[_mark]->lineno;
3043 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3044 : 930 : int _start_col_offset = p->tokens[_mark]->col_offset;
3045 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
3046 : : { // 'nonlocal' ','.NAME+
3047 [ - + ]: 930 : if (p->error_indicator) {
3048 : 0 : p->level--;
3049 : 0 : 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 [ + - ]: 930 : if (
3055 : 930 : (_keyword = _PyPegen_expect_token(p, 524)) // token='nonlocal'
3056 [ + + ]: 930 : &&
3057 : 930 : (a = (asdl_expr_seq*)_gather_20_rule(p)) // ','.NAME+
3058 : : )
3059 : : {
3060 : : D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+"));
3061 : 928 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3062 [ - + ]: 928 : if (_token == NULL) {
3063 : 0 : p->level--;
3064 : 0 : return NULL;
3065 : : }
3066 : 928 : int _end_lineno = _token->end_lineno;
3067 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3068 : 928 : int _end_col_offset = _token->end_col_offset;
3069 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3070 : 928 : _res = _PyAST_Nonlocal ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
3071 [ - + - - ]: 928 : if (_res == NULL && PyErr_Occurred()) {
3072 : 0 : p->error_indicator = 1;
3073 : 0 : p->level--;
3074 : 0 : return NULL;
3075 : : }
3076 : 928 : goto done;
3077 : : }
3078 : 2 : 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 : 2 : _res = NULL;
3083 : 930 : done:
3084 : 930 : p->level--;
3085 : 930 : return _res;
3086 : : }
3087 : :
3088 : : // del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt
3089 : : static stmt_ty
3090 : 8844 : del_stmt_rule(Parser *p)
3091 : : {
3092 [ - + ]: 8844 : if (p->level++ == MAXSTACK) {
3093 : 0 : p->error_indicator = 1;
3094 : : PyErr_NoMemory();
3095 : : }
3096 [ - + ]: 8844 : if (p->error_indicator) {
3097 : 0 : p->level--;
3098 : 0 : return NULL;
3099 : : }
3100 : 8844 : stmt_ty _res = NULL;
3101 : 8844 : int _mark = p->mark;
3102 [ - + - - ]: 8844 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3103 : 0 : p->error_indicator = 1;
3104 : 0 : p->level--;
3105 : 0 : return NULL;
3106 : : }
3107 : 8844 : int _start_lineno = p->tokens[_mark]->lineno;
3108 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3109 : 8844 : 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 [ - + ]: 8844 : if (p->error_indicator) {
3113 : 0 : p->level--;
3114 : 0 : 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 [ + - ]: 8844 : if (
3120 : 8844 : (_keyword = _PyPegen_expect_token(p, 603)) // token='del'
3121 [ + + ]: 8844 : &&
3122 : 8844 : (a = del_targets_rule(p)) // del_targets
3123 [ + + ]: 8798 : &&
3124 : 8798 : _PyPegen_lookahead(1, _tmp_22_rule, p)
3125 : : )
3126 : : {
3127 : : D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
3128 : 8764 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3129 [ - + ]: 8764 : if (_token == NULL) {
3130 : 0 : p->level--;
3131 : 0 : return NULL;
3132 : : }
3133 : 8764 : int _end_lineno = _token->end_lineno;
3134 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3135 : 8764 : int _end_col_offset = _token->end_col_offset;
3136 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3137 : 8764 : _res = _PyAST_Delete ( a , EXTRA );
3138 [ - + - - ]: 8764 : if (_res == NULL && PyErr_Occurred()) {
3139 : 0 : p->error_indicator = 1;
3140 : 0 : p->level--;
3141 : 0 : return NULL;
3142 : : }
3143 : 8764 : goto done;
3144 : : }
3145 : 80 : 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 [ + + ]: 80 : if (p->call_invalid_rules) { // invalid_del_stmt
3150 [ + + ]: 38 : if (p->error_indicator) {
3151 : 1 : p->level--;
3152 : 1 : 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 [ - + ]: 37 : if (
3157 : 37 : (invalid_del_stmt_var = invalid_del_stmt_rule(p)) // invalid_del_stmt
3158 : : )
3159 : : {
3160 : : D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt"));
3161 : 0 : _res = invalid_del_stmt_var;
3162 : 0 : goto done;
3163 : : }
3164 : 37 : 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 : 79 : _res = NULL;
3169 : 8843 : done:
3170 : 8843 : p->level--;
3171 : 8843 : return _res;
3172 : : }
3173 : :
3174 : : // yield_stmt: yield_expr
3175 : : static stmt_ty
3176 : 15191 : yield_stmt_rule(Parser *p)
3177 : : {
3178 [ - + ]: 15191 : if (p->level++ == MAXSTACK) {
3179 : 0 : p->error_indicator = 1;
3180 : : PyErr_NoMemory();
3181 : : }
3182 [ - + ]: 15191 : if (p->error_indicator) {
3183 : 0 : p->level--;
3184 : 0 : return NULL;
3185 : : }
3186 : 15191 : stmt_ty _res = NULL;
3187 : 15191 : int _mark = p->mark;
3188 [ - + - - ]: 15191 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3189 : 0 : p->error_indicator = 1;
3190 : 0 : p->level--;
3191 : 0 : return NULL;
3192 : : }
3193 : 15191 : int _start_lineno = p->tokens[_mark]->lineno;
3194 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3195 : 15191 : int _start_col_offset = p->tokens[_mark]->col_offset;
3196 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
3197 : : { // yield_expr
3198 [ - + ]: 15191 : if (p->error_indicator) {
3199 : 0 : p->level--;
3200 : 0 : 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 [ + - ]: 15191 : if (
3205 : 15191 : (y = yield_expr_rule(p)) // yield_expr
3206 : : )
3207 : : {
3208 : : D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
3209 : 15191 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3210 [ - + ]: 15191 : if (_token == NULL) {
3211 : 0 : p->level--;
3212 : 0 : return NULL;
3213 : : }
3214 : 15191 : int _end_lineno = _token->end_lineno;
3215 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3216 : 15191 : int _end_col_offset = _token->end_col_offset;
3217 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3218 : 15191 : _res = _PyAST_Expr ( y , EXTRA );
3219 [ - + - - ]: 15191 : if (_res == NULL && PyErr_Occurred()) {
3220 : 0 : p->error_indicator = 1;
3221 : 0 : p->level--;
3222 : 0 : return NULL;
3223 : : }
3224 : 15191 : goto done;
3225 : : }
3226 : 0 : 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 : 0 : _res = NULL;
3231 : 15191 : done:
3232 : 15191 : p->level--;
3233 : 15191 : return _res;
3234 : : }
3235 : :
3236 : : // assert_stmt: 'assert' expression [',' expression]
3237 : : static stmt_ty
3238 : 9810 : assert_stmt_rule(Parser *p)
3239 : : {
3240 [ - + ]: 9810 : if (p->level++ == MAXSTACK) {
3241 : 0 : p->error_indicator = 1;
3242 : : PyErr_NoMemory();
3243 : : }
3244 [ - + ]: 9810 : if (p->error_indicator) {
3245 : 0 : p->level--;
3246 : 0 : return NULL;
3247 : : }
3248 : 9810 : stmt_ty _res = NULL;
3249 : 9810 : int _mark = p->mark;
3250 [ - + - - ]: 9810 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3251 : 0 : p->error_indicator = 1;
3252 : 0 : p->level--;
3253 : 0 : return NULL;
3254 : : }
3255 : 9810 : int _start_lineno = p->tokens[_mark]->lineno;
3256 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3257 : 9810 : int _start_col_offset = p->tokens[_mark]->col_offset;
3258 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
3259 : : { // 'assert' expression [',' expression]
3260 [ - + ]: 9810 : if (p->error_indicator) {
3261 : 0 : p->level--;
3262 : 0 : 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 [ + - ]: 9810 : if (
3269 : 9810 : (_keyword = _PyPegen_expect_token(p, 526)) // token='assert'
3270 [ + + ]: 9810 : &&
3271 : 9810 : (a = expression_rule(p)) // expression
3272 : 9808 : &&
3273 [ + - ]: 9808 : (b = _tmp_23_rule(p), !p->error_indicator) // [',' expression]
3274 : : )
3275 : : {
3276 : : D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]"));
3277 : 9808 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3278 [ - + ]: 9808 : if (_token == NULL) {
3279 : 0 : p->level--;
3280 : 0 : return NULL;
3281 : : }
3282 : 9808 : int _end_lineno = _token->end_lineno;
3283 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3284 : 9808 : int _end_col_offset = _token->end_col_offset;
3285 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3286 : 9808 : _res = _PyAST_Assert ( a , b , EXTRA );
3287 [ - + - - ]: 9808 : if (_res == NULL && PyErr_Occurred()) {
3288 : 0 : p->error_indicator = 1;
3289 : 0 : p->level--;
3290 : 0 : return NULL;
3291 : : }
3292 : 9808 : goto done;
3293 : : }
3294 : 2 : 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 : 2 : _res = NULL;
3299 : 9810 : done:
3300 : 9810 : p->level--;
3301 : 9810 : return _res;
3302 : : }
3303 : :
3304 : : // import_stmt: import_name | import_from
3305 : : static stmt_ty
3306 : 90627 : import_stmt_rule(Parser *p)
3307 : : {
3308 [ - + ]: 90627 : if (p->level++ == MAXSTACK) {
3309 : 0 : p->error_indicator = 1;
3310 : : PyErr_NoMemory();
3311 : : }
3312 [ - + ]: 90627 : if (p->error_indicator) {
3313 : 0 : p->level--;
3314 : 0 : return NULL;
3315 : : }
3316 : 90627 : stmt_ty _res = NULL;
3317 : 90627 : int _mark = p->mark;
3318 : : { // import_name
3319 [ - + ]: 90627 : if (p->error_indicator) {
3320 : 0 : p->level--;
3321 : 0 : 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 [ + + ]: 90627 : if (
3326 : 90627 : (import_name_var = import_name_rule(p)) // import_name
3327 : : )
3328 : : {
3329 : : D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_name"));
3330 : 44819 : _res = import_name_var;
3331 : 44819 : goto done;
3332 : : }
3333 : 45808 : 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 [ + + ]: 45808 : if (p->error_indicator) {
3339 : 2 : p->level--;
3340 : 2 : 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 [ + + ]: 45806 : if (
3345 : 45806 : (import_from_var = import_from_rule(p)) // import_from
3346 : : )
3347 : : {
3348 : : D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from"));
3349 : 45752 : _res = import_from_var;
3350 : 45752 : goto done;
3351 : : }
3352 : 54 : 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 : 54 : _res = NULL;
3357 : 90625 : done:
3358 : 90625 : p->level--;
3359 : 90625 : return _res;
3360 : : }
3361 : :
3362 : : // import_name: 'import' dotted_as_names
3363 : : static stmt_ty
3364 : 90627 : import_name_rule(Parser *p)
3365 : : {
3366 [ - + ]: 90627 : if (p->level++ == MAXSTACK) {
3367 : 0 : p->error_indicator = 1;
3368 : : PyErr_NoMemory();
3369 : : }
3370 [ - + ]: 90627 : if (p->error_indicator) {
3371 : 0 : p->level--;
3372 : 0 : return NULL;
3373 : : }
3374 : 90627 : stmt_ty _res = NULL;
3375 : 90627 : int _mark = p->mark;
3376 [ - + - - ]: 90627 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3377 : 0 : p->error_indicator = 1;
3378 : 0 : p->level--;
3379 : 0 : return NULL;
3380 : : }
3381 : 90627 : int _start_lineno = p->tokens[_mark]->lineno;
3382 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3383 : 90627 : 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 [ - + ]: 90627 : if (p->error_indicator) {
3387 : 0 : p->level--;
3388 : 0 : 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 [ + + ]: 90627 : if (
3394 : 90627 : (_keyword = _PyPegen_expect_token(p, 531)) // token='import'
3395 [ + + ]: 44837 : &&
3396 : 44837 : (a = dotted_as_names_rule(p)) // dotted_as_names
3397 : : )
3398 : : {
3399 : : D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names"));
3400 : 44819 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3401 [ - + ]: 44819 : if (_token == NULL) {
3402 : 0 : p->level--;
3403 : 0 : return NULL;
3404 : : }
3405 : 44819 : int _end_lineno = _token->end_lineno;
3406 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3407 : 44819 : int _end_col_offset = _token->end_col_offset;
3408 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3409 : 44819 : _res = _PyAST_Import ( a , EXTRA );
3410 [ - + - - ]: 44819 : if (_res == NULL && PyErr_Occurred()) {
3411 : 0 : p->error_indicator = 1;
3412 : 0 : p->level--;
3413 : 0 : return NULL;
3414 : : }
3415 : 44819 : goto done;
3416 : : }
3417 : 45808 : 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 : 45808 : _res = NULL;
3422 : 90627 : done:
3423 : 90627 : p->level--;
3424 : 90627 : 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 : 45806 : import_from_rule(Parser *p)
3432 : : {
3433 [ - + ]: 45806 : if (p->level++ == MAXSTACK) {
3434 : 0 : p->error_indicator = 1;
3435 : : PyErr_NoMemory();
3436 : : }
3437 [ - + ]: 45806 : if (p->error_indicator) {
3438 : 0 : p->level--;
3439 : 0 : return NULL;
3440 : : }
3441 : 45806 : stmt_ty _res = NULL;
3442 : 45806 : int _mark = p->mark;
3443 [ - + - - ]: 45806 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3444 : 0 : p->error_indicator = 1;
3445 : 0 : p->level--;
3446 : 0 : return NULL;
3447 : : }
3448 : 45806 : int _start_lineno = p->tokens[_mark]->lineno;
3449 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3450 : 45806 : 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 [ - + ]: 45806 : if (p->error_indicator) {
3454 : 0 : p->level--;
3455 : 0 : 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 [ + + ]: 45806 : if (
3464 : 45806 : (_keyword = _PyPegen_expect_token(p, 572)) // token='from'
3465 [ + - ]: 45790 : &&
3466 : 45790 : (a = _loop0_24_rule(p)) // (('.' | '...'))*
3467 [ + + ]: 45790 : &&
3468 : 45790 : (b = dotted_name_rule(p)) // dotted_name
3469 [ + - ]: 44528 : &&
3470 : 44528 : (_keyword_1 = _PyPegen_expect_token(p, 531)) // token='import'
3471 [ + + ]: 44528 : &&
3472 : 44528 : (c = import_from_targets_rule(p)) // import_from_targets
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 : 44494 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3477 [ - + ]: 44494 : if (_token == NULL) {
3478 : 0 : p->level--;
3479 : 0 : return NULL;
3480 : : }
3481 : 44494 : int _end_lineno = _token->end_lineno;
3482 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3483 : 44494 : int _end_col_offset = _token->end_col_offset;
3484 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3485 : 44494 : _res = _PyAST_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA );
3486 [ - + - - ]: 44494 : if (_res == NULL && PyErr_Occurred()) {
3487 : 0 : p->error_indicator = 1;
3488 : 0 : p->level--;
3489 : 0 : return NULL;
3490 : : }
3491 : 44494 : goto done;
3492 : : }
3493 : 1312 : 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 [ + + ]: 1312 : if (p->error_indicator) {
3499 : 19 : p->level--;
3500 : 19 : 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 [ + + ]: 1293 : if (
3508 : 1293 : (_keyword = _PyPegen_expect_token(p, 572)) // token='from'
3509 [ + + ]: 1277 : &&
3510 : 1277 : (a = _loop1_25_rule(p)) // (('.' | '...'))+
3511 [ + - ]: 1258 : &&
3512 : 1258 : (_keyword_1 = _PyPegen_expect_token(p, 531)) // token='import'
3513 [ + - ]: 1258 : &&
3514 : 1258 : (b = import_from_targets_rule(p)) // import_from_targets
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 : 1258 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3519 [ - + ]: 1258 : if (_token == NULL) {
3520 : 0 : p->level--;
3521 : 0 : return NULL;
3522 : : }
3523 : 1258 : int _end_lineno = _token->end_lineno;
3524 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3525 : 1258 : int _end_col_offset = _token->end_col_offset;
3526 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3527 : 1258 : _res = _PyAST_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA );
3528 [ - + - - ]: 1258 : if (_res == NULL && PyErr_Occurred()) {
3529 : 0 : p->error_indicator = 1;
3530 : 0 : p->level--;
3531 : 0 : return NULL;
3532 : : }
3533 : 1258 : goto done;
3534 : : }
3535 : 35 : 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 : 35 : _res = NULL;
3540 : 45787 : done:
3541 : 45787 : p->level--;
3542 : 45787 : 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 : 45786 : import_from_targets_rule(Parser *p)
3552 : : {
3553 [ - + ]: 45786 : if (p->level++ == MAXSTACK) {
3554 : 0 : p->error_indicator = 1;
3555 : : PyErr_NoMemory();
3556 : : }
3557 [ - + ]: 45786 : if (p->error_indicator) {
3558 : 0 : p->level--;
3559 : 0 : return NULL;
3560 : : }
3561 : 45786 : asdl_alias_seq* _res = NULL;
3562 : 45786 : int _mark = p->mark;
3563 [ + + - + ]: 45786 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3564 : 0 : p->error_indicator = 1;
3565 : 0 : p->level--;
3566 : 0 : return NULL;
3567 : : }
3568 : 45786 : int _start_lineno = p->tokens[_mark]->lineno;
3569 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3570 : 45786 : 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 [ - + ]: 45786 : if (p->error_indicator) {
3574 : 0 : p->level--;
3575 : 0 : 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 [ + + ]: 45786 : if (
3584 : 45786 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
3585 [ + + ]: 2196 : &&
3586 : 2196 : (a = import_from_as_names_rule(p)) // import_from_as_names
3587 : 2188 : &&
3588 [ + + ]: 2188 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
3589 [ + + ]: 2182 : &&
3590 : 2182 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
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 : 2180 : _res = a;
3595 [ - + - - ]: 2180 : if (_res == NULL && PyErr_Occurred()) {
3596 : 0 : p->error_indicator = 1;
3597 : 0 : p->level--;
3598 : 0 : return NULL;
3599 : : }
3600 : 2180 : goto done;
3601 : : }
3602 : 43606 : 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 [ + + ]: 43606 : if (p->error_indicator) {
3608 : 12 : p->level--;
3609 : 12 : 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 [ + + ]: 43594 : if (
3614 : 43594 : (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names
3615 [ + + ]: 42493 : &&
3616 : 42493 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
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 : 42481 : _res = import_from_as_names_var;
3621 : 42481 : goto done;
3622 : : }
3623 : 1113 : 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 [ + + ]: 1113 : if (p->error_indicator) {
3629 : 2 : p->level--;
3630 : 2 : return NULL;
3631 : : }
3632 : : D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
3633 : : Token * _literal;
3634 [ + + ]: 1111 : if (
3635 : 1111 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
3636 : : )
3637 : : {
3638 : : D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'"));
3639 : 1091 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3640 [ - + ]: 1091 : if (_token == NULL) {
3641 : 0 : p->level--;
3642 : 0 : return NULL;
3643 : : }
3644 : 1091 : int _end_lineno = _token->end_lineno;
3645 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3646 : 1091 : int _end_col_offset = _token->end_col_offset;
3647 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3648 : 1091 : _res = ( asdl_alias_seq* ) _PyPegen_singleton_seq ( p , CHECK ( alias_ty , _PyPegen_alias_for_star ( p , EXTRA ) ) );
3649 [ - + - - ]: 1091 : if (_res == NULL && PyErr_Occurred()) {
3650 : 0 : p->error_indicator = 1;
3651 : 0 : p->level--;
3652 : 0 : return NULL;
3653 : : }
3654 : 1091 : goto done;
3655 : : }
3656 : 20 : 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 [ + + ]: 20 : if (p->call_invalid_rules) { // invalid_import_from_targets
3661 [ - + ]: 10 : if (p->error_indicator) {
3662 : 0 : p->level--;
3663 : 0 : 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 [ - + ]: 10 : if (
3668 : 10 : (invalid_import_from_targets_var = invalid_import_from_targets_rule(p)) // invalid_import_from_targets
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 : 0 : _res = invalid_import_from_targets_var;
3673 : 0 : goto done;
3674 : : }
3675 : 10 : 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 : 20 : _res = NULL;
3680 : 45772 : done:
3681 : 45772 : p->level--;
3682 : 45772 : return _res;
3683 : : }
3684 : :
3685 : : // import_from_as_names: ','.import_from_as_name+
3686 : : static asdl_alias_seq*
3687 : 45800 : import_from_as_names_rule(Parser *p)
3688 : : {
3689 [ - + ]: 45800 : if (p->level++ == MAXSTACK) {
3690 : 0 : p->error_indicator = 1;
3691 : : PyErr_NoMemory();
3692 : : }
3693 [ - + ]: 45800 : if (p->error_indicator) {
3694 : 0 : p->level--;
3695 : 0 : return NULL;
3696 : : }
3697 : 45800 : asdl_alias_seq* _res = NULL;
3698 : 45800 : int _mark = p->mark;
3699 : : { // ','.import_from_as_name+
3700 [ - + ]: 45800 : if (p->error_indicator) {
3701 : 0 : p->level--;
3702 : 0 : 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 [ + + ]: 45800 : if (
3707 : 45800 : (a = (asdl_alias_seq*)_gather_26_rule(p)) // ','.import_from_as_name+
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 : 44687 : _res = a;
3712 [ - + - - ]: 44687 : if (_res == NULL && PyErr_Occurred()) {
3713 : 0 : p->error_indicator = 1;
3714 : 0 : p->level--;
3715 : 0 : return NULL;
3716 : : }
3717 : 44687 : goto done;
3718 : : }
3719 : 1113 : 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 : 1113 : _res = NULL;
3724 : 45800 : done:
3725 : 45800 : p->level--;
3726 : 45800 : return _res;
3727 : : }
3728 : :
3729 : : // import_from_as_name: NAME ['as' NAME]
3730 : : static alias_ty
3731 : 79369 : import_from_as_name_rule(Parser *p)
3732 : : {
3733 [ - + ]: 79369 : if (p->level++ == MAXSTACK) {
3734 : 0 : p->error_indicator = 1;
3735 : : PyErr_NoMemory();
3736 : : }
3737 [ - + ]: 79369 : if (p->error_indicator) {
3738 : 0 : p->level--;
3739 : 0 : return NULL;
3740 : : }
3741 : 79369 : alias_ty _res = NULL;
3742 : 79369 : int _mark = p->mark;
3743 [ + + + + ]: 79369 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3744 : 6 : p->error_indicator = 1;
3745 : 6 : p->level--;
3746 : 6 : return NULL;
3747 : : }
3748 : 79363 : int _start_lineno = p->tokens[_mark]->lineno;
3749 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3750 : 79363 : int _start_col_offset = p->tokens[_mark]->col_offset;
3751 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
3752 : : { // NAME ['as' NAME]
3753 [ - + ]: 79363 : if (p->error_indicator) {
3754 : 0 : p->level--;
3755 : 0 : 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 [ + + ]: 79363 : if (
3761 : 79363 : (a = _PyPegen_name_token(p)) // NAME
3762 : 76884 : &&
3763 [ + + ]: 76884 : (b = _tmp_28_rule(p), !p->error_indicator) // ['as' NAME]
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 : 76876 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3768 [ - + ]: 76876 : if (_token == NULL) {
3769 : 0 : p->level--;
3770 : 0 : return NULL;
3771 : : }
3772 : 76876 : int _end_lineno = _token->end_lineno;
3773 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3774 : 76876 : int _end_col_offset = _token->end_col_offset;
3775 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3776 [ + + ]: 76876 : _res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXTRA );
3777 [ - + - - ]: 76876 : if (_res == NULL && PyErr_Occurred()) {
3778 : 0 : p->error_indicator = 1;
3779 : 0 : p->level--;
3780 : 0 : return NULL;
3781 : : }
3782 : 76876 : goto done;
3783 : : }
3784 : 2487 : 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 : 2487 : _res = NULL;
3789 : 79363 : done:
3790 : 79363 : p->level--;
3791 : 79363 : return _res;
3792 : : }
3793 : :
3794 : : // dotted_as_names: ','.dotted_as_name+
3795 : : static asdl_alias_seq*
3796 : 44837 : dotted_as_names_rule(Parser *p)
3797 : : {
3798 [ - + ]: 44837 : if (p->level++ == MAXSTACK) {
3799 : 0 : p->error_indicator = 1;
3800 : : PyErr_NoMemory();
3801 : : }
3802 [ - + ]: 44837 : if (p->error_indicator) {
3803 : 0 : p->level--;
3804 : 0 : return NULL;
3805 : : }
3806 : 44837 : asdl_alias_seq* _res = NULL;
3807 : 44837 : int _mark = p->mark;
3808 : : { // ','.dotted_as_name+
3809 [ - + ]: 44837 : if (p->error_indicator) {
3810 : 0 : p->level--;
3811 : 0 : 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 [ + + ]: 44837 : if (
3816 : 44837 : (a = (asdl_alias_seq*)_gather_29_rule(p)) // ','.dotted_as_name+
3817 : : )
3818 : : {
3819 : : D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+"));
3820 : 44819 : _res = a;
3821 [ - + - - ]: 44819 : if (_res == NULL && PyErr_Occurred()) {
3822 : 0 : p->error_indicator = 1;
3823 : 0 : p->level--;
3824 : 0 : return NULL;
3825 : : }
3826 : 44819 : goto done;
3827 : : }
3828 : 18 : 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 : 18 : _res = NULL;
3833 : 44837 : done:
3834 : 44837 : p->level--;
3835 : 44837 : return _res;
3836 : : }
3837 : :
3838 : : // dotted_as_name: dotted_name ['as' NAME]
3839 : : static alias_ty
3840 : 46094 : dotted_as_name_rule(Parser *p)
3841 : : {
3842 [ - + ]: 46094 : if (p->level++ == MAXSTACK) {
3843 : 0 : p->error_indicator = 1;
3844 : : PyErr_NoMemory();
3845 : : }
3846 [ - + ]: 46094 : if (p->error_indicator) {
3847 : 0 : p->level--;
3848 : 0 : return NULL;
3849 : : }
3850 : 46094 : alias_ty _res = NULL;
3851 : 46094 : int _mark = p->mark;
3852 [ + + - + ]: 46094 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3853 : 0 : p->error_indicator = 1;
3854 : 0 : p->level--;
3855 : 0 : return NULL;
3856 : : }
3857 : 46094 : int _start_lineno = p->tokens[_mark]->lineno;
3858 : : UNUSED(_start_lineno); // Only used by EXTRA macro
3859 : 46094 : 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 [ - + ]: 46094 : if (p->error_indicator) {
3863 : 0 : p->level--;
3864 : 0 : 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 [ + + ]: 46094 : if (
3870 : 46094 : (a = dotted_name_rule(p)) // dotted_name
3871 : 46076 : &&
3872 [ + - ]: 46076 : (b = _tmp_31_rule(p), !p->error_indicator) // ['as' NAME]
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 : 46076 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3877 [ - + ]: 46076 : if (_token == NULL) {
3878 : 0 : p->level--;
3879 : 0 : return NULL;
3880 : : }
3881 : 46076 : int _end_lineno = _token->end_lineno;
3882 : : UNUSED(_end_lineno); // Only used by EXTRA macro
3883 : 46076 : int _end_col_offset = _token->end_col_offset;
3884 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
3885 [ + + ]: 46076 : _res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXTRA );
3886 [ - + - - ]: 46076 : if (_res == NULL && PyErr_Occurred()) {
3887 : 0 : p->error_indicator = 1;
3888 : 0 : p->level--;
3889 : 0 : return NULL;
3890 : : }
3891 : 46076 : goto done;
3892 : : }
3893 : 18 : 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 : 18 : _res = NULL;
3898 : 46094 : done:
3899 : 46094 : p->level--;
3900 : 46094 : 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 : 314399 : dotted_name_rule(Parser *p)
3908 : : {
3909 [ - + ]: 314399 : if (p->level++ == MAXSTACK) {
3910 : 0 : p->error_indicator = 1;
3911 : : PyErr_NoMemory();
3912 : : }
3913 : 314399 : expr_ty _res = NULL;
3914 [ + + ]: 314399 : if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) {
3915 : 222515 : p->level--;
3916 : 222515 : return _res;
3917 : : }
3918 : 91884 : int _mark = p->mark;
3919 : 91884 : int _resmark = p->mark;
3920 : 130631 : while (1) {
3921 : 222515 : int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res);
3922 [ - + ]: 222515 : if (tmpvar_0) {
3923 : 0 : p->level--;
3924 : 0 : return _res;
3925 : : }
3926 : 222515 : p->mark = _mark;
3927 : 222515 : void *_raw = dotted_name_raw(p);
3928 [ + + ]: 222515 : if (p->error_indicator) {
3929 : 2 : p->level--;
3930 : 2 : return NULL;
3931 : : }
3932 [ + + + + ]: 222513 : if (_raw == NULL || p->mark <= _resmark)
3933 : : break;
3934 : 130631 : _resmark = p->mark;
3935 : 130631 : _res = _raw;
3936 : : }
3937 : 91882 : p->mark = _resmark;
3938 : 91882 : p->level--;
3939 : 91882 : return _res;
3940 : : }
3941 : : static expr_ty
3942 : 222515 : dotted_name_raw(Parser *p)
3943 : : {
3944 [ - + ]: 222515 : if (p->level++ == MAXSTACK) {
3945 : 0 : p->error_indicator = 1;
3946 : : PyErr_NoMemory();
3947 : : }
3948 [ - + ]: 222515 : if (p->error_indicator) {
3949 : 0 : p->level--;
3950 : 0 : return NULL;
3951 : : }
3952 : 222515 : expr_ty _res = NULL;
3953 : 222515 : int _mark = p->mark;
3954 : : { // dotted_name '.' NAME
3955 [ - + ]: 222515 : if (p->error_indicator) {
3956 : 0 : p->level--;
3957 : 0 : 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 [ + + ]: 222515 : if (
3964 : 222515 : (a = dotted_name_rule(p)) // dotted_name
3965 [ + + ]: 130631 : &&
3966 : 130631 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
3967 [ + - ]: 40025 : &&
3968 : 40025 : (b = _PyPegen_name_token(p)) // NAME
3969 : : )
3970 : : {
3971 : : D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME"));
3972 : 40025 : _res = _PyPegen_join_names_with_dot ( p , a , b );
3973 [ - + - - ]: 40025 : if (_res == NULL && PyErr_Occurred()) {
3974 : 0 : p->error_indicator = 1;
3975 : 0 : p->level--;
3976 : 0 : return NULL;
3977 : : }
3978 : 40025 : goto done;
3979 : : }
3980 : 182490 : 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 [ + + ]: 182490 : if (p->error_indicator) {
3986 : 2 : p->level--;
3987 : 2 : 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 [ + + ]: 182488 : if (
3992 : 182488 : (name_var = _PyPegen_name_token(p)) // NAME
3993 : : )
3994 : : {
3995 : : D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
3996 : 181210 : _res = name_var;
3997 : 181210 : goto done;
3998 : : }
3999 : 1278 : 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 : 1278 : _res = NULL;
4004 : 222513 : done:
4005 : 222513 : p->level--;
4006 : 222513 : return _res;
4007 : : }
4008 : :
4009 : : // block: NEWLINE INDENT statements DEDENT | simple_stmts | invalid_block
4010 : : static asdl_stmt_seq*
4011 : 1730065 : block_rule(Parser *p)
4012 : : {
4013 [ - + ]: 1730065 : if (p->level++ == MAXSTACK) {
4014 : 0 : p->error_indicator = 1;
4015 : : PyErr_NoMemory();
4016 : : }
4017 [ - + ]: 1730065 : if (p->error_indicator) {
4018 : 0 : p->level--;
4019 : 0 : return NULL;
4020 : : }
4021 : 1730065 : asdl_stmt_seq* _res = NULL;
4022 [ + + ]: 1730065 : if (_PyPegen_is_memoized(p, block_type, &_res)) {
4023 : 529148 : p->level--;
4024 : 529148 : return _res;
4025 : : }
4026 : 1200917 : int _mark = p->mark;
4027 : : { // NEWLINE INDENT statements DEDENT
4028 [ - + ]: 1200917 : if (p->error_indicator) {
4029 : 0 : p->level--;
4030 : 0 : 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 [ + + ]: 1200917 : if (
4038 : 1200917 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
4039 [ + + ]: 989180 : &&
4040 : 989180 : (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT'
4041 [ + + ]: 989091 : &&
4042 : 989091 : (a = statements_rule(p)) // statements
4043 [ + + ]: 988966 : &&
4044 : 988966 : (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT'
4045 : : )
4046 : : {
4047 : : D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
4048 : 988940 : _res = a;
4049 [ - + - - ]: 988940 : if (_res == NULL && PyErr_Occurred()) {
4050 : 0 : p->error_indicator = 1;
4051 : 0 : p->level--;
4052 : 0 : return NULL;
4053 : : }
4054 : 988940 : goto done;
4055 : : }
4056 : 211977 : 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 [ + + ]: 211977 : if (p->error_indicator) {
4062 : 29 : p->level--;
4063 : 29 : 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 [ + + ]: 211948 : if (
4068 : 211948 : (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts
4069 : : )
4070 : : {
4071 : : D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
4072 : 211597 : _res = simple_stmts_var;
4073 : 211597 : goto done;
4074 : : }
4075 : 351 : 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 [ + + ]: 351 : if (p->call_invalid_rules) { // invalid_block
4080 [ + + ]: 143 : if (p->error_indicator) {
4081 : 7 : p->level--;
4082 : 7 : 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 [ - + ]: 136 : if (
4087 : 136 : (invalid_block_var = invalid_block_rule(p)) // invalid_block
4088 : : )
4089 : : {
4090 : : D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_block"));
4091 : 0 : _res = invalid_block_var;
4092 : 0 : goto done;
4093 : : }
4094 : 136 : 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 : 344 : _res = NULL;
4099 : 1200881 : done:
4100 : 1200881 : _PyPegen_insert_memo(p, _mark, block_type, _res);
4101 : 1200881 : p->level--;
4102 : 1200881 : return _res;
4103 : : }
4104 : :
4105 : : // decorators: (('@' named_expression NEWLINE))+
4106 : : static asdl_expr_seq*
4107 : 400849 : decorators_rule(Parser *p)
4108 : : {
4109 [ - + ]: 400849 : if (p->level++ == MAXSTACK) {
4110 : 0 : p->error_indicator = 1;
4111 : : PyErr_NoMemory();
4112 : : }
4113 [ - + ]: 400849 : if (p->error_indicator) {
4114 : 0 : p->level--;
4115 : 0 : return NULL;
4116 : : }
4117 : 400849 : asdl_expr_seq* _res = NULL;
4118 : 400849 : int _mark = p->mark;
4119 : : { // (('@' named_expression NEWLINE))+
4120 [ - + ]: 400849 : if (p->error_indicator) {
4121 : 0 : p->level--;
4122 : 0 : 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 [ + + ]: 400849 : if (
4127 : 400849 : (a = (asdl_expr_seq*)_loop1_32_rule(p)) // (('@' named_expression NEWLINE))+
4128 : : )
4129 : : {
4130 : : D(fprintf(stderr, "%*c+ decorators[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+"));
4131 : 37344 : _res = a;
4132 [ - + - - ]: 37344 : if (_res == NULL && PyErr_Occurred()) {
4133 : 0 : p->error_indicator = 1;
4134 : 0 : p->level--;
4135 : 0 : return NULL;
4136 : : }
4137 : 37344 : goto done;
4138 : : }
4139 : 363505 : 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 : 363505 : _res = NULL;
4144 : 400849 : done:
4145 : 400849 : p->level--;
4146 : 400849 : return _res;
4147 : : }
4148 : :
4149 : : // class_def: decorators class_def_raw | class_def_raw
4150 : : static stmt_ty
4151 : 56490 : class_def_rule(Parser *p)
4152 : : {
4153 [ - + ]: 56490 : if (p->level++ == MAXSTACK) {
4154 : 0 : p->error_indicator = 1;
4155 : : PyErr_NoMemory();
4156 : : }
4157 [ - + ]: 56490 : if (p->error_indicator) {
4158 : 0 : p->level--;
4159 : 0 : return NULL;
4160 : : }
4161 : 56490 : stmt_ty _res = NULL;
4162 : 56490 : int _mark = p->mark;
4163 : : { // decorators class_def_raw
4164 [ - + ]: 56490 : if (p->error_indicator) {
4165 : 0 : p->level--;
4166 : 0 : 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 [ + + ]: 56490 : if (
4172 : 56490 : (a = decorators_rule(p)) // decorators
4173 [ + - ]: 3181 : &&
4174 : 3181 : (b = class_def_raw_rule(p)) // class_def_raw
4175 : : )
4176 : : {
4177 : : D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw"));
4178 : 3181 : _res = _PyPegen_class_def_decorators ( p , a , b );
4179 [ - + - - ]: 3181 : if (_res == NULL && PyErr_Occurred()) {
4180 : 0 : p->error_indicator = 1;
4181 : 0 : p->level--;
4182 : 0 : return NULL;
4183 : : }
4184 : 3181 : goto done;
4185 : : }
4186 : 53309 : 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 [ - + ]: 53309 : if (p->error_indicator) {
4192 : 0 : p->level--;
4193 : 0 : 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 [ + + ]: 53309 : if (
4198 : 53309 : (class_def_raw_var = class_def_raw_rule(p)) // class_def_raw
4199 : : )
4200 : : {
4201 : : D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_def_raw"));
4202 : 53268 : _res = class_def_raw_var;
4203 : 53268 : goto done;
4204 : : }
4205 : 41 : 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 : 41 : _res = NULL;
4210 : 56490 : done:
4211 : 56490 : p->level--;
4212 : 56490 : return _res;
4213 : : }
4214 : :
4215 : : // class_def_raw: invalid_class_def_raw | 'class' NAME ['(' arguments? ')'] ':' block
4216 : : static stmt_ty
4217 : 56490 : class_def_raw_rule(Parser *p)
4218 : : {
4219 [ - + ]: 56490 : if (p->level++ == MAXSTACK) {
4220 : 0 : p->error_indicator = 1;
4221 : : PyErr_NoMemory();
4222 : : }
4223 [ - + ]: 56490 : if (p->error_indicator) {
4224 : 0 : p->level--;
4225 : 0 : return NULL;
4226 : : }
4227 : 56490 : stmt_ty _res = NULL;
4228 : 56490 : int _mark = p->mark;
4229 [ - + - - ]: 56490 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
4230 : 0 : p->error_indicator = 1;
4231 : 0 : p->level--;
4232 : 0 : return NULL;
4233 : : }
4234 : 56490 : int _start_lineno = p->tokens[_mark]->lineno;
4235 : : UNUSED(_start_lineno); // Only used by EXTRA macro
4236 : 56490 : int _start_col_offset = p->tokens[_mark]->col_offset;
4237 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
4238 [ + + ]: 56490 : if (p->call_invalid_rules) { // invalid_class_def_raw
4239 [ - + ]: 15 : if (p->error_indicator) {
4240 : 0 : p->level--;
4241 : 0 : 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 [ - + ]: 15 : if (
4246 : 15 : (invalid_class_def_raw_var = invalid_class_def_raw_rule(p)) // invalid_class_def_raw
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 : 0 : _res = invalid_class_def_raw_var;
4251 : 0 : goto done;
4252 : : }
4253 : 15 : 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 [ + + ]: 56490 : if (p->error_indicator) {
4259 : 2 : p->level--;
4260 : 2 : 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 [ + + ]: 56488 : if (
4269 : 56488 : (_keyword = _PyPegen_expect_token(p, 646)) // token='class'
4270 [ + + ]: 56479 : &&
4271 : 56479 : (a = _PyPegen_name_token(p)) // NAME
4272 : 56469 : &&
4273 [ + + ]: 56469 : (b = _tmp_33_rule(p), !p->error_indicator) // ['(' arguments? ')']
4274 [ + + ]: 56463 : &&
4275 : 56463 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
4276 [ + + ]: 56458 : &&
4277 : 56458 : (c = block_rule(p)) // block
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 : 56449 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4282 [ - + ]: 56449 : if (_token == NULL) {
4283 : 0 : p->level--;
4284 : 0 : return NULL;
4285 : : }
4286 : 56449 : int _end_lineno = _token->end_lineno;
4287 : : UNUSED(_end_lineno); // Only used by EXTRA macro
4288 : 56449 : int _end_col_offset = _token->end_col_offset;
4289 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
4290 [ + + + + ]: 56449 : _res = _PyAST_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , c , NULL , EXTRA );
4291 [ - + - - ]: 56449 : if (_res == NULL && PyErr_Occurred()) {
4292 : 0 : p->error_indicator = 1;
4293 : 0 : p->level--;
4294 : 0 : return NULL;
4295 : : }
4296 : 56449 : goto done;
4297 : : }
4298 : 39 : 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 : 39 : _res = NULL;
4303 : 56488 : done:
4304 : 56488 : p->level--;
4305 : 56488 : return _res;
4306 : : }
4307 : :
4308 : : // function_def: decorators function_def_raw | function_def_raw
4309 : : static stmt_ty
4310 : 344359 : function_def_rule(Parser *p)
4311 : : {
4312 [ - + ]: 344359 : if (p->level++ == MAXSTACK) {
4313 : 0 : p->error_indicator = 1;
4314 : : PyErr_NoMemory();
4315 : : }
4316 [ - + ]: 344359 : if (p->error_indicator) {
4317 : 0 : p->level--;
4318 : 0 : return NULL;
4319 : : }
4320 : 344359 : stmt_ty _res = NULL;
4321 : 344359 : int _mark = p->mark;
4322 : : { // decorators function_def_raw
4323 [ - + ]: 344359 : if (p->error_indicator) {
4324 : 0 : p->level--;
4325 : 0 : 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 [ + + ]: 344359 : if (
4331 : 344359 : (d = decorators_rule(p)) // decorators
4332 [ + + ]: 34163 : &&
4333 : 34163 : (f = function_def_raw_rule(p)) // function_def_raw
4334 : : )
4335 : : {
4336 : : D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw"));
4337 : 30982 : _res = _PyPegen_function_def_decorators ( p , d , f );
4338 [ - + - - ]: 30982 : if (_res == NULL && PyErr_Occurred()) {
4339 : 0 : p->error_indicator = 1;
4340 : 0 : p->level--;
4341 : 0 : return NULL;
4342 : : }
4343 : 30982 : goto done;
4344 : : }
4345 : 313377 : 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 [ + + ]: 313377 : if (p->error_indicator) {
4351 : 11 : p->level--;
4352 : 11 : 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 [ + + ]: 313366 : if (
4357 : 313366 : (function_def_raw_var = function_def_raw_rule(p)) // function_def_raw
4358 : : )
4359 : : {
4360 : : D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "function_def_raw"));
4361 : 309177 : _res = function_def_raw_var;
4362 : 309177 : goto done;
4363 : : }
4364 : 4189 : 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 : 4189 : _res = NULL;
4369 : 344348 : done:
4370 : 344348 : p->level--;
4371 : 344348 : 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 : 347529 : function_def_raw_rule(Parser *p)
4380 : : {
4381 [ - + ]: 347529 : if (p->level++ == MAXSTACK) {
4382 : 0 : p->error_indicator = 1;
4383 : : PyErr_NoMemory();
4384 : : }
4385 [ - + ]: 347529 : if (p->error_indicator) {
4386 : 0 : p->level--;
4387 : 0 : return NULL;
4388 : : }
4389 : 347529 : stmt_ty _res = NULL;
4390 : 347529 : int _mark = p->mark;
4391 [ - + - - ]: 347529 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
4392 : 0 : p->error_indicator = 1;
4393 : 0 : p->level--;
4394 : 0 : return NULL;
4395 : : }
4396 : 347529 : int _start_lineno = p->tokens[_mark]->lineno;
4397 : : UNUSED(_start_lineno); // Only used by EXTRA macro
4398 : 347529 : int _start_col_offset = p->tokens[_mark]->col_offset;
4399 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
4400 [ + + ]: 347529 : if (p->call_invalid_rules) { // invalid_def_raw
4401 [ - + ]: 217 : if (p->error_indicator) {
4402 : 0 : p->level--;
4403 : 0 : 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 [ - + ]: 217 : if (
4408 : 217 : (invalid_def_raw_var = invalid_def_raw_rule(p)) // invalid_def_raw
4409 : : )
4410 : : {
4411 : : D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_def_raw"));
4412 : 0 : _res = invalid_def_raw_var;
4413 : 0 : goto done;
4414 : : }
4415 : 217 : 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 [ + + ]: 347529 : if (p->error_indicator) {
4421 : 72 : p->level--;
4422 : 72 : 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 [ + + ]: 347457 : if (
4435 : 347457 : (_keyword = _PyPegen_expect_token(p, 644)) // token='def'
4436 [ + + ]: 337020 : &&
4437 : 337020 : (n = _PyPegen_name_token(p)) // NAME
4438 [ + + ]: 337002 : &&
4439 : 337002 : (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='('
4440 : 336997 : &&
4441 [ + + ]: 336997 : (params = params_rule(p), !p->error_indicator) // params?
4442 [ + + ]: 336984 : &&
4443 : 336984 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
4444 : 336834 : &&
4445 [ + - ]: 336834 : (a = _tmp_34_rule(p), !p->error_indicator) // ['->' expression]
4446 [ + + ]: 336834 : &&
4447 : 336834 : (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
4448 : 336833 : &&
4449 [ + + ]: 336833 : (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment?
4450 [ + + ]: 336824 : &&
4451 : 336824 : (b = block_rule(p)) // block
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 : 336747 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4456 [ - + ]: 336747 : if (_token == NULL) {
4457 : 0 : p->level--;
4458 : 0 : return NULL;
4459 : : }
4460 : 336747 : int _end_lineno = _token->end_lineno;
4461 : : UNUSED(_end_lineno); // Only used by EXTRA macro
4462 : 336747 : int _end_col_offset = _token->end_col_offset;
4463 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
4464 [ + + ]: 336747 : _res = _PyAST_FunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
4465 [ - + - - ]: 336747 : if (_res == NULL && PyErr_Occurred()) {
4466 : 0 : p->error_indicator = 1;
4467 : 0 : p->level--;
4468 : 0 : return NULL;
4469 : : }
4470 : 336747 : goto done;
4471 : : }
4472 : 10710 : 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 [ + + ]: 10710 : if (p->error_indicator) {
4478 : 39 : p->level--;
4479 : 39 : 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 [ + + ]: 10671 : if (
4493 : 10671 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
4494 [ + + ]: 4066 : &&
4495 : 4066 : (_keyword = _PyPegen_expect_token(p, 644)) // token='def'
4496 [ + - ]: 3471 : &&
4497 : 3471 : (n = _PyPegen_name_token(p)) // NAME
4498 [ + + ]: 3471 : &&
4499 : 3471 : (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='('
4500 : 3470 : &&
4501 [ + - ]: 3470 : (params = params_rule(p), !p->error_indicator) // params?
4502 [ + + ]: 3470 : &&
4503 : 3470 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
4504 : 3447 : &&
4505 [ + - ]: 3447 : (a = _tmp_35_rule(p), !p->error_indicator) // ['->' expression]
4506 [ + - ]: 3447 : &&
4507 : 3447 : (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
4508 : 3447 : &&
4509 [ + - ]: 3447 : (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment?
4510 [ + + ]: 3447 : &&
4511 : 3447 : (b = block_rule(p)) // block
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 : 3412 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4516 [ - + ]: 3412 : if (_token == NULL) {
4517 : 0 : p->level--;
4518 : 0 : return NULL;
4519 : : }
4520 : 3412 : int _end_lineno = _token->end_lineno;
4521 : : UNUSED(_end_lineno); // Only used by EXTRA macro
4522 : 3412 : int _end_col_offset = _token->end_col_offset;
4523 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
4524 [ + + ]: 3412 : _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 [ - + - - ]: 3412 : if (_res == NULL && PyErr_Occurred()) {
4526 : 0 : p->error_indicator = 1;
4527 : 0 : p->level--;
4528 : 0 : return NULL;
4529 : : }
4530 : 3412 : goto done;
4531 : : }
4532 : 7259 : 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 : 7259 : _res = NULL;
4537 : 347418 : done:
4538 : 347418 : p->level--;
4539 : 347418 : return _res;
4540 : : }
4541 : :
4542 : : // params: invalid_parameters | parameters
4543 : : static arguments_ty
4544 : 340654 : params_rule(Parser *p)
4545 : : {
4546 [ - + ]: 340654 : if (p->level++ == MAXSTACK) {
4547 : 0 : p->error_indicator = 1;
4548 : : PyErr_NoMemory();
4549 : : }
4550 [ - + ]: 340654 : if (p->error_indicator) {
4551 : 0 : p->level--;
4552 : 0 : return NULL;
4553 : : }
4554 : 340654 : arguments_ty _res = NULL;
4555 : 340654 : int _mark = p->mark;
4556 [ + + ]: 340654 : if (p->call_invalid_rules) { // invalid_parameters
4557 [ - + ]: 302 : if (p->error_indicator) {
4558 : 0 : p->level--;
4559 : 0 : 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 [ - + ]: 302 : if (
4564 : 302 : (invalid_parameters_var = invalid_parameters_rule(p)) // invalid_parameters
4565 : : )
4566 : : {
4567 : : D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_parameters"));
4568 : 0 : _res = invalid_parameters_var;
4569 : 0 : goto done;
4570 : : }
4571 : 302 : 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 [ + + ]: 340654 : if (p->error_indicator) {
4577 : 50 : p->level--;
4578 : 50 : 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 [ + + ]: 340604 : if (
4583 : 340604 : (parameters_var = parameters_rule(p)) // parameters
4584 : : )
4585 : : {
4586 : : D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "parameters"));
4587 : 322294 : _res = parameters_var;
4588 : 322294 : goto done;
4589 : : }
4590 : 18310 : 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 : 18310 : _res = NULL;
4595 : 340604 : done:
4596 : 340604 : p->level--;
4597 : 340604 : 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 : 340604 : parameters_rule(Parser *p)
4608 : : {
4609 [ - + ]: 340604 : if (p->level++ == MAXSTACK) {
4610 : 0 : p->error_indicator = 1;
4611 : : PyErr_NoMemory();
4612 : : }
4613 [ - + ]: 340604 : if (p->error_indicator) {
4614 : 0 : p->level--;
4615 : 0 : return NULL;
4616 : : }
4617 : 340604 : arguments_ty _res = NULL;
4618 : 340604 : int _mark = p->mark;
4619 : : { // slash_no_default param_no_default* param_with_default* star_etc?
4620 [ - + ]: 340604 : if (p->error_indicator) {
4621 : 0 : p->level--;
4622 : 0 : 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 [ + + ]: 340604 : if (
4630 : 340604 : (a = slash_no_default_rule(p)) // slash_no_default
4631 [ + - ]: 17578 : &&
4632 : 17578 : (b = (asdl_arg_seq*)_loop0_36_rule(p)) // param_no_default*
4633 [ + - ]: 17578 : &&
4634 : 17578 : (c = _loop0_37_rule(p)) // param_with_default*
4635 : 17578 : &&
4636 [ + + ]: 17578 : (d = star_etc_rule(p), !p->error_indicator) // star_etc?
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 : 17576 : _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
4641 [ - + - - ]: 17576 : if (_res == NULL && PyErr_Occurred()) {
4642 : 0 : p->error_indicator = 1;
4643 : 0 : p->level--;
4644 : 0 : return NULL;
4645 : : }
4646 : 17576 : goto done;
4647 : : }
4648 : 323028 : 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 [ + + ]: 323028 : if (p->error_indicator) {
4654 : 15 : p->level--;
4655 : 15 : 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 [ + + ]: 323013 : if (
4662 : 323013 : (a = slash_with_default_rule(p)) // slash_with_default
4663 [ + - ]: 367 : &&
4664 : 367 : (b = _loop0_38_rule(p)) // param_with_default*
4665 : 367 : &&
4666 [ + + ]: 367 : (c = star_etc_rule(p), !p->error_indicator) // star_etc?
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 : 366 : _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
4671 [ - + - - ]: 366 : if (_res == NULL && PyErr_Occurred()) {
4672 : 0 : p->error_indicator = 1;
4673 : 0 : p->level--;
4674 : 0 : return NULL;
4675 : : }
4676 : 366 : goto done;
4677 : : }
4678 : 322647 : 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 [ + + ]: 322647 : if (p->error_indicator) {
4684 : 1 : p->level--;
4685 : 1 : 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 [ + + ]: 322646 : if (
4692 : 322646 : (a = (asdl_arg_seq*)_loop1_39_rule(p)) // param_no_default+
4693 [ + - ]: 297942 : &&
4694 : 297942 : (b = _loop0_40_rule(p)) // param_with_default*
4695 : 297942 : &&
4696 [ + + ]: 297942 : (c = star_etc_rule(p), !p->error_indicator) // star_etc?
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 : 297931 : _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
4701 [ - + - - ]: 297931 : if (_res == NULL && PyErr_Occurred()) {
4702 : 0 : p->error_indicator = 1;
4703 : 0 : p->level--;
4704 : 0 : return NULL;
4705 : : }
4706 : 297931 : goto done;
4707 : : }
4708 : 24715 : 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 [ + + ]: 24715 : if (p->error_indicator) {
4714 : 11 : p->level--;
4715 : 11 : 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 [ + + ]: 24704 : if (
4721 : 24704 : (a = _loop1_41_rule(p)) // param_with_default+
4722 : 3095 : &&
4723 [ + - ]: 3095 : (b = star_etc_rule(p), !p->error_indicator) // star_etc?
4724 : : )
4725 : : {
4726 : : D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?"));
4727 : 3095 : _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
4728 [ - + - - ]: 3095 : if (_res == NULL && PyErr_Occurred()) {
4729 : 0 : p->error_indicator = 1;
4730 : 0 : p->level--;
4731 : 0 : return NULL;
4732 : : }
4733 : 3095 : goto done;
4734 : : }
4735 : 21609 : 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 [ - + ]: 21609 : if (p->error_indicator) {
4741 : 0 : p->level--;
4742 : 0 : return NULL;
4743 : : }
4744 : : D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc"));
4745 : : StarEtc* a;
4746 [ + + ]: 21609 : if (
4747 : 21609 : (a = star_etc_rule(p)) // star_etc
4748 : : )
4749 : : {
4750 : : D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_etc"));
4751 : 3326 : _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
4752 [ - + - - ]: 3326 : if (_res == NULL && PyErr_Occurred()) {
4753 : 0 : p->error_indicator = 1;
4754 : 0 : p->level--;
4755 : 0 : return NULL;
4756 : : }
4757 : 3326 : goto done;
4758 : : }
4759 : 18283 : 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 : 18283 : _res = NULL;
4764 : 340577 : done:
4765 : 340577 : p->level--;
4766 : 340577 : return _res;
4767 : : }
4768 : :
4769 : : // slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &')'
4770 : : static asdl_arg_seq*
4771 : 341144 : slash_no_default_rule(Parser *p)
4772 : : {
4773 [ - + ]: 341144 : if (p->level++ == MAXSTACK) {
4774 : 0 : p->error_indicator = 1;
4775 : : PyErr_NoMemory();
4776 : : }
4777 [ - + ]: 341144 : if (p->error_indicator) {
4778 : 0 : p->level--;
4779 : 0 : return NULL;
4780 : : }
4781 : 341144 : asdl_arg_seq* _res = NULL;
4782 : 341144 : int _mark = p->mark;
4783 : : { // param_no_default+ '/' ','
4784 [ - + ]: 341144 : if (p->error_indicator) {
4785 : 0 : p->level--;
4786 : 0 : 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 [ + + ]: 341144 : if (
4793 : 341144 : (a = (asdl_arg_seq*)_loop1_42_rule(p)) // param_no_default+
4794 [ + + ]: 315888 : &&
4795 : 315888 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4796 [ + + ]: 17593 : &&
4797 : 17593 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
4798 : : )
4799 : : {
4800 : : D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','"));
4801 : 17363 : _res = a;
4802 [ - + - - ]: 17363 : if (_res == NULL && PyErr_Occurred()) {
4803 : 0 : p->error_indicator = 1;
4804 : 0 : p->level--;
4805 : 0 : return NULL;
4806 : : }
4807 : 17363 : goto done;
4808 : : }
4809 : 323781 : 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 [ + + ]: 323781 : if (p->error_indicator) {
4815 : 13 : p->level--;
4816 : 13 : 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 [ + + ]: 323768 : if (
4822 : 323768 : (a = (asdl_arg_seq*)_loop1_43_rule(p)) // param_no_default+
4823 [ + + ]: 298525 : &&
4824 : 298525 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4825 [ + - ]: 230 : &&
4826 : 230 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
4827 : : )
4828 : : {
4829 : : D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'"));
4830 : 230 : _res = a;
4831 [ - + - - ]: 230 : if (_res == NULL && PyErr_Occurred()) {
4832 : 0 : p->error_indicator = 1;
4833 : 0 : p->level--;
4834 : 0 : return NULL;
4835 : : }
4836 : 230 : goto done;
4837 : : }
4838 : 323538 : 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 : 323538 : _res = NULL;
4843 : 341131 : done:
4844 : 341131 : p->level--;
4845 : 341131 : 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 : 323835 : slash_with_default_rule(Parser *p)
4853 : : {
4854 [ - + ]: 323835 : if (p->level++ == MAXSTACK) {
4855 : 0 : p->error_indicator = 1;
4856 : : PyErr_NoMemory();
4857 : : }
4858 [ - + ]: 323835 : if (p->error_indicator) {
4859 : 0 : p->level--;
4860 : 0 : return NULL;
4861 : : }
4862 : 323835 : SlashWithDefault* _res = NULL;
4863 : 323835 : int _mark = p->mark;
4864 : : { // param_no_default* param_with_default+ '/' ','
4865 [ - + ]: 323835 : if (p->error_indicator) {
4866 : 0 : p->level--;
4867 : 0 : 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 [ + - ]: 323835 : if (
4875 : 323835 : (a = _loop0_44_rule(p)) // param_no_default*
4876 [ + + ]: 323835 : &&
4877 : 323835 : (b = _loop1_45_rule(p)) // param_with_default+
4878 [ + + ]: 39661 : &&
4879 : 39661 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4880 [ + + ]: 380 : &&
4881 : 380 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
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 : 352 : _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
4886 [ - + - - ]: 352 : if (_res == NULL && PyErr_Occurred()) {
4887 : 0 : p->error_indicator = 1;
4888 : 0 : p->level--;
4889 : 0 : return NULL;
4890 : : }
4891 : 352 : goto done;
4892 : : }
4893 : 323483 : 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 [ + + ]: 323483 : if (p->error_indicator) {
4899 : 3 : p->level--;
4900 : 3 : 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 [ + - ]: 323480 : if (
4907 : 323480 : (a = _loop0_46_rule(p)) // param_no_default*
4908 [ + + ]: 323480 : &&
4909 : 323480 : (b = _loop1_47_rule(p)) // param_with_default+
4910 [ + + ]: 39309 : &&
4911 : 39309 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4912 [ + + ]: 28 : &&
4913 : 28 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
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 : 24 : _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
4918 [ - + - - ]: 24 : if (_res == NULL && PyErr_Occurred()) {
4919 : 0 : p->error_indicator = 1;
4920 : 0 : p->level--;
4921 : 0 : return NULL;
4922 : : }
4923 : 24 : goto done;
4924 : : }
4925 : 323456 : 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 : 323456 : _res = NULL;
4930 : 323832 : done:
4931 : 323832 : p->level--;
4932 : 323832 : 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 : 340591 : star_etc_rule(Parser *p)
4943 : : {
4944 [ - + ]: 340591 : if (p->level++ == MAXSTACK) {
4945 : 0 : p->error_indicator = 1;
4946 : : PyErr_NoMemory();
4947 : : }
4948 [ - + ]: 340591 : if (p->error_indicator) {
4949 : 0 : p->level--;
4950 : 0 : return NULL;
4951 : : }
4952 : 340591 : StarEtc* _res = NULL;
4953 : 340591 : int _mark = p->mark;
4954 [ + + ]: 340591 : if (p->call_invalid_rules) { // invalid_star_etc
4955 [ - + ]: 252 : if (p->error_indicator) {
4956 : 0 : p->level--;
4957 : 0 : 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 [ - + ]: 252 : if (
4962 : 252 : (invalid_star_etc_var = invalid_star_etc_rule(p)) // invalid_star_etc
4963 : : )
4964 : : {
4965 : : D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_star_etc"));
4966 : 0 : _res = invalid_star_etc_var;
4967 : 0 : goto done;
4968 : : }
4969 : 252 : 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 [ + + ]: 340591 : if (p->error_indicator) {
4975 : 10 : p->level--;
4976 : 10 : 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 [ + + ]: 340581 : if (
4984 : 340581 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
4985 [ + + ]: 33151 : &&
4986 : 33151 : (a = param_no_default_rule(p)) // param_no_default
4987 [ + - ]: 27187 : &&
4988 : 27187 : (b = _loop0_48_rule(p)) // param_maybe_default*
4989 : 27187 : &&
4990 [ + + ]: 27187 : (c = kwds_rule(p), !p->error_indicator) // kwds?
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 : 27183 : _res = _PyPegen_star_etc ( p , a , b , c );
4995 [ - + - - ]: 27183 : if (_res == NULL && PyErr_Occurred()) {
4996 : 0 : p->error_indicator = 1;
4997 : 0 : p->level--;
4998 : 0 : return NULL;
4999 : : }
5000 : 27183 : goto done;
5001 : : }
5002 : 313398 : 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 [ + + ]: 313398 : if (p->error_indicator) {
5008 : 4 : p->level--;
5009 : 4 : 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 [ + + ]: 313394 : if (
5017 : 313394 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
5018 [ + + ]: 5964 : &&
5019 : 5964 : (a = param_no_default_star_annotation_rule(p)) // param_no_default_star_annotation
5020 [ + - ]: 20 : &&
5021 : 20 : (b = _loop0_49_rule(p)) // param_maybe_default*
5022 : 20 : &&
5023 [ + - ]: 20 : (c = kwds_rule(p), !p->error_indicator) // kwds?
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 : 20 : _res = _PyPegen_star_etc ( p , a , b , c );
5028 [ - + - - ]: 20 : if (_res == NULL && PyErr_Occurred()) {
5029 : 0 : p->error_indicator = 1;
5030 : 0 : p->level--;
5031 : 0 : return NULL;
5032 : : }
5033 : 20 : goto done;
5034 : : }
5035 : 313374 : 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 [ - + ]: 313374 : if (p->error_indicator) {
5041 : 0 : p->level--;
5042 : 0 : 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 [ + + ]: 313374 : if (
5050 : 313374 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
5051 [ + + ]: 5944 : &&
5052 : 5944 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
5053 [ + + ]: 5934 : &&
5054 : 5934 : (b = _loop1_50_rule(p)) // param_maybe_default+
5055 : 5921 : &&
5056 [ + - ]: 5921 : (c = kwds_rule(p), !p->error_indicator) // kwds?
5057 : : )
5058 : : {
5059 : : D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
5060 : 5921 : _res = _PyPegen_star_etc ( p , NULL , b , c );
5061 [ - + - - ]: 5921 : if (_res == NULL && PyErr_Occurred()) {
5062 : 0 : p->error_indicator = 1;
5063 : 0 : p->level--;
5064 : 0 : return NULL;
5065 : : }
5066 : 5921 : goto done;
5067 : : }
5068 : 307453 : 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 [ - + ]: 307453 : if (p->error_indicator) {
5074 : 0 : p->level--;
5075 : 0 : 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 [ + + ]: 307453 : if (
5080 : 307453 : (a = kwds_rule(p)) // kwds
5081 : : )
5082 : : {
5083 : : D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwds"));
5084 : 3484 : _res = _PyPegen_star_etc ( p , NULL , NULL , a );
5085 [ - + - - ]: 3484 : if (_res == NULL && PyErr_Occurred()) {
5086 : 0 : p->error_indicator = 1;
5087 : 0 : p->level--;
5088 : 0 : return NULL;
5089 : : }
5090 : 3484 : goto done;
5091 : : }
5092 : 303969 : 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 : 303969 : _res = NULL;
5097 : 340577 : done:
5098 : 340577 : p->level--;
5099 : 340577 : return _res;
5100 : : }
5101 : :
5102 : : // kwds: invalid_kwds | '**' param_no_default
5103 : : static arg_ty
5104 : 340581 : kwds_rule(Parser *p)
5105 : : {
5106 [ - + ]: 340581 : if (p->level++ == MAXSTACK) {
5107 : 0 : p->error_indicator = 1;
5108 : : PyErr_NoMemory();
5109 : : }
5110 [ - + ]: 340581 : if (p->error_indicator) {
5111 : 0 : p->level--;
5112 : 0 : return NULL;
5113 : : }
5114 : 340581 : arg_ty _res = NULL;
5115 : 340581 : int _mark = p->mark;
5116 [ + + ]: 340581 : if (p->call_invalid_rules) { // invalid_kwds
5117 [ - + ]: 242 : if (p->error_indicator) {
5118 : 0 : p->level--;
5119 : 0 : 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 [ - + ]: 242 : if (
5124 : 242 : (invalid_kwds_var = invalid_kwds_rule(p)) // invalid_kwds
5125 : : )
5126 : : {
5127 : : D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwds"));
5128 : 0 : _res = invalid_kwds_var;
5129 : 0 : goto done;
5130 : : }
5131 : 242 : 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 [ + + ]: 340581 : if (p->error_indicator) {
5137 : 9 : p->level--;
5138 : 9 : 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 [ + + ]: 340572 : if (
5144 : 340572 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
5145 [ + + ]: 25539 : &&
5146 : 25539 : (a = param_no_default_rule(p)) // param_no_default
5147 : : )
5148 : : {
5149 : : D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"));
5150 : 25531 : _res = a;
5151 [ - + - - ]: 25531 : if (_res == NULL && PyErr_Occurred()) {
5152 : 0 : p->error_indicator = 1;
5153 : 0 : p->level--;
5154 : 0 : return NULL;
5155 : : }
5156 : 25531 : goto done;
5157 : : }
5158 : 315041 : 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 : 315041 : _res = NULL;
5163 : 340572 : done:
5164 : 340572 : p->level--;
5165 : 340572 : return _res;
5166 : : }
5167 : :
5168 : : // param_no_default: param ',' TYPE_COMMENT? | param TYPE_COMMENT? &')'
5169 : : static arg_ty
5170 : 4050200 : param_no_default_rule(Parser *p)
5171 : : {
5172 [ - + ]: 4050200 : if (p->level++ == MAXSTACK) {
5173 : 0 : p->error_indicator = 1;
5174 : : PyErr_NoMemory();
5175 : : }
5176 [ - + ]: 4050200 : if (p->error_indicator) {
5177 : 0 : p->level--;
5178 : 0 : return NULL;
5179 : : }
5180 : 4050200 : arg_ty _res = NULL;
5181 : 4050200 : int _mark = p->mark;
5182 : : { // param ',' TYPE_COMMENT?
5183 [ - + ]: 4050200 : if (p->error_indicator) {
5184 : 0 : p->level--;
5185 : 0 : 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 [ + + ]: 4050200 : if (
5192 : 4050200 : (a = param_rule(p)) // param
5193 [ + + ]: 2590116 : &&
5194 : 2590116 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
5195 : 1117715 : &&
5196 [ + + ]: 1117715 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5197 : : )
5198 : : {
5199 : : D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?"));
5200 : 1117711 : _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5201 [ - + - - ]: 1117711 : if (_res == NULL && PyErr_Occurred()) {
5202 : 0 : p->error_indicator = 1;
5203 : 0 : p->level--;
5204 : 0 : return NULL;
5205 : : }
5206 : 1117711 : goto done;
5207 : : }
5208 : 2932489 : 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 [ + + ]: 2932489 : if (p->error_indicator) {
5214 : 18 : p->level--;
5215 : 18 : 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 [ + + ]: 2932471 : if (
5221 : 2932471 : (a = param_rule(p)) // param
5222 : 1472401 : &&
5223 [ + - ]: 1472401 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5224 [ + + ]: 1472401 : &&
5225 : 1472401 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
5226 : : )
5227 : : {
5228 : : D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'"));
5229 : 1273453 : _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5230 [ - + - - ]: 1273453 : if (_res == NULL && PyErr_Occurred()) {
5231 : 0 : p->error_indicator = 1;
5232 : 0 : p->level--;
5233 : 0 : return NULL;
5234 : : }
5235 : 1273453 : goto done;
5236 : : }
5237 : 1659018 : 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 : 1659018 : _res = NULL;
5242 : 4050182 : done:
5243 : 4050182 : p->level--;
5244 : 4050182 : 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 : 5964 : param_no_default_star_annotation_rule(Parser *p)
5252 : : {
5253 [ - + ]: 5964 : if (p->level++ == MAXSTACK) {
5254 : 0 : p->error_indicator = 1;
5255 : : PyErr_NoMemory();
5256 : : }
5257 [ - + ]: 5964 : if (p->error_indicator) {
5258 : 0 : p->level--;
5259 : 0 : return NULL;
5260 : : }
5261 : 5964 : arg_ty _res = NULL;
5262 : 5964 : int _mark = p->mark;
5263 : : { // param_star_annotation ',' TYPE_COMMENT?
5264 [ - + ]: 5964 : if (p->error_indicator) {
5265 : 0 : p->level--;
5266 : 0 : 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 [ + + ]: 5964 : if (
5273 : 5964 : (a = param_star_annotation_rule(p)) // param_star_annotation
5274 [ + + ]: 24 : &&
5275 : 24 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
5276 : 3 : &&
5277 [ + - ]: 3 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
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 : 3 : _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5282 [ - + - - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
5283 : 0 : p->error_indicator = 1;
5284 : 0 : p->level--;
5285 : 0 : return NULL;
5286 : : }
5287 : 3 : goto done;
5288 : : }
5289 : 5961 : 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 [ - + ]: 5961 : if (p->error_indicator) {
5295 : 0 : p->level--;
5296 : 0 : 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 [ + + ]: 5961 : if (
5302 : 5961 : (a = param_star_annotation_rule(p)) // param_star_annotation
5303 : 21 : &&
5304 [ + - ]: 21 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5305 [ + + ]: 21 : &&
5306 : 21 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
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 : 17 : _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5311 [ - + - - ]: 17 : if (_res == NULL && PyErr_Occurred()) {
5312 : 0 : p->error_indicator = 1;
5313 : 0 : p->level--;
5314 : 0 : return NULL;
5315 : : }
5316 : 17 : goto done;
5317 : : }
5318 : 5944 : 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 : 5944 : _res = NULL;
5323 : 5964 : done:
5324 : 5964 : p->level--;
5325 : 5964 : return _res;
5326 : : }
5327 : :
5328 : : // param_with_default: param default ',' TYPE_COMMENT? | param default TYPE_COMMENT? &')'
5329 : : static NameDefaultPair*
5330 : 1207831 : param_with_default_rule(Parser *p)
5331 : : {
5332 [ - + ]: 1207831 : if (p->level++ == MAXSTACK) {
5333 : 0 : p->error_indicator = 1;
5334 : : PyErr_NoMemory();
5335 : : }
5336 [ - + ]: 1207831 : if (p->error_indicator) {
5337 : 0 : p->level--;
5338 : 0 : return NULL;
5339 : : }
5340 : 1207831 : NameDefaultPair* _res = NULL;
5341 : 1207831 : int _mark = p->mark;
5342 : : { // param default ',' TYPE_COMMENT?
5343 [ - + ]: 1207831 : if (p->error_indicator) {
5344 : 0 : p->level--;
5345 : 0 : 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 [ + + ]: 1207831 : if (
5353 : 1207831 : (a = param_rule(p)) // param
5354 [ + + ]: 220440 : &&
5355 : 220440 : (c = default_rule(p)) // default
5356 [ + + ]: 219660 : &&
5357 : 219660 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
5358 : 119554 : &&
5359 [ + - ]: 119554 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
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 : 119554 : _res = _PyPegen_name_default_pair ( p , a , c , tc );
5364 [ - + - - ]: 119554 : if (_res == NULL && PyErr_Occurred()) {
5365 : 0 : p->error_indicator = 1;
5366 : 0 : p->level--;
5367 : 0 : return NULL;
5368 : : }
5369 : 119554 : goto done;
5370 : : }
5371 : 1088277 : 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 [ + + ]: 1088277 : if (p->error_indicator) {
5377 : 3 : p->level--;
5378 : 3 : 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 [ + + ]: 1088274 : if (
5385 : 1088274 : (a = param_rule(p)) // param
5386 [ + + ]: 100883 : &&
5387 : 100883 : (c = default_rule(p)) // default
5388 : 100106 : &&
5389 [ + - ]: 100106 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5390 [ + + ]: 100106 : &&
5391 : 100106 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
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 : 100083 : _res = _PyPegen_name_default_pair ( p , a , c , tc );
5396 [ - + - - ]: 100083 : if (_res == NULL && PyErr_Occurred()) {
5397 : 0 : p->error_indicator = 1;
5398 : 0 : p->level--;
5399 : 0 : return NULL;
5400 : : }
5401 : 100083 : goto done;
5402 : : }
5403 : 988191 : 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 : 988191 : _res = NULL;
5408 : 1207828 : done:
5409 : 1207828 : p->level--;
5410 : 1207828 : return _res;
5411 : : }
5412 : :
5413 : : // param_maybe_default:
5414 : : // | param default? ',' TYPE_COMMENT?
5415 : : // | param default? TYPE_COMMENT? &')'
5416 : : static NameDefaultPair*
5417 : 52435 : param_maybe_default_rule(Parser *p)
5418 : : {
5419 [ - + ]: 52435 : if (p->level++ == MAXSTACK) {
5420 : 0 : p->error_indicator = 1;
5421 : : PyErr_NoMemory();
5422 : : }
5423 [ - + ]: 52435 : if (p->error_indicator) {
5424 : 0 : p->level--;
5425 : 0 : return NULL;
5426 : : }
5427 : 52435 : NameDefaultPair* _res = NULL;
5428 : 52435 : int _mark = p->mark;
5429 : : { // param default? ',' TYPE_COMMENT?
5430 [ - + ]: 52435 : if (p->error_indicator) {
5431 : 0 : p->level--;
5432 : 0 : 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 [ + + ]: 52435 : if (
5440 : 52435 : (a = param_rule(p)) // param
5441 : 18838 : &&
5442 [ + - ]: 18838 : (c = default_rule(p), !p->error_indicator) // default?
5443 [ + + ]: 18838 : &&
5444 : 18838 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
5445 : 13937 : &&
5446 [ + - ]: 13937 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
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 : 13937 : _res = _PyPegen_name_default_pair ( p , a , c , tc );
5451 [ - + - - ]: 13937 : if (_res == NULL && PyErr_Occurred()) {
5452 : 0 : p->error_indicator = 1;
5453 : 0 : p->level--;
5454 : 0 : return NULL;
5455 : : }
5456 : 13937 : goto done;
5457 : : }
5458 : 38498 : 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 [ - + ]: 38498 : if (p->error_indicator) {
5464 : 0 : p->level--;
5465 : 0 : 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 [ + + ]: 38498 : if (
5472 : 38498 : (a = param_rule(p)) // param
5473 : 4901 : &&
5474 [ + - ]: 4901 : (c = default_rule(p), !p->error_indicator) // default?
5475 : 4901 : &&
5476 [ + - ]: 4901 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5477 [ + + ]: 4901 : &&
5478 : 4901 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
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 : 4773 : _res = _PyPegen_name_default_pair ( p , a , c , tc );
5483 [ - + - - ]: 4773 : if (_res == NULL && PyErr_Occurred()) {
5484 : 0 : p->error_indicator = 1;
5485 : 0 : p->level--;
5486 : 0 : return NULL;
5487 : : }
5488 : 4773 : goto done;
5489 : : }
5490 : 33725 : 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 : 33725 : _res = NULL;
5495 : 52435 : done:
5496 : 52435 : p->level--;
5497 : 52435 : return _res;
5498 : : }
5499 : :
5500 : : // param: NAME annotation?
5501 : : static arg_ty
5502 : 9369786 : param_rule(Parser *p)
5503 : : {
5504 [ - + ]: 9369786 : if (p->level++ == MAXSTACK) {
5505 : 0 : p->error_indicator = 1;
5506 : : PyErr_NoMemory();
5507 : : }
5508 [ - + ]: 9369786 : if (p->error_indicator) {
5509 : 0 : p->level--;
5510 : 0 : return NULL;
5511 : : }
5512 : 9369786 : arg_ty _res = NULL;
5513 : 9369786 : int _mark = p->mark;
5514 [ + + + + ]: 9369786 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
5515 : 5 : p->error_indicator = 1;
5516 : 5 : p->level--;
5517 : 5 : return NULL;
5518 : : }
5519 : 9369781 : int _start_lineno = p->tokens[_mark]->lineno;
5520 : : UNUSED(_start_lineno); // Only used by EXTRA macro
5521 : 9369781 : int _start_col_offset = p->tokens[_mark]->col_offset;
5522 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
5523 : : { // NAME annotation?
5524 [ - + ]: 9369781 : if (p->error_indicator) {
5525 : 0 : p->level--;
5526 : 0 : 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 [ + + ]: 9369781 : if (
5532 : 9369781 : (a = _PyPegen_name_token(p)) // NAME
5533 : 4407645 : &&
5534 [ + + ]: 4407645 : (b = annotation_rule(p), !p->error_indicator) // annotation?
5535 : : )
5536 : : {
5537 : : D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
5538 : 4407636 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5539 [ - + ]: 4407636 : if (_token == NULL) {
5540 : 0 : p->level--;
5541 : 0 : return NULL;
5542 : : }
5543 : 4407636 : int _end_lineno = _token->end_lineno;
5544 : : UNUSED(_end_lineno); // Only used by EXTRA macro
5545 : 4407636 : int _end_col_offset = _token->end_col_offset;
5546 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
5547 : 4407636 : _res = _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA );
5548 [ - + - - ]: 4407636 : if (_res == NULL && PyErr_Occurred()) {
5549 : 0 : p->error_indicator = 1;
5550 : 0 : p->level--;
5551 : 0 : return NULL;
5552 : : }
5553 : 4407636 : goto done;
5554 : : }
5555 : 4962145 : 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 : 4962145 : _res = NULL;
5560 : 9369781 : done:
5561 : 9369781 : p->level--;
5562 : 9369781 : return _res;
5563 : : }
5564 : :
5565 : : // param_star_annotation: NAME star_annotation
5566 : : static arg_ty
5567 : 11925 : param_star_annotation_rule(Parser *p)
5568 : : {
5569 [ - + ]: 11925 : if (p->level++ == MAXSTACK) {
5570 : 0 : p->error_indicator = 1;
5571 : : PyErr_NoMemory();
5572 : : }
5573 [ - + ]: 11925 : if (p->error_indicator) {
5574 : 0 : p->level--;
5575 : 0 : return NULL;
5576 : : }
5577 : 11925 : arg_ty _res = NULL;
5578 : 11925 : int _mark = p->mark;
5579 [ - + - - ]: 11925 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
5580 : 0 : p->error_indicator = 1;
5581 : 0 : p->level--;
5582 : 0 : return NULL;
5583 : : }
5584 : 11925 : int _start_lineno = p->tokens[_mark]->lineno;
5585 : : UNUSED(_start_lineno); // Only used by EXTRA macro
5586 : 11925 : int _start_col_offset = p->tokens[_mark]->col_offset;
5587 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
5588 : : { // NAME star_annotation
5589 [ - + ]: 11925 : if (p->error_indicator) {
5590 : 0 : p->level--;
5591 : 0 : 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 [ + + ]: 11925 : if (
5597 : 11925 : (a = _PyPegen_name_token(p)) // NAME
5598 [ + + ]: 47 : &&
5599 : 47 : (b = star_annotation_rule(p)) // star_annotation
5600 : : )
5601 : : {
5602 : : D(fprintf(stderr, "%*c+ param_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME star_annotation"));
5603 : 45 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5604 [ - + ]: 45 : if (_token == NULL) {
5605 : 0 : p->level--;
5606 : 0 : return NULL;
5607 : : }
5608 : 45 : int _end_lineno = _token->end_lineno;
5609 : : UNUSED(_end_lineno); // Only used by EXTRA macro
5610 : 45 : int _end_col_offset = _token->end_col_offset;
5611 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
5612 : 45 : _res = _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA );
5613 [ - + - - ]: 45 : if (_res == NULL && PyErr_Occurred()) {
5614 : 0 : p->error_indicator = 1;
5615 : 0 : p->level--;
5616 : 0 : return NULL;
5617 : : }
5618 : 45 : goto done;
5619 : : }
5620 : 11880 : 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 : 11880 : _res = NULL;
5625 : 11925 : done:
5626 : 11925 : p->level--;
5627 : 11925 : return _res;
5628 : : }
5629 : :
5630 : : // annotation: ':' expression
5631 : : static expr_ty
5632 : 4407645 : annotation_rule(Parser *p)
5633 : : {
5634 [ - + ]: 4407645 : if (p->level++ == MAXSTACK) {
5635 : 0 : p->error_indicator = 1;
5636 : : PyErr_NoMemory();
5637 : : }
5638 [ - + ]: 4407645 : if (p->error_indicator) {
5639 : 0 : p->level--;
5640 : 0 : return NULL;
5641 : : }
5642 : 4407645 : expr_ty _res = NULL;
5643 : 4407645 : int _mark = p->mark;
5644 : : { // ':' expression
5645 [ - + ]: 4407645 : if (p->error_indicator) {
5646 : 0 : p->level--;
5647 : 0 : 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 [ + + ]: 4407645 : if (
5653 : 4407645 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5654 [ + + ]: 340454 : &&
5655 : 340454 : (a = expression_rule(p)) // expression
5656 : : )
5657 : : {
5658 : : D(fprintf(stderr, "%*c+ annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression"));
5659 : 340117 : _res = a;
5660 [ - + - - ]: 340117 : if (_res == NULL && PyErr_Occurred()) {
5661 : 0 : p->error_indicator = 1;
5662 : 0 : p->level--;
5663 : 0 : return NULL;
5664 : : }
5665 : 340117 : goto done;
5666 : : }
5667 : 4067528 : 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 : 4067528 : _res = NULL;
5672 : 4407645 : done:
5673 : 4407645 : p->level--;
5674 : 4407645 : return _res;
5675 : : }
5676 : :
5677 : : // star_annotation: ':' star_expression
5678 : : static expr_ty
5679 : 47 : star_annotation_rule(Parser *p)
5680 : : {
5681 [ - + ]: 47 : if (p->level++ == MAXSTACK) {
5682 : 0 : p->error_indicator = 1;
5683 : : PyErr_NoMemory();
5684 : : }
5685 [ - + ]: 47 : if (p->error_indicator) {
5686 : 0 : p->level--;
5687 : 0 : return NULL;
5688 : : }
5689 : 47 : expr_ty _res = NULL;
5690 : 47 : int _mark = p->mark;
5691 : : { // ':' star_expression
5692 [ - + ]: 47 : if (p->error_indicator) {
5693 : 0 : p->level--;
5694 : 0 : 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 [ + + ]: 47 : if (
5700 : 47 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5701 [ + - ]: 45 : &&
5702 : 45 : (a = star_expression_rule(p)) // star_expression
5703 : : )
5704 : : {
5705 : : D(fprintf(stderr, "%*c+ star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' star_expression"));
5706 : 45 : _res = a;
5707 [ - + - - ]: 45 : if (_res == NULL && PyErr_Occurred()) {
5708 : 0 : p->error_indicator = 1;
5709 : 0 : p->level--;
5710 : 0 : return NULL;
5711 : : }
5712 : 45 : goto done;
5713 : : }
5714 : 2 : 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 : 2 : _res = NULL;
5719 : 47 : done:
5720 : 47 : p->level--;
5721 : 47 : return _res;
5722 : : }
5723 : :
5724 : : // default: '=' expression | invalid_default
5725 : : static expr_ty
5726 : 347091 : default_rule(Parser *p)
5727 : : {
5728 [ - + ]: 347091 : if (p->level++ == MAXSTACK) {
5729 : 0 : p->error_indicator = 1;
5730 : : PyErr_NoMemory();
5731 : : }
5732 [ - + ]: 347091 : if (p->error_indicator) {
5733 : 0 : p->level--;
5734 : 0 : return NULL;
5735 : : }
5736 : 347091 : expr_ty _res = NULL;
5737 : 347091 : int _mark = p->mark;
5738 : : { // '=' expression
5739 [ - + ]: 347091 : if (p->error_indicator) {
5740 : 0 : p->level--;
5741 : 0 : 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 [ + + ]: 347091 : if (
5747 : 347091 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
5748 [ + + ]: 340699 : &&
5749 : 340699 : (a = expression_rule(p)) // expression
5750 : : )
5751 : : {
5752 : : D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expression"));
5753 : 340394 : _res = a;
5754 [ - + - - ]: 340394 : if (_res == NULL && PyErr_Occurred()) {
5755 : 0 : p->error_indicator = 1;
5756 : 0 : p->level--;
5757 : 0 : return NULL;
5758 : : }
5759 : 340394 : goto done;
5760 : : }
5761 : 6697 : 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 [ + + ]: 6697 : if (p->call_invalid_rules) { // invalid_default
5766 [ - + ]: 1775 : if (p->error_indicator) {
5767 : 0 : p->level--;
5768 : 0 : 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 [ - + ]: 1775 : if (
5773 : 1775 : (invalid_default_var = invalid_default_rule(p)) // invalid_default
5774 : : )
5775 : : {
5776 : : D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_default"));
5777 : 0 : _res = invalid_default_var;
5778 : 0 : goto done;
5779 : : }
5780 : 1775 : 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 : 6697 : _res = NULL;
5785 : 347091 : done:
5786 : 347091 : p->level--;
5787 : 347091 : 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 : 487179 : if_stmt_rule(Parser *p)
5796 : : {
5797 [ - + ]: 487179 : if (p->level++ == MAXSTACK) {
5798 : 0 : p->error_indicator = 1;
5799 : : PyErr_NoMemory();
5800 : : }
5801 [ - + ]: 487179 : if (p->error_indicator) {
5802 : 0 : p->level--;
5803 : 0 : return NULL;
5804 : : }
5805 : 487179 : stmt_ty _res = NULL;
5806 : 487179 : int _mark = p->mark;
5807 [ - + - - ]: 487179 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
5808 : 0 : p->error_indicator = 1;
5809 : 0 : p->level--;
5810 : 0 : return NULL;
5811 : : }
5812 : 487179 : int _start_lineno = p->tokens[_mark]->lineno;
5813 : : UNUSED(_start_lineno); // Only used by EXTRA macro
5814 : 487179 : int _start_col_offset = p->tokens[_mark]->col_offset;
5815 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
5816 [ + + ]: 487179 : if (p->call_invalid_rules) { // invalid_if_stmt
5817 [ - + ]: 39 : if (p->error_indicator) {
5818 : 0 : p->level--;
5819 : 0 : 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 [ - + ]: 39 : if (
5824 : 39 : (invalid_if_stmt_var = invalid_if_stmt_rule(p)) // invalid_if_stmt
5825 : : )
5826 : : {
5827 : : D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_if_stmt"));
5828 : 0 : _res = invalid_if_stmt_var;
5829 : 0 : goto done;
5830 : : }
5831 : 39 : 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 [ + + ]: 487179 : if (p->error_indicator) {
5837 : 6 : p->level--;
5838 : 6 : 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 [ + - ]: 487173 : if (
5847 : 487173 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
5848 [ + + ]: 487173 : &&
5849 : 487173 : (a = named_expression_rule(p)) // named_expression
5850 [ + + ]: 487167 : &&
5851 : 487167 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5852 [ + + ]: 487164 : &&
5853 : 487164 : (b = block_rule(p)) // block
5854 [ + + ]: 487095 : &&
5855 : 487095 : (c = elif_stmt_rule(p)) // elif_stmt
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 : 19892 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5860 [ - + ]: 19892 : if (_token == NULL) {
5861 : 0 : p->level--;
5862 : 0 : return NULL;
5863 : : }
5864 : 19892 : int _end_lineno = _token->end_lineno;
5865 : : UNUSED(_end_lineno); // Only used by EXTRA macro
5866 : 19892 : int _end_col_offset = _token->end_col_offset;
5867 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
5868 : 19892 : _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
5869 [ - + - - ]: 19892 : if (_res == NULL && PyErr_Occurred()) {
5870 : 0 : p->error_indicator = 1;
5871 : 0 : p->level--;
5872 : 0 : return NULL;
5873 : : }
5874 : 19892 : goto done;
5875 : : }
5876 : 467281 : 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 [ + + ]: 467281 : if (p->error_indicator) {
5882 : 24 : p->level--;
5883 : 24 : 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 [ + - ]: 467257 : if (
5892 : 467257 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
5893 [ + + ]: 467257 : &&
5894 : 467257 : (a = named_expression_rule(p)) // named_expression
5895 [ + + ]: 467251 : &&
5896 : 467251 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5897 [ + + ]: 467248 : &&
5898 : 467248 : (b = block_rule(p)) // block
5899 : 467196 : &&
5900 [ + - ]: 467196 : (c = else_block_rule(p), !p->error_indicator) // else_block?
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 : 467196 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5905 [ - + ]: 467196 : if (_token == NULL) {
5906 : 0 : p->level--;
5907 : 0 : return NULL;
5908 : : }
5909 : 467196 : int _end_lineno = _token->end_lineno;
5910 : : UNUSED(_end_lineno); // Only used by EXTRA macro
5911 : 467196 : int _end_col_offset = _token->end_col_offset;
5912 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
5913 : 467196 : _res = _PyAST_If ( a , b , c , EXTRA );
5914 [ - + - - ]: 467196 : if (_res == NULL && PyErr_Occurred()) {
5915 : 0 : p->error_indicator = 1;
5916 : 0 : p->level--;
5917 : 0 : return NULL;
5918 : : }
5919 : 467196 : goto done;
5920 : : }
5921 : 61 : 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 : 61 : _res = NULL;
5926 : 487149 : done:
5927 : 487149 : p->level--;
5928 : 487149 : 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 : 521148 : elif_stmt_rule(Parser *p)
5937 : : {
5938 [ - + ]: 521148 : if (p->level++ == MAXSTACK) {
5939 : 0 : p->error_indicator = 1;
5940 : : PyErr_NoMemory();
5941 : : }
5942 [ - + ]: 521148 : if (p->error_indicator) {
5943 : 0 : p->level--;
5944 : 0 : return NULL;
5945 : : }
5946 : 521148 : stmt_ty _res = NULL;
5947 : 521148 : int _mark = p->mark;
5948 [ + + - + ]: 521148 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
5949 : 0 : p->error_indicator = 1;
5950 : 0 : p->level--;
5951 : 0 : return NULL;
5952 : : }
5953 : 521148 : int _start_lineno = p->tokens[_mark]->lineno;
5954 : : UNUSED(_start_lineno); // Only used by EXTRA macro
5955 : 521148 : int _start_col_offset = p->tokens[_mark]->col_offset;
5956 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
5957 [ + + ]: 521148 : if (p->call_invalid_rules) { // invalid_elif_stmt
5958 [ - + ]: 8 : if (p->error_indicator) {
5959 : 0 : p->level--;
5960 : 0 : 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 [ - + ]: 8 : if (
5965 : 8 : (invalid_elif_stmt_var = invalid_elif_stmt_rule(p)) // invalid_elif_stmt
5966 : : )
5967 : : {
5968 : : D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_elif_stmt"));
5969 : 0 : _res = invalid_elif_stmt_var;
5970 : 0 : goto done;
5971 : : }
5972 : 8 : 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 [ + + ]: 521148 : if (p->error_indicator) {
5978 : 2 : p->level--;
5979 : 2 : 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 [ + + ]: 521146 : if (
5988 : 521146 : (_keyword = _PyPegen_expect_token(p, 636)) // token='elif'
5989 [ + - ]: 34061 : &&
5990 : 34061 : (a = named_expression_rule(p)) // named_expression
5991 [ + + ]: 34061 : &&
5992 : 34061 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5993 [ + + ]: 34060 : &&
5994 : 34060 : (b = block_rule(p)) // block
5995 [ + + ]: 34053 : &&
5996 : 34053 : (c = elif_stmt_rule(p)) // elif_stmt
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 : 14158 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6001 [ - + ]: 14158 : if (_token == NULL) {
6002 : 0 : p->level--;
6003 : 0 : return NULL;
6004 : : }
6005 : 14158 : int _end_lineno = _token->end_lineno;
6006 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6007 : 14158 : int _end_col_offset = _token->end_col_offset;
6008 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6009 : 14158 : _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
6010 [ - + - - ]: 14158 : if (_res == NULL && PyErr_Occurred()) {
6011 : 0 : p->error_indicator = 1;
6012 : 0 : p->level--;
6013 : 0 : return NULL;
6014 : : }
6015 : 14158 : goto done;
6016 : : }
6017 : 506988 : 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 [ + + ]: 506988 : if (p->error_indicator) {
6023 : 2 : p->level--;
6024 : 2 : 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 [ + + ]: 506986 : if (
6033 : 506986 : (_keyword = _PyPegen_expect_token(p, 636)) // token='elif'
6034 [ + - ]: 19901 : &&
6035 : 19901 : (a = named_expression_rule(p)) // named_expression
6036 [ + + ]: 19901 : &&
6037 : 19901 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6038 [ + + ]: 19900 : &&
6039 : 19900 : (b = block_rule(p)) // block
6040 : 19895 : &&
6041 [ + + ]: 19895 : (c = else_block_rule(p), !p->error_indicator) // else_block?
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 : 19892 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6046 [ - + ]: 19892 : if (_token == NULL) {
6047 : 0 : p->level--;
6048 : 0 : return NULL;
6049 : : }
6050 : 19892 : int _end_lineno = _token->end_lineno;
6051 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6052 : 19892 : int _end_col_offset = _token->end_col_offset;
6053 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6054 : 19892 : _res = _PyAST_If ( a , b , c , EXTRA );
6055 [ - + - - ]: 19892 : if (_res == NULL && PyErr_Occurred()) {
6056 : 0 : p->error_indicator = 1;
6057 : 0 : p->level--;
6058 : 0 : return NULL;
6059 : : }
6060 : 19892 : goto done;
6061 : : }
6062 : 487094 : 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 : 487094 : _res = NULL;
6067 : 521144 : done:
6068 : 521144 : p->level--;
6069 : 521144 : return _res;
6070 : : }
6071 : :
6072 : : // else_block: invalid_else_stmt | 'else' &&':' block
6073 : : static asdl_stmt_seq*
6074 : 601515 : else_block_rule(Parser *p)
6075 : : {
6076 [ - + ]: 601515 : if (p->level++ == MAXSTACK) {
6077 : 0 : p->error_indicator = 1;
6078 : : PyErr_NoMemory();
6079 : : }
6080 [ - + ]: 601515 : if (p->error_indicator) {
6081 : 0 : p->level--;
6082 : 0 : return NULL;
6083 : : }
6084 : 601515 : asdl_stmt_seq* _res = NULL;
6085 : 601515 : int _mark = p->mark;
6086 [ + + ]: 601515 : if (p->call_invalid_rules) { // invalid_else_stmt
6087 [ - + ]: 6 : if (p->error_indicator) {
6088 : 0 : p->level--;
6089 : 0 : 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 [ - + ]: 6 : if (
6094 : 6 : (invalid_else_stmt_var = invalid_else_stmt_rule(p)) // invalid_else_stmt
6095 : : )
6096 : : {
6097 : : D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_else_stmt"));
6098 : 0 : _res = invalid_else_stmt_var;
6099 : 0 : goto done;
6100 : : }
6101 : 6 : 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 [ + + ]: 601515 : if (p->error_indicator) {
6107 : 3 : p->level--;
6108 : 3 : 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 [ + + ]: 601512 : if (
6115 : 601512 : (_keyword = _PyPegen_expect_token(p, 637)) // token='else'
6116 [ + + ]: 67780 : &&
6117 : 67780 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6118 [ + + ]: 67779 : &&
6119 : 67779 : (b = block_rule(p)) // block
6120 : : )
6121 : : {
6122 : : D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' &&':' block"));
6123 : 67758 : _res = b;
6124 [ - + - - ]: 67758 : if (_res == NULL && PyErr_Occurred()) {
6125 : 0 : p->error_indicator = 1;
6126 : 0 : p->level--;
6127 : 0 : return NULL;
6128 : : }
6129 : 67758 : goto done;
6130 : : }
6131 : 533754 : 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 : 533754 : _res = NULL;
6136 : 601512 : done:
6137 : 601512 : p->level--;
6138 : 601512 : return _res;
6139 : : }
6140 : :
6141 : : // while_stmt: invalid_while_stmt | 'while' named_expression ':' block else_block?
6142 : : static stmt_ty
6143 : 11686 : while_stmt_rule(Parser *p)
6144 : : {
6145 [ - + ]: 11686 : if (p->level++ == MAXSTACK) {
6146 : 0 : p->error_indicator = 1;
6147 : : PyErr_NoMemory();
6148 : : }
6149 [ - + ]: 11686 : if (p->error_indicator) {
6150 : 0 : p->level--;
6151 : 0 : return NULL;
6152 : : }
6153 : 11686 : stmt_ty _res = NULL;
6154 : 11686 : int _mark = p->mark;
6155 [ - + - - ]: 11686 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6156 : 0 : p->error_indicator = 1;
6157 : 0 : p->level--;
6158 : 0 : return NULL;
6159 : : }
6160 : 11686 : int _start_lineno = p->tokens[_mark]->lineno;
6161 : : UNUSED(_start_lineno); // Only used by EXTRA macro
6162 : 11686 : int _start_col_offset = p->tokens[_mark]->col_offset;
6163 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
6164 [ + + ]: 11686 : if (p->call_invalid_rules) { // invalid_while_stmt
6165 [ - + ]: 23 : if (p->error_indicator) {
6166 : 0 : p->level--;
6167 : 0 : 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 [ - + ]: 23 : if (
6172 : 23 : (invalid_while_stmt_var = invalid_while_stmt_rule(p)) // invalid_while_stmt
6173 : : )
6174 : : {
6175 : : D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_while_stmt"));
6176 : 0 : _res = invalid_while_stmt_var;
6177 : 0 : goto done;
6178 : : }
6179 : 23 : 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 [ + + ]: 11686 : if (p->error_indicator) {
6185 : 4 : p->level--;
6186 : 4 : 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 [ + - ]: 11682 : if (
6195 : 11682 : (_keyword = _PyPegen_expect_token(p, 639)) // token='while'
6196 [ + + ]: 11682 : &&
6197 : 11682 : (a = named_expression_rule(p)) // named_expression
6198 [ + + ]: 11680 : &&
6199 : 11680 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6200 [ + + ]: 11677 : &&
6201 : 11677 : (b = block_rule(p)) // block
6202 : 11638 : &&
6203 [ + - ]: 11638 : (c = else_block_rule(p), !p->error_indicator) // else_block?
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 : 11638 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6208 [ - + ]: 11638 : if (_token == NULL) {
6209 : 0 : p->level--;
6210 : 0 : return NULL;
6211 : : }
6212 : 11638 : int _end_lineno = _token->end_lineno;
6213 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6214 : 11638 : int _end_col_offset = _token->end_col_offset;
6215 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6216 : 11638 : _res = _PyAST_While ( a , b , c , EXTRA );
6217 [ - + - - ]: 11638 : if (_res == NULL && PyErr_Occurred()) {
6218 : 0 : p->error_indicator = 1;
6219 : 0 : p->level--;
6220 : 0 : return NULL;
6221 : : }
6222 : 11638 : goto done;
6223 : : }
6224 : 44 : 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 : 44 : _res = NULL;
6229 : 11682 : done:
6230 : 11682 : p->level--;
6231 : 11682 : 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 : 61364 : for_stmt_rule(Parser *p)
6241 : : {
6242 [ - + ]: 61364 : if (p->level++ == MAXSTACK) {
6243 : 0 : p->error_indicator = 1;
6244 : : PyErr_NoMemory();
6245 : : }
6246 [ - + ]: 61364 : if (p->error_indicator) {
6247 : 0 : p->level--;
6248 : 0 : return NULL;
6249 : : }
6250 : 61364 : stmt_ty _res = NULL;
6251 : 61364 : int _mark = p->mark;
6252 [ - + - - ]: 61364 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6253 : 0 : p->error_indicator = 1;
6254 : 0 : p->level--;
6255 : 0 : return NULL;
6256 : : }
6257 : 61364 : int _start_lineno = p->tokens[_mark]->lineno;
6258 : : UNUSED(_start_lineno); // Only used by EXTRA macro
6259 : 61364 : int _start_col_offset = p->tokens[_mark]->col_offset;
6260 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
6261 [ + + ]: 61364 : if (p->call_invalid_rules) { // invalid_for_stmt
6262 [ - + ]: 54 : if (p->error_indicator) {
6263 : 0 : p->level--;
6264 : 0 : 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 [ - + ]: 54 : if (
6269 : 54 : (invalid_for_stmt_var = invalid_for_stmt_rule(p)) // invalid_for_stmt
6270 : : )
6271 : : {
6272 : : D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_stmt"));
6273 : 0 : _res = invalid_for_stmt_var;
6274 : 0 : goto done;
6275 : : }
6276 : 54 : 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 [ + + ]: 61364 : if (p->error_indicator) {
6282 : 3 : p->level--;
6283 : 3 : 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 : 61361 : 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 [ + + ]: 61361 : if (
6296 : 61361 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
6297 [ + + ]: 61086 : &&
6298 : 61086 : (t = star_targets_rule(p)) // star_targets
6299 [ + + ]: 61068 : &&
6300 : 61068 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
6301 : : &&
6302 : 61056 : (_cut_var = 1)
6303 [ + - ]: 61056 : &&
6304 : 61056 : (ex = star_expressions_rule(p)) // star_expressions
6305 [ + + ]: 61056 : &&
6306 : 61056 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6307 : 61053 : &&
6308 [ + - ]: 61053 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6309 [ + + ]: 61053 : &&
6310 : 61053 : (b = block_rule(p)) // block
6311 : 61047 : &&
6312 [ + + ]: 61047 : (el = else_block_rule(p), !p->error_indicator) // else_block?
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 : 61046 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6317 [ - + ]: 61046 : if (_token == NULL) {
6318 : 0 : p->level--;
6319 : 0 : return NULL;
6320 : : }
6321 : 61046 : int _end_lineno = _token->end_lineno;
6322 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6323 : 61046 : int _end_col_offset = _token->end_col_offset;
6324 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6325 : 61046 : _res = _PyAST_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
6326 [ - + - - ]: 61046 : if (_res == NULL && PyErr_Occurred()) {
6327 : 0 : p->error_indicator = 1;
6328 : 0 : p->level--;
6329 : 0 : return NULL;
6330 : : }
6331 : 61046 : goto done;
6332 : : }
6333 : 315 : 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 [ + + ]: 315 : if (_cut_var) {
6337 : 10 : p->level--;
6338 : 10 : return NULL;
6339 : : }
6340 : : }
6341 : : { // ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
6342 [ - + ]: 305 : if (p->error_indicator) {
6343 : 0 : p->level--;
6344 : 0 : 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 : 305 : 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 [ + + ]: 305 : if (
6358 : 305 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
6359 [ + + ]: 275 : &&
6360 : 275 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
6361 [ + - ]: 193 : &&
6362 : 193 : (t = star_targets_rule(p)) // star_targets
6363 [ + - ]: 193 : &&
6364 : 193 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
6365 : : &&
6366 : 193 : (_cut_var = 1)
6367 [ + - ]: 193 : &&
6368 : 193 : (ex = star_expressions_rule(p)) // star_expressions
6369 [ + - ]: 193 : &&
6370 : 193 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6371 : 193 : &&
6372 [ + - ]: 193 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6373 [ + + ]: 193 : &&
6374 : 193 : (b = block_rule(p)) // block
6375 : 192 : &&
6376 [ + + ]: 192 : (el = else_block_rule(p), !p->error_indicator) // else_block?
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 : 191 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6381 [ - + ]: 191 : if (_token == NULL) {
6382 : 0 : p->level--;
6383 : 0 : return NULL;
6384 : : }
6385 : 191 : int _end_lineno = _token->end_lineno;
6386 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6387 : 191 : int _end_col_offset = _token->end_col_offset;
6388 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6389 : 191 : _res = CHECK_VERSION ( stmt_ty , 5 , "Async for loops are" , _PyAST_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
6390 [ - + - - ]: 191 : if (_res == NULL && PyErr_Occurred()) {
6391 : 0 : p->error_indicator = 1;
6392 : 0 : p->level--;
6393 : 0 : return NULL;
6394 : : }
6395 : 191 : goto done;
6396 : : }
6397 : 114 : 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 [ + + ]: 114 : if (_cut_var) {
6401 : 2 : p->level--;
6402 : 2 : return NULL;
6403 : : }
6404 : : }
6405 [ + + ]: 112 : if (p->call_invalid_rules) { // invalid_for_target
6406 [ - + ]: 47 : if (p->error_indicator) {
6407 : 0 : p->level--;
6408 : 0 : 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 [ - + ]: 47 : if (
6413 : 47 : (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target
6414 : : )
6415 : : {
6416 : : D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
6417 : 0 : _res = invalid_for_target_var;
6418 : 0 : goto done;
6419 : : }
6420 : 47 : 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 : 112 : _res = NULL;
6425 : 61349 : done:
6426 : 61349 : p->level--;
6427 : 61349 : 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 : 39282 : with_stmt_rule(Parser *p)
6439 : : {
6440 [ - + ]: 39282 : if (p->level++ == MAXSTACK) {
6441 : 0 : p->error_indicator = 1;
6442 : : PyErr_NoMemory();
6443 : : }
6444 [ - + ]: 39282 : if (p->error_indicator) {
6445 : 0 : p->level--;
6446 : 0 : return NULL;
6447 : : }
6448 : 39282 : stmt_ty _res = NULL;
6449 : 39282 : int _mark = p->mark;
6450 [ - + - - ]: 39282 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6451 : 0 : p->error_indicator = 1;
6452 : 0 : p->level--;
6453 : 0 : return NULL;
6454 : : }
6455 : 39282 : int _start_lineno = p->tokens[_mark]->lineno;
6456 : : UNUSED(_start_lineno); // Only used by EXTRA macro
6457 : 39282 : int _start_col_offset = p->tokens[_mark]->col_offset;
6458 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
6459 [ + + ]: 39282 : if (p->call_invalid_rules) { // invalid_with_stmt_indent
6460 [ - + ]: 63 : if (p->error_indicator) {
6461 : 0 : p->level--;
6462 : 0 : 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 [ - + ]: 63 : if (
6467 : 63 : (invalid_with_stmt_indent_var = invalid_with_stmt_indent_rule(p)) // invalid_with_stmt_indent
6468 : : )
6469 : : {
6470 : : D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt_indent"));
6471 : 0 : _res = invalid_with_stmt_indent_var;
6472 : 0 : goto done;
6473 : : }
6474 : 63 : 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 [ + + ]: 39282 : if (p->error_indicator) {
6480 : 7 : p->level--;
6481 : 7 : 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 [ + + ]: 39275 : if (
6493 : 39275 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
6494 [ + + ]: 38628 : &&
6495 : 38628 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
6496 [ + + ]: 72 : &&
6497 : 72 : (a = (asdl_withitem_seq*)_gather_51_rule(p)) // ','.with_item+
6498 : 71 : &&
6499 [ + - ]: 71 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
6500 [ + - ]: 71 : &&
6501 : 71 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
6502 [ + + ]: 71 : &&
6503 : 71 : (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
6504 [ + + ]: 35 : &&
6505 : 35 : (b = block_rule(p)) // block
6506 : : )
6507 : : {
6508 : : D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block"));
6509 : 34 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6510 [ - + ]: 34 : if (_token == NULL) {
6511 : 0 : p->level--;
6512 : 0 : return NULL;
6513 : : }
6514 : 34 : int _end_lineno = _token->end_lineno;
6515 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6516 : 34 : int _end_col_offset = _token->end_col_offset;
6517 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6518 : 34 : _res = CHECK_VERSION ( stmt_ty , 9 , "Parenthesized context managers are" , _PyAST_With ( a , b , NULL , EXTRA ) );
6519 [ + + + - ]: 34 : if (_res == NULL && PyErr_Occurred()) {
6520 : 1 : p->error_indicator = 1;
6521 : 1 : p->level--;
6522 : 1 : return NULL;
6523 : : }
6524 : 33 : goto done;
6525 : : }
6526 : 39241 : 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 [ - + ]: 39241 : if (p->error_indicator) {
6532 : 0 : p->level--;
6533 : 0 : 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 [ + + ]: 39241 : if (
6542 : 39241 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
6543 [ + + ]: 38594 : &&
6544 : 38594 : (a = (asdl_withitem_seq*)_gather_53_rule(p)) // ','.with_item+
6545 [ + + ]: 38574 : &&
6546 : 38574 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6547 : 38548 : &&
6548 [ + - ]: 38548 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6549 [ + + ]: 38548 : &&
6550 : 38548 : (b = block_rule(p)) // block
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 : 38542 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6555 [ - + ]: 38542 : if (_token == NULL) {
6556 : 0 : p->level--;
6557 : 0 : return NULL;
6558 : : }
6559 : 38542 : int _end_lineno = _token->end_lineno;
6560 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6561 : 38542 : int _end_col_offset = _token->end_col_offset;
6562 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6563 : 38542 : _res = _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
6564 [ - + - - ]: 38542 : if (_res == NULL && PyErr_Occurred()) {
6565 : 0 : p->error_indicator = 1;
6566 : 0 : p->level--;
6567 : 0 : return NULL;
6568 : : }
6569 : 38542 : goto done;
6570 : : }
6571 : 699 : 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 [ + + ]: 699 : if (p->error_indicator) {
6577 : 11 : p->level--;
6578 : 11 : 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 [ + + ]: 688 : if (
6591 : 688 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
6592 [ + + ]: 647 : &&
6593 : 647 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
6594 [ + + ]: 374 : &&
6595 : 374 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
6596 [ + - ]: 1 : &&
6597 : 1 : (a = (asdl_withitem_seq*)_gather_55_rule(p)) // ','.with_item+
6598 : 1 : &&
6599 [ + - ]: 1 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
6600 [ + - ]: 1 : &&
6601 : 1 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
6602 [ + - ]: 1 : &&
6603 : 1 : (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
6604 [ - + ]: 1 : &&
6605 : 1 : (b = block_rule(p)) // block
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 : 0 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6610 [ # # ]: 0 : if (_token == NULL) {
6611 : 0 : p->level--;
6612 : 0 : return NULL;
6613 : : }
6614 : 0 : int _end_lineno = _token->end_lineno;
6615 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6616 : 0 : int _end_col_offset = _token->end_col_offset;
6617 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6618 : 0 : _res = CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NULL , EXTRA ) );
6619 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
6620 : 0 : p->error_indicator = 1;
6621 : 0 : p->level--;
6622 : 0 : return NULL;
6623 : : }
6624 : 0 : goto done;
6625 : : }
6626 : 688 : 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 [ - + ]: 688 : if (p->error_indicator) {
6632 : 0 : p->level--;
6633 : 0 : 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 [ + + ]: 688 : if (
6643 : 688 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
6644 [ + + ]: 647 : &&
6645 : 647 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
6646 [ + + ]: 374 : &&
6647 : 374 : (a = (asdl_withitem_seq*)_gather_57_rule(p)) // ','.with_item+
6648 [ + - ]: 373 : &&
6649 : 373 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6650 : 373 : &&
6651 [ + - ]: 373 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6652 [ + + ]: 373 : &&
6653 : 373 : (b = block_rule(p)) // block
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 : 371 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6658 [ - + ]: 371 : if (_token == NULL) {
6659 : 0 : p->level--;
6660 : 0 : return NULL;
6661 : : }
6662 : 371 : int _end_lineno = _token->end_lineno;
6663 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6664 : 371 : int _end_col_offset = _token->end_col_offset;
6665 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6666 : 371 : _res = CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
6667 [ - + - - ]: 371 : if (_res == NULL && PyErr_Occurred()) {
6668 : 0 : p->error_indicator = 1;
6669 : 0 : p->level--;
6670 : 0 : return NULL;
6671 : : }
6672 : 371 : goto done;
6673 : : }
6674 : 317 : 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 [ + + ]: 317 : if (p->call_invalid_rules) { // invalid_with_stmt
6679 [ - + ]: 45 : if (p->error_indicator) {
6680 : 0 : p->level--;
6681 : 0 : 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 [ - + ]: 45 : if (
6686 : 45 : (invalid_with_stmt_var = invalid_with_stmt_rule(p)) // invalid_with_stmt
6687 : : )
6688 : : {
6689 : : D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt"));
6690 : 0 : _res = invalid_with_stmt_var;
6691 : 0 : goto done;
6692 : : }
6693 : 45 : 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 : 317 : _res = NULL;
6698 : 39263 : done:
6699 : 39263 : p->level--;
6700 : 39263 : return _res;
6701 : : }
6702 : :
6703 : : // with_item:
6704 : : // | expression 'as' star_target &(',' | ')' | ':')
6705 : : // | invalid_with_item
6706 : : // | expression
6707 : : static withitem_ty
6708 : 39864 : with_item_rule(Parser *p)
6709 : : {
6710 [ - + ]: 39864 : if (p->level++ == MAXSTACK) {
6711 : 0 : p->error_indicator = 1;
6712 : : PyErr_NoMemory();
6713 : : }
6714 [ - + ]: 39864 : if (p->error_indicator) {
6715 : 0 : p->level--;
6716 : 0 : return NULL;
6717 : : }
6718 : 39864 : withitem_ty _res = NULL;
6719 : 39864 : int _mark = p->mark;
6720 : : { // expression 'as' star_target &(',' | ')' | ':')
6721 [ - + ]: 39864 : if (p->error_indicator) {
6722 : 0 : p->level--;
6723 : 0 : 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 [ + + ]: 39864 : if (
6730 : 39864 : (e = expression_rule(p)) // expression
6731 [ + + ]: 39843 : &&
6732 : 39843 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
6733 [ + + ]: 16848 : &&
6734 : 16848 : (t = star_target_rule(p)) // star_target
6735 [ + + ]: 16830 : &&
6736 : 16830 : _PyPegen_lookahead(1, _tmp_59_rule, p)
6737 : : )
6738 : : {
6739 : : D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
6740 : 16820 : _res = _PyAST_withitem ( e , t , p -> arena );
6741 [ - + - - ]: 16820 : if (_res == NULL && PyErr_Occurred()) {
6742 : 0 : p->error_indicator = 1;
6743 : 0 : p->level--;
6744 : 0 : return NULL;
6745 : : }
6746 : 16820 : goto done;
6747 : : }
6748 : 23044 : 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 [ + + ]: 23044 : if (p->call_invalid_rules) { // invalid_with_item
6753 [ - + ]: 28 : if (p->error_indicator) {
6754 : 0 : p->level--;
6755 : 0 : 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 [ - + ]: 28 : if (
6760 : 28 : (invalid_with_item_var = invalid_with_item_rule(p)) // invalid_with_item
6761 : : )
6762 : : {
6763 : : D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_item"));
6764 : 0 : _res = invalid_with_item_var;
6765 : 0 : goto done;
6766 : : }
6767 : 28 : 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 [ + + ]: 23044 : if (p->error_indicator) {
6773 : 11 : p->level--;
6774 : 11 : 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 [ + + ]: 23033 : if (
6779 : 23033 : (e = expression_rule(p)) // expression
6780 : : )
6781 : : {
6782 : : D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
6783 : 23012 : _res = _PyAST_withitem ( e , NULL , p -> arena );
6784 [ - + - - ]: 23012 : if (_res == NULL && PyErr_Occurred()) {
6785 : 0 : p->error_indicator = 1;
6786 : 0 : p->level--;
6787 : 0 : return NULL;
6788 : : }
6789 : 23012 : goto done;
6790 : : }
6791 : 21 : 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 : 21 : _res = NULL;
6796 : 39853 : done:
6797 : 39853 : p->level--;
6798 : 39853 : 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 : 49059 : try_stmt_rule(Parser *p)
6808 : : {
6809 [ - + ]: 49059 : if (p->level++ == MAXSTACK) {
6810 : 0 : p->error_indicator = 1;
6811 : : PyErr_NoMemory();
6812 : : }
6813 [ - + ]: 49059 : if (p->error_indicator) {
6814 : 0 : p->level--;
6815 : 0 : return NULL;
6816 : : }
6817 : 49059 : stmt_ty _res = NULL;
6818 : 49059 : int _mark = p->mark;
6819 [ - + - - ]: 49059 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6820 : 0 : p->error_indicator = 1;
6821 : 0 : p->level--;
6822 : 0 : return NULL;
6823 : : }
6824 : 49059 : int _start_lineno = p->tokens[_mark]->lineno;
6825 : : UNUSED(_start_lineno); // Only used by EXTRA macro
6826 : 49059 : int _start_col_offset = p->tokens[_mark]->col_offset;
6827 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
6828 [ + + ]: 49059 : if (p->call_invalid_rules) { // invalid_try_stmt
6829 [ - + ]: 51 : if (p->error_indicator) {
6830 : 0 : p->level--;
6831 : 0 : 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 [ - + ]: 51 : if (
6836 : 51 : (invalid_try_stmt_var = invalid_try_stmt_rule(p)) // invalid_try_stmt
6837 : : )
6838 : : {
6839 : : D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_try_stmt"));
6840 : 0 : _res = invalid_try_stmt_var;
6841 : 0 : goto done;
6842 : : }
6843 : 51 : 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 [ + + ]: 49059 : if (p->error_indicator) {
6849 : 29 : p->level--;
6850 : 29 : 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 [ + - ]: 49030 : if (
6858 : 49030 : (_keyword = _PyPegen_expect_token(p, 618)) // token='try'
6859 [ + + ]: 49030 : &&
6860 : 49030 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6861 [ + + ]: 49027 : &&
6862 : 49027 : (b = block_rule(p)) // block
6863 [ + + ]: 49005 : &&
6864 : 49005 : (f = finally_block_rule(p)) // finally_block
6865 : : )
6866 : : {
6867 : : D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &&':' block finally_block"));
6868 : 7417 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6869 [ - + ]: 7417 : if (_token == NULL) {
6870 : 0 : p->level--;
6871 : 0 : return NULL;
6872 : : }
6873 : 7417 : int _end_lineno = _token->end_lineno;
6874 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6875 : 7417 : int _end_col_offset = _token->end_col_offset;
6876 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6877 : 7417 : _res = _PyAST_Try ( b , NULL , NULL , f , EXTRA );
6878 [ - + - - ]: 7417 : if (_res == NULL && PyErr_Occurred()) {
6879 : 0 : p->error_indicator = 1;
6880 : 0 : p->level--;
6881 : 0 : return NULL;
6882 : : }
6883 : 7417 : goto done;
6884 : : }
6885 : 41613 : 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 [ + + ]: 41613 : if (p->error_indicator) {
6891 : 4 : p->level--;
6892 : 4 : 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 [ + - ]: 41609 : if (
6902 : 41609 : (_keyword = _PyPegen_expect_token(p, 618)) // token='try'
6903 [ + - ]: 41609 : &&
6904 : 41609 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6905 [ + + ]: 41609 : &&
6906 : 41609 : (b = block_rule(p)) // block
6907 [ + + ]: 41588 : &&
6908 : 41588 : (ex = (asdl_excepthandler_seq*)_loop1_60_rule(p)) // except_block+
6909 : 41291 : &&
6910 [ + - ]: 41291 : (el = else_block_rule(p), !p->error_indicator) // else_block?
6911 : 41291 : &&
6912 [ + + ]: 41291 : (f = finally_block_rule(p), !p->error_indicator) // finally_block?
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 : 41290 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6917 [ - + ]: 41290 : if (_token == NULL) {
6918 : 0 : p->level--;
6919 : 0 : return NULL;
6920 : : }
6921 : 41290 : int _end_lineno = _token->end_lineno;
6922 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6923 : 41290 : int _end_col_offset = _token->end_col_offset;
6924 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6925 : 41290 : _res = _PyAST_Try ( b , ex , el , f , EXTRA );
6926 [ - + - - ]: 41290 : if (_res == NULL && PyErr_Occurred()) {
6927 : 0 : p->error_indicator = 1;
6928 : 0 : p->level--;
6929 : 0 : return NULL;
6930 : : }
6931 : 41290 : goto done;
6932 : : }
6933 : 319 : 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 [ + + ]: 319 : if (p->error_indicator) {
6939 : 1 : p->level--;
6940 : 1 : 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 [ + - ]: 318 : if (
6950 : 318 : (_keyword = _PyPegen_expect_token(p, 618)) // token='try'
6951 [ + - ]: 318 : &&
6952 : 318 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6953 [ + + ]: 318 : &&
6954 : 318 : (b = block_rule(p)) // block
6955 [ + + ]: 297 : &&
6956 : 297 : (ex = (asdl_excepthandler_seq*)_loop1_61_rule(p)) // except_star_block+
6957 : 256 : &&
6958 [ + - ]: 256 : (el = else_block_rule(p), !p->error_indicator) // else_block?
6959 : 256 : &&
6960 [ + + ]: 256 : (f = finally_block_rule(p), !p->error_indicator) // finally_block?
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 : 255 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6965 [ - + ]: 255 : if (_token == NULL) {
6966 : 0 : p->level--;
6967 : 0 : return NULL;
6968 : : }
6969 : 255 : int _end_lineno = _token->end_lineno;
6970 : : UNUSED(_end_lineno); // Only used by EXTRA macro
6971 : 255 : int _end_col_offset = _token->end_col_offset;
6972 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
6973 : 255 : _res = _PyAST_TryStar ( b , ex , el , f , EXTRA );
6974 [ - + - - ]: 255 : if (_res == NULL && PyErr_Occurred()) {
6975 : 0 : p->error_indicator = 1;
6976 : 0 : p->level--;
6977 : 0 : return NULL;
6978 : : }
6979 : 255 : goto done;
6980 : : }
6981 : 63 : 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 : 63 : _res = NULL;
6986 : 49025 : done:
6987 : 49025 : p->level--;
6988 : 49025 : 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 : 85594 : except_block_rule(Parser *p)
6998 : : {
6999 [ - + ]: 85594 : if (p->level++ == MAXSTACK) {
7000 : 0 : p->error_indicator = 1;
7001 : : PyErr_NoMemory();
7002 : : }
7003 [ - + ]: 85594 : if (p->error_indicator) {
7004 : 0 : p->level--;
7005 : 0 : return NULL;
7006 : : }
7007 : 85594 : excepthandler_ty _res = NULL;
7008 : 85594 : int _mark = p->mark;
7009 [ + + - + ]: 85594 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7010 : 0 : p->error_indicator = 1;
7011 : 0 : p->level--;
7012 : 0 : return NULL;
7013 : : }
7014 : 85594 : int _start_lineno = p->tokens[_mark]->lineno;
7015 : : UNUSED(_start_lineno); // Only used by EXTRA macro
7016 : 85594 : int _start_col_offset = p->tokens[_mark]->col_offset;
7017 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
7018 [ + + ]: 85594 : if (p->call_invalid_rules) { // invalid_except_stmt_indent
7019 [ - + ]: 78 : if (p->error_indicator) {
7020 : 0 : p->level--;
7021 : 0 : 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 [ - + ]: 78 : if (
7026 : 78 : (invalid_except_stmt_indent_var = invalid_except_stmt_indent_rule(p)) // invalid_except_stmt_indent
7027 : : )
7028 : : {
7029 : : D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt_indent"));
7030 : 0 : _res = invalid_except_stmt_indent_var;
7031 : 0 : goto done;
7032 : : }
7033 : 78 : 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 [ + + ]: 85594 : if (p->error_indicator) {
7039 : 2 : p->level--;
7040 : 2 : 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 [ + + ]: 85592 : if (
7049 : 85592 : (_keyword = _PyPegen_expect_token(p, 629)) // token='except'
7050 [ + + ]: 44266 : &&
7051 : 44266 : (e = expression_rule(p)) // expression
7052 : 41811 : &&
7053 [ + - ]: 41811 : (t = _tmp_62_rule(p), !p->error_indicator) // ['as' NAME]
7054 [ + + ]: 41811 : &&
7055 : 41811 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7056 [ + + ]: 41800 : &&
7057 : 41800 : (b = block_rule(p)) // block
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 : 41799 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7062 [ - + ]: 41799 : if (_token == NULL) {
7063 : 0 : p->level--;
7064 : 0 : return NULL;
7065 : : }
7066 : 41799 : int _end_lineno = _token->end_lineno;
7067 : : UNUSED(_end_lineno); // Only used by EXTRA macro
7068 : 41799 : int _end_col_offset = _token->end_col_offset;
7069 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
7070 [ + + ]: 41799 : _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
7071 [ - + - - ]: 41799 : if (_res == NULL && PyErr_Occurred()) {
7072 : 0 : p->error_indicator = 1;
7073 : 0 : p->level--;
7074 : 0 : return NULL;
7075 : : }
7076 : 41799 : goto done;
7077 : : }
7078 : 43793 : 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 [ - + ]: 43793 : if (p->error_indicator) {
7084 : 0 : p->level--;
7085 : 0 : 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 [ + + ]: 43793 : if (
7092 : 43793 : (_keyword = _PyPegen_expect_token(p, 629)) // token='except'
7093 [ + + ]: 2467 : &&
7094 : 2467 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7095 [ + + ]: 2160 : &&
7096 : 2160 : (b = block_rule(p)) // block
7097 : : )
7098 : : {
7099 : : D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' block"));
7100 : 2157 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7101 [ - + ]: 2157 : if (_token == NULL) {
7102 : 0 : p->level--;
7103 : 0 : return NULL;
7104 : : }
7105 : 2157 : int _end_lineno = _token->end_lineno;
7106 : : UNUSED(_end_lineno); // Only used by EXTRA macro
7107 : 2157 : int _end_col_offset = _token->end_col_offset;
7108 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
7109 : 2157 : _res = _PyAST_ExceptHandler ( NULL , NULL , b , EXTRA );
7110 [ - + - - ]: 2157 : if (_res == NULL && PyErr_Occurred()) {
7111 : 0 : p->error_indicator = 1;
7112 : 0 : p->level--;
7113 : 0 : return NULL;
7114 : : }
7115 : 2157 : goto done;
7116 : : }
7117 : 41636 : 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 [ + + ]: 41636 : if (p->call_invalid_rules) { // invalid_except_stmt
7122 [ - + ]: 61 : if (p->error_indicator) {
7123 : 0 : p->level--;
7124 : 0 : 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 [ - + ]: 61 : if (
7129 : 61 : (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt
7130 : : )
7131 : : {
7132 : : D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt"));
7133 : 0 : _res = invalid_except_stmt_var;
7134 : 0 : goto done;
7135 : : }
7136 : 61 : 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 : 41636 : _res = NULL;
7141 : 85592 : done:
7142 : 85592 : p->level--;
7143 : 85592 : 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 : 659 : except_star_block_rule(Parser *p)
7152 : : {
7153 [ - + ]: 659 : if (p->level++ == MAXSTACK) {
7154 : 0 : p->error_indicator = 1;
7155 : : PyErr_NoMemory();
7156 : : }
7157 [ - + ]: 659 : if (p->error_indicator) {
7158 : 0 : p->level--;
7159 : 0 : return NULL;
7160 : : }
7161 : 659 : excepthandler_ty _res = NULL;
7162 : 659 : int _mark = p->mark;
7163 [ + + - + ]: 659 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7164 : 0 : p->error_indicator = 1;
7165 : 0 : p->level--;
7166 : 0 : return NULL;
7167 : : }
7168 : 659 : int _start_lineno = p->tokens[_mark]->lineno;
7169 : : UNUSED(_start_lineno); // Only used by EXTRA macro
7170 : 659 : int _start_col_offset = p->tokens[_mark]->col_offset;
7171 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
7172 [ + + ]: 659 : if (p->call_invalid_rules) { // invalid_except_star_stmt_indent
7173 [ - + ]: 58 : if (p->error_indicator) {
7174 : 0 : p->level--;
7175 : 0 : 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 [ - + ]: 58 : if (
7180 : 58 : (invalid_except_star_stmt_indent_var = invalid_except_star_stmt_indent_rule(p)) // invalid_except_star_stmt_indent
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 : 0 : _res = invalid_except_star_stmt_indent_var;
7185 : 0 : goto done;
7186 : : }
7187 : 58 : 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 [ + + ]: 659 : if (p->error_indicator) {
7193 : 1 : p->level--;
7194 : 1 : 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 [ + + ]: 658 : if (
7204 : 658 : (_keyword = _PyPegen_expect_token(p, 629)) // token='except'
7205 [ + + ]: 368 : &&
7206 : 368 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
7207 [ + + ]: 343 : &&
7208 : 343 : (e = expression_rule(p)) // expression
7209 : 339 : &&
7210 [ + - ]: 339 : (t = _tmp_63_rule(p), !p->error_indicator) // ['as' NAME]
7211 [ + + ]: 339 : &&
7212 : 339 : (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
7213 [ + + ]: 332 : &&
7214 : 332 : (b = block_rule(p)) // block
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 : 331 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7219 [ - + ]: 331 : if (_token == NULL) {
7220 : 0 : p->level--;
7221 : 0 : return NULL;
7222 : : }
7223 : 331 : int _end_lineno = _token->end_lineno;
7224 : : UNUSED(_end_lineno); // Only used by EXTRA macro
7225 : 331 : int _end_col_offset = _token->end_col_offset;
7226 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
7227 [ + + ]: 331 : _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
7228 [ - + - - ]: 331 : if (_res == NULL && PyErr_Occurred()) {
7229 : 0 : p->error_indicator = 1;
7230 : 0 : p->level--;
7231 : 0 : return NULL;
7232 : : }
7233 : 331 : goto done;
7234 : : }
7235 : 327 : 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 [ + + ]: 327 : if (p->call_invalid_rules) { // invalid_except_stmt
7240 [ - + ]: 42 : if (p->error_indicator) {
7241 : 0 : p->level--;
7242 : 0 : 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 [ - + ]: 42 : if (
7247 : 42 : (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt
7248 : : )
7249 : : {
7250 : : D(fprintf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt"));
7251 : 0 : _res = invalid_except_stmt_var;
7252 : 0 : goto done;
7253 : : }
7254 : 42 : 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 : 327 : _res = NULL;
7259 : 658 : done:
7260 : 658 : p->level--;
7261 : 658 : return _res;
7262 : : }
7263 : :
7264 : : // finally_block: invalid_finally_stmt | 'finally' &&':' block
7265 : : static asdl_stmt_seq*
7266 : 90552 : finally_block_rule(Parser *p)
7267 : : {
7268 [ - + ]: 90552 : if (p->level++ == MAXSTACK) {
7269 : 0 : p->error_indicator = 1;
7270 : : PyErr_NoMemory();
7271 : : }
7272 [ - + ]: 90552 : if (p->error_indicator) {
7273 : 0 : p->level--;
7274 : 0 : return NULL;
7275 : : }
7276 : 90552 : asdl_stmt_seq* _res = NULL;
7277 : 90552 : int _mark = p->mark;
7278 [ + + ]: 90552 : if (p->call_invalid_rules) { // invalid_finally_stmt
7279 [ - + ]: 15 : if (p->error_indicator) {
7280 : 0 : p->level--;
7281 : 0 : 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 [ - + ]: 15 : if (
7286 : 15 : (invalid_finally_stmt_var = invalid_finally_stmt_rule(p)) // invalid_finally_stmt
7287 : : )
7288 : : {
7289 : : D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_finally_stmt"));
7290 : 0 : _res = invalid_finally_stmt_var;
7291 : 0 : goto done;
7292 : : }
7293 : 15 : 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 [ + + ]: 90552 : if (p->error_indicator) {
7299 : 2 : p->level--;
7300 : 2 : 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 [ + + ]: 90550 : if (
7307 : 90550 : (_keyword = _PyPegen_expect_token(p, 625)) // token='finally'
7308 [ + - ]: 8121 : &&
7309 : 8121 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
7310 [ + + ]: 8121 : &&
7311 : 8121 : (a = block_rule(p)) // block
7312 : : )
7313 : : {
7314 : : D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally' &&':' block"));
7315 : 8097 : _res = a;
7316 [ - + - - ]: 8097 : if (_res == NULL && PyErr_Occurred()) {
7317 : 0 : p->error_indicator = 1;
7318 : 0 : p->level--;
7319 : 0 : return NULL;
7320 : : }
7321 : 8097 : goto done;
7322 : : }
7323 : 82453 : 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 : 82453 : _res = NULL;
7328 : 90550 : done:
7329 : 90550 : p->level--;
7330 : 90550 : 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 : 2992338 : match_stmt_rule(Parser *p)
7338 : : {
7339 [ - + ]: 2992338 : if (p->level++ == MAXSTACK) {
7340 : 0 : p->error_indicator = 1;
7341 : : PyErr_NoMemory();
7342 : : }
7343 [ - + ]: 2992338 : if (p->error_indicator) {
7344 : 0 : p->level--;
7345 : 0 : return NULL;
7346 : : }
7347 : 2992338 : stmt_ty _res = NULL;
7348 : 2992338 : int _mark = p->mark;
7349 [ - + - - ]: 2992338 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7350 : 0 : p->error_indicator = 1;
7351 : 0 : p->level--;
7352 : 0 : return NULL;
7353 : : }
7354 : 2992338 : int _start_lineno = p->tokens[_mark]->lineno;
7355 : : UNUSED(_start_lineno); // Only used by EXTRA macro
7356 : 2992338 : 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 [ - + ]: 2992338 : if (p->error_indicator) {
7360 : 0 : p->level--;
7361 : 0 : 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 [ + + ]: 2992338 : if (
7372 : 2992338 : (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"'
7373 [ + + ]: 2362 : &&
7374 : 2362 : (subject = subject_expr_rule(p)) // subject_expr
7375 [ + + ]: 1276 : &&
7376 : 1276 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7377 [ + - ]: 1271 : &&
7378 : 1271 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
7379 [ + + ]: 1271 : &&
7380 : 1271 : (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT'
7381 [ + + ]: 1269 : &&
7382 : 1269 : (cases = (asdl_match_case_seq*)_loop1_64_rule(p)) // case_block+
7383 [ + + ]: 1224 : &&
7384 : 1224 : (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT'
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 : 1223 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7389 [ - + ]: 1223 : if (_token == NULL) {
7390 : 0 : p->level--;
7391 : 0 : return NULL;
7392 : : }
7393 : 1223 : int _end_lineno = _token->end_lineno;
7394 : : UNUSED(_end_lineno); // Only used by EXTRA macro
7395 : 1223 : int _end_col_offset = _token->end_col_offset;
7396 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
7397 : 1223 : _res = CHECK_VERSION ( stmt_ty , 10 , "Pattern matching is" , _PyAST_Match ( subject , cases , EXTRA ) );
7398 [ - + - - ]: 1223 : if (_res == NULL && PyErr_Occurred()) {
7399 : 0 : p->error_indicator = 1;
7400 : 0 : p->level--;
7401 : 0 : return NULL;
7402 : : }
7403 : 1223 : goto done;
7404 : : }
7405 : 2991115 : 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 [ + + ]: 2991115 : if (p->call_invalid_rules) { // invalid_match_stmt
7410 [ + + ]: 840 : if (p->error_indicator) {
7411 : 11 : p->level--;
7412 : 11 : 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 [ - + ]: 829 : if (
7417 : 829 : (invalid_match_stmt_var = invalid_match_stmt_rule(p)) // invalid_match_stmt
7418 : : )
7419 : : {
7420 : : D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_match_stmt"));
7421 : 0 : _res = invalid_match_stmt_var;
7422 : 0 : goto done;
7423 : : }
7424 : 829 : 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 : 2991104 : _res = NULL;
7429 : 2992327 : done:
7430 : 2992327 : p->level--;
7431 : 2992327 : return _res;
7432 : : }
7433 : :
7434 : : // subject_expr: star_named_expression ',' star_named_expressions? | named_expression
7435 : : static expr_ty
7436 : 2385 : subject_expr_rule(Parser *p)
7437 : : {
7438 [ - + ]: 2385 : if (p->level++ == MAXSTACK) {
7439 : 0 : p->error_indicator = 1;
7440 : : PyErr_NoMemory();
7441 : : }
7442 [ - + ]: 2385 : if (p->error_indicator) {
7443 : 0 : p->level--;
7444 : 0 : return NULL;
7445 : : }
7446 : 2385 : expr_ty _res = NULL;
7447 : 2385 : int _mark = p->mark;
7448 [ + + - + ]: 2385 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7449 : 0 : p->error_indicator = 1;
7450 : 0 : p->level--;
7451 : 0 : return NULL;
7452 : : }
7453 : 2385 : int _start_lineno = p->tokens[_mark]->lineno;
7454 : : UNUSED(_start_lineno); // Only used by EXTRA macro
7455 : 2385 : 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 [ - + ]: 2385 : if (p->error_indicator) {
7459 : 0 : p->level--;
7460 : 0 : 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 [ + + ]: 2385 : if (
7467 : 2385 : (value = star_named_expression_rule(p)) // star_named_expression
7468 [ + + ]: 1299 : &&
7469 : 1299 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
7470 : 12 : &&
7471 [ + - ]: 12 : (values = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions?
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 : 12 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7476 [ - + ]: 12 : if (_token == NULL) {
7477 : 0 : p->level--;
7478 : 0 : return NULL;
7479 : : }
7480 : 12 : int _end_lineno = _token->end_lineno;
7481 : : UNUSED(_end_lineno); // Only used by EXTRA macro
7482 : 12 : int _end_col_offset = _token->end_col_offset;
7483 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
7484 : 12 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , value , values ) ) , Load , EXTRA );
7485 [ - + - - ]: 12 : if (_res == NULL && PyErr_Occurred()) {
7486 : 0 : p->error_indicator = 1;
7487 : 0 : p->level--;
7488 : 0 : return NULL;
7489 : : }
7490 : 12 : goto done;
7491 : : }
7492 : 2373 : 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 [ - + ]: 2373 : if (p->error_indicator) {
7498 : 0 : p->level--;
7499 : 0 : 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 [ + + ]: 2373 : if (
7504 : 2373 : (named_expression_var = named_expression_rule(p)) // named_expression
7505 : : )
7506 : : {
7507 : : D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
7508 : 1287 : _res = named_expression_var;
7509 : 1287 : goto done;
7510 : : }
7511 : 1086 : 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 : 1086 : _res = NULL;
7516 : 2385 : done:
7517 : 2385 : p->level--;
7518 : 2385 : return _res;
7519 : : }
7520 : :
7521 : : // case_block: invalid_case_block | "case" patterns guard? ':' block
7522 : : static match_case_ty
7523 : 3053 : case_block_rule(Parser *p)
7524 : : {
7525 [ - + ]: 3053 : if (p->level++ == MAXSTACK) {
7526 : 0 : p->error_indicator = 1;
7527 : : PyErr_NoMemory();
7528 : : }
7529 [ - + ]: 3053 : if (p->error_indicator) {
7530 : 0 : p->level--;
7531 : 0 : return NULL;
7532 : : }
7533 : 3053 : match_case_ty _res = NULL;
7534 : 3053 : int _mark = p->mark;
7535 [ + + ]: 3053 : if (p->call_invalid_rules) { // invalid_case_block
7536 [ - + ]: 21 : if (p->error_indicator) {
7537 : 0 : p->level--;
7538 : 0 : 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 [ - + ]: 21 : if (
7543 : 21 : (invalid_case_block_var = invalid_case_block_rule(p)) // invalid_case_block
7544 : : )
7545 : : {
7546 : : D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_case_block"));
7547 : 0 : _res = invalid_case_block_var;
7548 : 0 : goto done;
7549 : : }
7550 : 21 : 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 [ + + ]: 3053 : if (p->error_indicator) {
7556 : 11 : p->level--;
7557 : 11 : 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 [ + + ]: 3042 : if (
7566 : 3042 : (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"'
7567 [ + + ]: 1817 : &&
7568 : 1817 : (pattern = patterns_rule(p)) // patterns
7569 : 1793 : &&
7570 [ + - ]: 1793 : (guard = guard_rule(p), !p->error_indicator) // guard?
7571 [ + + ]: 1793 : &&
7572 : 1793 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7573 [ + + ]: 1788 : &&
7574 : 1788 : (body = block_rule(p)) // block
7575 : : )
7576 : : {
7577 : : D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' block"));
7578 : 1784 : _res = _PyAST_match_case ( pattern , guard , body , p -> arena );
7579 [ - + - - ]: 1784 : if (_res == NULL && PyErr_Occurred()) {
7580 : 0 : p->error_indicator = 1;
7581 : 0 : p->level--;
7582 : 0 : return NULL;
7583 : : }
7584 : 1784 : goto done;
7585 : : }
7586 : 1258 : 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 : 1258 : _res = NULL;
7591 : 3042 : done:
7592 : 3042 : p->level--;
7593 : 3042 : return _res;
7594 : : }
7595 : :
7596 : : // guard: 'if' named_expression
7597 : : static expr_ty
7598 : 1803 : guard_rule(Parser *p)
7599 : : {
7600 [ - + ]: 1803 : if (p->level++ == MAXSTACK) {
7601 : 0 : p->error_indicator = 1;
7602 : : PyErr_NoMemory();
7603 : : }
7604 [ - + ]: 1803 : if (p->error_indicator) {
7605 : 0 : p->level--;
7606 : 0 : return NULL;
7607 : : }
7608 : 1803 : expr_ty _res = NULL;
7609 : 1803 : int _mark = p->mark;
7610 : : { // 'if' named_expression
7611 [ - + ]: 1803 : if (p->error_indicator) {
7612 : 0 : p->level--;
7613 : 0 : 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 [ + + ]: 1803 : if (
7619 : 1803 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
7620 [ + - ]: 207 : &&
7621 : 207 : (guard = named_expression_rule(p)) // named_expression
7622 : : )
7623 : : {
7624 : : D(fprintf(stderr, "%*c+ guard[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression"));
7625 : 207 : _res = guard;
7626 [ - + - - ]: 207 : if (_res == NULL && PyErr_Occurred()) {
7627 : 0 : p->error_indicator = 1;
7628 : 0 : p->level--;
7629 : 0 : return NULL;
7630 : : }
7631 : 207 : goto done;
7632 : : }
7633 : 1596 : 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 : 1596 : _res = NULL;
7638 : 1803 : done:
7639 : 1803 : p->level--;
7640 : 1803 : return _res;
7641 : : }
7642 : :
7643 : : // patterns: open_sequence_pattern | pattern
7644 : : static pattern_ty
7645 : 1848 : patterns_rule(Parser *p)
7646 : : {
7647 [ - + ]: 1848 : if (p->level++ == MAXSTACK) {
7648 : 0 : p->error_indicator = 1;
7649 : : PyErr_NoMemory();
7650 : : }
7651 [ - + ]: 1848 : if (p->error_indicator) {
7652 : 0 : p->level--;
7653 : 0 : return NULL;
7654 : : }
7655 : 1848 : pattern_ty _res = NULL;
7656 : 1848 : int _mark = p->mark;
7657 [ + + - + ]: 1848 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7658 : 0 : p->error_indicator = 1;
7659 : 0 : p->level--;
7660 : 0 : return NULL;
7661 : : }
7662 : 1848 : int _start_lineno = p->tokens[_mark]->lineno;
7663 : : UNUSED(_start_lineno); // Only used by EXTRA macro
7664 : 1848 : int _start_col_offset = p->tokens[_mark]->col_offset;
7665 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
7666 : : { // open_sequence_pattern
7667 [ - + ]: 1848 : if (p->error_indicator) {
7668 : 0 : p->level--;
7669 : 0 : 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 [ + + ]: 1848 : if (
7674 : 1848 : (patterns = (asdl_pattern_seq*)open_sequence_pattern_rule(p)) // open_sequence_pattern
7675 : : )
7676 : : {
7677 : : D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "open_sequence_pattern"));
7678 : 74 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7679 [ - + ]: 74 : if (_token == NULL) {
7680 : 0 : p->level--;
7681 : 0 : return NULL;
7682 : : }
7683 : 74 : int _end_lineno = _token->end_lineno;
7684 : : UNUSED(_end_lineno); // Only used by EXTRA macro
7685 : 74 : int _end_col_offset = _token->end_col_offset;
7686 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
7687 : 74 : _res = _PyAST_MatchSequence ( patterns , EXTRA );
7688 [ - + - - ]: 74 : if (_res == NULL && PyErr_Occurred()) {
7689 : 0 : p->error_indicator = 1;
7690 : 0 : p->level--;
7691 : 0 : return NULL;
7692 : : }
7693 : 74 : goto done;
7694 : : }
7695 : 1774 : 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 [ + + ]: 1774 : if (p->error_indicator) {
7701 : 13 : p->level--;
7702 : 13 : 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 [ + + ]: 1761 : if (
7707 : 1761 : (pattern_var = pattern_rule(p)) // pattern
7708 : : )
7709 : : {
7710 : : D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern"));
7711 : 1729 : _res = pattern_var;
7712 : 1729 : goto done;
7713 : : }
7714 : 32 : 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 : 32 : _res = NULL;
7719 : 1835 : done:
7720 : 1835 : p->level--;
7721 : 1835 : return _res;
7722 : : }
7723 : :
7724 : : // pattern: as_pattern | or_pattern
7725 : : static pattern_ty
7726 : 6773 : pattern_rule(Parser *p)
7727 : : {
7728 [ - + ]: 6773 : if (p->level++ == MAXSTACK) {
7729 : 0 : p->error_indicator = 1;
7730 : : PyErr_NoMemory();
7731 : : }
7732 [ - + ]: 6773 : if (p->error_indicator) {
7733 : 0 : p->level--;
7734 : 0 : return NULL;
7735 : : }
7736 : 6773 : pattern_ty _res = NULL;
7737 : 6773 : int _mark = p->mark;
7738 : : { // as_pattern
7739 [ - + ]: 6773 : if (p->error_indicator) {
7740 : 0 : p->level--;
7741 : 0 : 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 [ + + ]: 6773 : if (
7746 : 6773 : (as_pattern_var = as_pattern_rule(p)) // as_pattern
7747 : : )
7748 : : {
7749 : : D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "as_pattern"));
7750 : 228 : _res = as_pattern_var;
7751 : 228 : goto done;
7752 : : }
7753 : 6545 : 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 [ + + ]: 6545 : if (p->error_indicator) {
7759 : 13 : p->level--;
7760 : 13 : 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 [ + + ]: 6532 : if (
7765 : 6532 : (or_pattern_var = or_pattern_rule(p)) // or_pattern
7766 : : )
7767 : : {
7768 : : D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern"));
7769 : 6159 : _res = or_pattern_var;
7770 : 6159 : goto done;
7771 : : }
7772 : 373 : 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 : 373 : _res = NULL;
7777 : 6760 : done:
7778 : 6760 : p->level--;
7779 : 6760 : return _res;
7780 : : }
7781 : :
7782 : : // as_pattern: or_pattern 'as' pattern_capture_target | invalid_as_pattern
7783 : : static pattern_ty
7784 : 6773 : as_pattern_rule(Parser *p)
7785 : : {
7786 [ - + ]: 6773 : if (p->level++ == MAXSTACK) {
7787 : 0 : p->error_indicator = 1;
7788 : : PyErr_NoMemory();
7789 : : }
7790 [ - + ]: 6773 : if (p->error_indicator) {
7791 : 0 : p->level--;
7792 : 0 : return NULL;
7793 : : }
7794 : 6773 : pattern_ty _res = NULL;
7795 : 6773 : int _mark = p->mark;
7796 [ + + - + ]: 6773 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7797 : 0 : p->error_indicator = 1;
7798 : 0 : p->level--;
7799 : 0 : return NULL;
7800 : : }
7801 : 6773 : int _start_lineno = p->tokens[_mark]->lineno;
7802 : : UNUSED(_start_lineno); // Only used by EXTRA macro
7803 : 6773 : 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 [ - + ]: 6773 : if (p->error_indicator) {
7807 : 0 : p->level--;
7808 : 0 : 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 [ + + ]: 6773 : if (
7815 : 6773 : (pattern = or_pattern_rule(p)) // or_pattern
7816 [ + + ]: 6390 : &&
7817 : 6390 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
7818 [ + + ]: 237 : &&
7819 : 237 : (target = pattern_capture_target_rule(p)) // pattern_capture_target
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 : 228 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7824 [ - + ]: 228 : if (_token == NULL) {
7825 : 0 : p->level--;
7826 : 0 : return NULL;
7827 : : }
7828 : 228 : int _end_lineno = _token->end_lineno;
7829 : : UNUSED(_end_lineno); // Only used by EXTRA macro
7830 : 228 : int _end_col_offset = _token->end_col_offset;
7831 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
7832 : 228 : _res = _PyAST_MatchAs ( pattern , target -> v . Name . id , EXTRA );
7833 [ - + - - ]: 228 : if (_res == NULL && PyErr_Occurred()) {
7834 : 0 : p->error_indicator = 1;
7835 : 0 : p->level--;
7836 : 0 : return NULL;
7837 : : }
7838 : 228 : goto done;
7839 : : }
7840 : 6545 : 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 [ + + ]: 6545 : if (p->call_invalid_rules) { // invalid_as_pattern
7845 [ + + ]: 111 : if (p->error_indicator) {
7846 : 4 : p->level--;
7847 : 4 : 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 [ - + ]: 107 : if (
7852 : 107 : (invalid_as_pattern_var = invalid_as_pattern_rule(p)) // invalid_as_pattern
7853 : : )
7854 : : {
7855 : : D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_as_pattern"));
7856 : 0 : _res = invalid_as_pattern_var;
7857 : 0 : goto done;
7858 : : }
7859 : 107 : 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 : 6541 : _res = NULL;
7864 : 6769 : done:
7865 : 6769 : p->level--;
7866 : 6769 : return _res;
7867 : : }
7868 : :
7869 : : // or_pattern: '|'.closed_pattern+
7870 : : static pattern_ty
7871 : 13517 : or_pattern_rule(Parser *p)
7872 : : {
7873 [ - + ]: 13517 : if (p->level++ == MAXSTACK) {
7874 : 0 : p->error_indicator = 1;
7875 : : PyErr_NoMemory();
7876 : : }
7877 [ - + ]: 13517 : if (p->error_indicator) {
7878 : 0 : p->level--;
7879 : 0 : return NULL;
7880 : : }
7881 : 13517 : pattern_ty _res = NULL;
7882 : 13517 : int _mark = p->mark;
7883 [ - + - - ]: 13517 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7884 : 0 : p->error_indicator = 1;
7885 : 0 : p->level--;
7886 : 0 : return NULL;
7887 : : }
7888 : 13517 : int _start_lineno = p->tokens[_mark]->lineno;
7889 : : UNUSED(_start_lineno); // Only used by EXTRA macro
7890 : 13517 : int _start_col_offset = p->tokens[_mark]->col_offset;
7891 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
7892 : : { // '|'.closed_pattern+
7893 [ - + ]: 13517 : if (p->error_indicator) {
7894 : 0 : p->level--;
7895 : 0 : 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 [ + + ]: 13517 : if (
7900 : 13517 : (patterns = (asdl_pattern_seq*)_gather_65_rule(p)) // '|'.closed_pattern+
7901 : : )
7902 : : {
7903 : : D(fprintf(stderr, "%*c+ or_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+"));
7904 : 12645 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7905 [ - + ]: 12645 : if (_token == NULL) {
7906 : 0 : p->level--;
7907 : 0 : return NULL;
7908 : : }
7909 : 12645 : int _end_lineno = _token->end_lineno;
7910 : : UNUSED(_end_lineno); // Only used by EXTRA macro
7911 : 12645 : int _end_col_offset = _token->end_col_offset;
7912 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
7913 [ + - + + ]: 12645 : _res = asdl_seq_LEN ( patterns ) == 1 ? asdl_seq_GET ( patterns , 0 ) : _PyAST_MatchOr ( patterns , EXTRA );
7914 [ - + - - ]: 12645 : if (_res == NULL && PyErr_Occurred()) {
7915 : 0 : p->error_indicator = 1;
7916 : 0 : p->level--;
7917 : 0 : return NULL;
7918 : : }
7919 : 12645 : goto done;
7920 : : }
7921 : 872 : 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 : 872 : _res = NULL;
7926 : 13517 : done:
7927 : 13517 : p->level--;
7928 : 13517 : 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 : 14745 : closed_pattern_rule(Parser *p)
7942 : : {
7943 [ - + ]: 14745 : if (p->level++ == MAXSTACK) {
7944 : 0 : p->error_indicator = 1;
7945 : : PyErr_NoMemory();
7946 : : }
7947 [ - + ]: 14745 : if (p->error_indicator) {
7948 : 0 : p->level--;
7949 : 0 : return NULL;
7950 : : }
7951 : 14745 : pattern_ty _res = NULL;
7952 [ + + ]: 14745 : if (_PyPegen_is_memoized(p, closed_pattern_type, &_res)) {
7953 : 9946 : p->level--;
7954 : 9946 : return _res;
7955 : : }
7956 : 4799 : int _mark = p->mark;
7957 : : { // literal_pattern
7958 [ - + ]: 4799 : if (p->error_indicator) {
7959 : 0 : p->level--;
7960 : 0 : 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 [ + + ]: 4799 : if (
7965 : 4799 : (literal_pattern_var = literal_pattern_rule(p)) // literal_pattern
7966 : : )
7967 : : {
7968 : : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_pattern"));
7969 : 1552 : _res = literal_pattern_var;
7970 : 1552 : goto done;
7971 : : }
7972 : 3247 : 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 [ + + ]: 3247 : if (p->error_indicator) {
7978 : 3 : p->level--;
7979 : 3 : 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 [ + + ]: 3244 : if (
7984 : 3244 : (capture_pattern_var = capture_pattern_rule(p)) // capture_pattern
7985 : : )
7986 : : {
7987 : : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "capture_pattern"));
7988 : 996 : _res = capture_pattern_var;
7989 : 996 : goto done;
7990 : : }
7991 : 2248 : 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 [ - + ]: 2248 : if (p->error_indicator) {
7997 : 0 : p->level--;
7998 : 0 : 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 [ + + ]: 2248 : if (
8003 : 2248 : (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern
8004 : : )
8005 : : {
8006 : : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "wildcard_pattern"));
8007 : 250 : _res = wildcard_pattern_var;
8008 : 250 : goto done;
8009 : : }
8010 : 1998 : 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 [ - + ]: 1998 : if (p->error_indicator) {
8016 : 0 : p->level--;
8017 : 0 : 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 [ + + ]: 1998 : if (
8022 : 1998 : (value_pattern_var = value_pattern_rule(p)) // value_pattern
8023 : : )
8024 : : {
8025 : : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "value_pattern"));
8026 : 60 : _res = value_pattern_var;
8027 : 60 : goto done;
8028 : : }
8029 : 1938 : 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 [ - + ]: 1938 : if (p->error_indicator) {
8035 : 0 : p->level--;
8036 : 0 : 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 [ + + ]: 1938 : if (
8041 : 1938 : (group_pattern_var = group_pattern_rule(p)) // group_pattern
8042 : : )
8043 : : {
8044 : : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group_pattern"));
8045 : 257 : _res = group_pattern_var;
8046 : 257 : goto done;
8047 : : }
8048 : 1681 : 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 [ - + ]: 1681 : if (p->error_indicator) {
8054 : 0 : p->level--;
8055 : 0 : 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 [ + + ]: 1681 : if (
8060 : 1681 : (sequence_pattern_var = sequence_pattern_rule(p)) // sequence_pattern
8061 : : )
8062 : : {
8063 : : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sequence_pattern"));
8064 : 689 : _res = sequence_pattern_var;
8065 : 689 : goto done;
8066 : : }
8067 : 992 : 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 [ - + ]: 992 : if (p->error_indicator) {
8073 : 0 : p->level--;
8074 : 0 : 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 [ + + ]: 992 : if (
8079 : 992 : (mapping_pattern_var = mapping_pattern_rule(p)) // mapping_pattern
8080 : : )
8081 : : {
8082 : : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "mapping_pattern"));
8083 : 429 : _res = mapping_pattern_var;
8084 : 429 : goto done;
8085 : : }
8086 : 563 : 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 [ + + ]: 563 : if (p->error_indicator) {
8092 : 3 : p->level--;
8093 : 3 : 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 [ + + ]: 560 : if (
8098 : 560 : (class_pattern_var = class_pattern_rule(p)) // class_pattern
8099 : : )
8100 : : {
8101 : : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_pattern"));
8102 : 292 : _res = class_pattern_var;
8103 : 292 : goto done;
8104 : : }
8105 : 268 : 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 : 268 : _res = NULL;
8110 : 4793 : done:
8111 : 4793 : _PyPegen_insert_memo(p, _mark, closed_pattern_type, _res);
8112 : 4793 : p->level--;
8113 : 4793 : 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 : 4799 : literal_pattern_rule(Parser *p)
8125 : : {
8126 [ - + ]: 4799 : if (p->level++ == MAXSTACK) {
8127 : 0 : p->error_indicator = 1;
8128 : : PyErr_NoMemory();
8129 : : }
8130 [ - + ]: 4799 : if (p->error_indicator) {
8131 : 0 : p->level--;
8132 : 0 : return NULL;
8133 : : }
8134 : 4799 : pattern_ty _res = NULL;
8135 : 4799 : int _mark = p->mark;
8136 [ - + - - ]: 4799 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8137 : 0 : p->error_indicator = 1;
8138 : 0 : p->level--;
8139 : 0 : return NULL;
8140 : : }
8141 : 4799 : int _start_lineno = p->tokens[_mark]->lineno;
8142 : : UNUSED(_start_lineno); // Only used by EXTRA macro
8143 : 4799 : int _start_col_offset = p->tokens[_mark]->col_offset;
8144 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
8145 : : { // signed_number !('+' | '-')
8146 [ - + ]: 4799 : if (p->error_indicator) {
8147 : 0 : p->level--;
8148 : 0 : 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 [ + + ]: 4799 : if (
8153 : 4799 : (value = signed_number_rule(p)) // signed_number
8154 [ + + ]: 1353 : &&
8155 : 1353 : _PyPegen_lookahead(0, _tmp_67_rule, p)
8156 : : )
8157 : : {
8158 : : D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')"));
8159 : 1310 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8160 [ - + ]: 1310 : if (_token == NULL) {
8161 : 0 : p->level--;
8162 : 0 : return NULL;
8163 : : }
8164 : 1310 : int _end_lineno = _token->end_lineno;
8165 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8166 : 1310 : int _end_col_offset = _token->end_col_offset;
8167 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8168 : 1310 : _res = _PyAST_MatchValue ( value , EXTRA );
8169 [ - + - - ]: 1310 : if (_res == NULL && PyErr_Occurred()) {
8170 : 0 : p->error_indicator = 1;
8171 : 0 : p->level--;
8172 : 0 : return NULL;
8173 : : }
8174 : 1310 : goto done;
8175 : : }
8176 : 3489 : 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 [ - + ]: 3489 : if (p->error_indicator) {
8182 : 0 : p->level--;
8183 : 0 : 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 [ + + ]: 3489 : if (
8188 : 3489 : (value = complex_number_rule(p)) // complex_number
8189 : : )
8190 : : {
8191 : : D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "complex_number"));
8192 : 40 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8193 [ - + ]: 40 : if (_token == NULL) {
8194 : 0 : p->level--;
8195 : 0 : return NULL;
8196 : : }
8197 : 40 : int _end_lineno = _token->end_lineno;
8198 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8199 : 40 : int _end_col_offset = _token->end_col_offset;
8200 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8201 : 40 : _res = _PyAST_MatchValue ( value , EXTRA );
8202 [ - + - - ]: 40 : if (_res == NULL && PyErr_Occurred()) {
8203 : 0 : p->error_indicator = 1;
8204 : 0 : p->level--;
8205 : 0 : return NULL;
8206 : : }
8207 : 40 : goto done;
8208 : : }
8209 : 3449 : 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 [ + + ]: 3449 : if (p->error_indicator) {
8215 : 3 : p->level--;
8216 : 3 : 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 [ + + ]: 3446 : if (
8221 : 3446 : (value = strings_rule(p)) // strings
8222 : : )
8223 : : {
8224 : : D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings"));
8225 : 140 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8226 [ - + ]: 140 : if (_token == NULL) {
8227 : 0 : p->level--;
8228 : 0 : return NULL;
8229 : : }
8230 : 140 : int _end_lineno = _token->end_lineno;
8231 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8232 : 140 : int _end_col_offset = _token->end_col_offset;
8233 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8234 : 140 : _res = _PyAST_MatchValue ( value , EXTRA );
8235 [ - + - - ]: 140 : if (_res == NULL && PyErr_Occurred()) {
8236 : 0 : p->error_indicator = 1;
8237 : 0 : p->level--;
8238 : 0 : return NULL;
8239 : : }
8240 : 140 : goto done;
8241 : : }
8242 : 3306 : 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 [ - + ]: 3306 : if (p->error_indicator) {
8248 : 0 : p->level--;
8249 : 0 : return NULL;
8250 : : }
8251 : : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
8252 : : Token * _keyword;
8253 [ + + ]: 3306 : if (
8254 : 3306 : (_keyword = _PyPegen_expect_token(p, 601)) // token='None'
8255 : : )
8256 : : {
8257 : : D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
8258 : 32 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8259 [ - + ]: 32 : if (_token == NULL) {
8260 : 0 : p->level--;
8261 : 0 : return NULL;
8262 : : }
8263 : 32 : int _end_lineno = _token->end_lineno;
8264 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8265 : 32 : int _end_col_offset = _token->end_col_offset;
8266 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8267 : 32 : _res = _PyAST_MatchSingleton ( Py_None , EXTRA );
8268 [ - + - - ]: 32 : if (_res == NULL && PyErr_Occurred()) {
8269 : 0 : p->error_indicator = 1;
8270 : 0 : p->level--;
8271 : 0 : return NULL;
8272 : : }
8273 : 32 : goto done;
8274 : : }
8275 : 3274 : 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 [ - + ]: 3274 : if (p->error_indicator) {
8281 : 0 : p->level--;
8282 : 0 : return NULL;
8283 : : }
8284 : : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
8285 : : Token * _keyword;
8286 [ + + ]: 3274 : if (
8287 : 3274 : (_keyword = _PyPegen_expect_token(p, 600)) // token='True'
8288 : : )
8289 : : {
8290 : : D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
8291 : 13 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8292 [ - + ]: 13 : if (_token == NULL) {
8293 : 0 : p->level--;
8294 : 0 : return NULL;
8295 : : }
8296 : 13 : int _end_lineno = _token->end_lineno;
8297 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8298 : 13 : int _end_col_offset = _token->end_col_offset;
8299 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8300 : 13 : _res = _PyAST_MatchSingleton ( Py_True , EXTRA );
8301 [ - + - - ]: 13 : if (_res == NULL && PyErr_Occurred()) {
8302 : 0 : p->error_indicator = 1;
8303 : 0 : p->level--;
8304 : 0 : return NULL;
8305 : : }
8306 : 13 : goto done;
8307 : : }
8308 : 3261 : 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 [ - + ]: 3261 : if (p->error_indicator) {
8314 : 0 : p->level--;
8315 : 0 : return NULL;
8316 : : }
8317 : : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
8318 : : Token * _keyword;
8319 [ + + ]: 3261 : if (
8320 : 3261 : (_keyword = _PyPegen_expect_token(p, 602)) // token='False'
8321 : : )
8322 : : {
8323 : : D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
8324 : 17 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8325 [ - + ]: 17 : if (_token == NULL) {
8326 : 0 : p->level--;
8327 : 0 : return NULL;
8328 : : }
8329 : 17 : int _end_lineno = _token->end_lineno;
8330 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8331 : 17 : int _end_col_offset = _token->end_col_offset;
8332 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8333 : 17 : _res = _PyAST_MatchSingleton ( Py_False , EXTRA );
8334 [ - + - - ]: 17 : if (_res == NULL && PyErr_Occurred()) {
8335 : 0 : p->error_indicator = 1;
8336 : 0 : p->level--;
8337 : 0 : return NULL;
8338 : : }
8339 : 17 : goto done;
8340 : : }
8341 : 3244 : 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 : 3244 : _res = NULL;
8346 : 4796 : done:
8347 : 4796 : p->level--;
8348 : 4796 : 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 : 809 : literal_expr_rule(Parser *p)
8360 : : {
8361 [ - + ]: 809 : if (p->level++ == MAXSTACK) {
8362 : 0 : p->error_indicator = 1;
8363 : : PyErr_NoMemory();
8364 : : }
8365 [ - + ]: 809 : if (p->error_indicator) {
8366 : 0 : p->level--;
8367 : 0 : return NULL;
8368 : : }
8369 : 809 : expr_ty _res = NULL;
8370 : 809 : int _mark = p->mark;
8371 [ + + - + ]: 809 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8372 : 0 : p->error_indicator = 1;
8373 : 0 : p->level--;
8374 : 0 : return NULL;
8375 : : }
8376 : 809 : int _start_lineno = p->tokens[_mark]->lineno;
8377 : : UNUSED(_start_lineno); // Only used by EXTRA macro
8378 : 809 : int _start_col_offset = p->tokens[_mark]->col_offset;
8379 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
8380 : : { // signed_number !('+' | '-')
8381 [ - + ]: 809 : if (p->error_indicator) {
8382 : 0 : p->level--;
8383 : 0 : 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 [ + + ]: 809 : if (
8388 : 809 : (signed_number_var = signed_number_rule(p)) // signed_number
8389 [ + + ]: 581 : &&
8390 : 581 : _PyPegen_lookahead(0, _tmp_68_rule, p)
8391 : : )
8392 : : {
8393 : : D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')"));
8394 : 570 : _res = signed_number_var;
8395 : 570 : goto done;
8396 : : }
8397 : 239 : 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 [ - + ]: 239 : if (p->error_indicator) {
8403 : 0 : p->level--;
8404 : 0 : 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 [ + + ]: 239 : if (
8409 : 239 : (complex_number_var = complex_number_rule(p)) // complex_number
8410 : : )
8411 : : {
8412 : : D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "complex_number"));
8413 : 8 : _res = complex_number_var;
8414 : 8 : goto done;
8415 : : }
8416 : 231 : 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 [ + + ]: 231 : if (p->error_indicator) {
8422 : 3 : p->level--;
8423 : 3 : 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 [ + + ]: 228 : if (
8428 : 228 : (strings_var = strings_rule(p)) // strings
8429 : : )
8430 : : {
8431 : : D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings"));
8432 : 174 : _res = strings_var;
8433 : 174 : goto done;
8434 : : }
8435 : 54 : 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 [ - + ]: 54 : if (p->error_indicator) {
8441 : 0 : p->level--;
8442 : 0 : return NULL;
8443 : : }
8444 : : D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
8445 : : Token * _keyword;
8446 [ - + ]: 54 : if (
8447 : 54 : (_keyword = _PyPegen_expect_token(p, 601)) // token='None'
8448 : : )
8449 : : {
8450 : : D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
8451 : 0 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8452 [ # # ]: 0 : if (_token == NULL) {
8453 : 0 : p->level--;
8454 : 0 : return NULL;
8455 : : }
8456 : 0 : int _end_lineno = _token->end_lineno;
8457 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8458 : 0 : int _end_col_offset = _token->end_col_offset;
8459 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8460 : 0 : _res = _PyAST_Constant ( Py_None , NULL , EXTRA );
8461 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
8462 : 0 : p->error_indicator = 1;
8463 : 0 : p->level--;
8464 : 0 : return NULL;
8465 : : }
8466 : 0 : goto done;
8467 : : }
8468 : 54 : 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 [ - + ]: 54 : if (p->error_indicator) {
8474 : 0 : p->level--;
8475 : 0 : return NULL;
8476 : : }
8477 : : D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
8478 : : Token * _keyword;
8479 [ - + ]: 54 : if (
8480 : 54 : (_keyword = _PyPegen_expect_token(p, 600)) // token='True'
8481 : : )
8482 : : {
8483 : : D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
8484 : 0 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8485 [ # # ]: 0 : if (_token == NULL) {
8486 : 0 : p->level--;
8487 : 0 : return NULL;
8488 : : }
8489 : 0 : int _end_lineno = _token->end_lineno;
8490 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8491 : 0 : int _end_col_offset = _token->end_col_offset;
8492 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8493 : 0 : _res = _PyAST_Constant ( Py_True , NULL , EXTRA );
8494 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
8495 : 0 : p->error_indicator = 1;
8496 : 0 : p->level--;
8497 : 0 : return NULL;
8498 : : }
8499 : 0 : goto done;
8500 : : }
8501 : 54 : 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 [ - + ]: 54 : if (p->error_indicator) {
8507 : 0 : p->level--;
8508 : 0 : return NULL;
8509 : : }
8510 : : D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
8511 : : Token * _keyword;
8512 [ + + ]: 54 : if (
8513 : 54 : (_keyword = _PyPegen_expect_token(p, 602)) // token='False'
8514 : : )
8515 : : {
8516 : : D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
8517 : 2 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8518 [ - + ]: 2 : if (_token == NULL) {
8519 : 0 : p->level--;
8520 : 0 : return NULL;
8521 : : }
8522 : 2 : int _end_lineno = _token->end_lineno;
8523 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8524 : 2 : int _end_col_offset = _token->end_col_offset;
8525 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8526 : 2 : _res = _PyAST_Constant ( Py_False , NULL , EXTRA );
8527 [ - + - - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
8528 : 0 : p->error_indicator = 1;
8529 : 0 : p->level--;
8530 : 0 : return NULL;
8531 : : }
8532 : 2 : goto done;
8533 : : }
8534 : 52 : 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 : 52 : _res = NULL;
8539 : 806 : done:
8540 : 806 : p->level--;
8541 : 806 : return _res;
8542 : : }
8543 : :
8544 : : // complex_number:
8545 : : // | signed_real_number '+' imaginary_number
8546 : : // | signed_real_number '-' imaginary_number
8547 : : static expr_ty
8548 : 3728 : complex_number_rule(Parser *p)
8549 : : {
8550 [ - + ]: 3728 : if (p->level++ == MAXSTACK) {
8551 : 0 : p->error_indicator = 1;
8552 : : PyErr_NoMemory();
8553 : : }
8554 [ - + ]: 3728 : if (p->error_indicator) {
8555 : 0 : p->level--;
8556 : 0 : return NULL;
8557 : : }
8558 : 3728 : expr_ty _res = NULL;
8559 : 3728 : int _mark = p->mark;
8560 [ - + - - ]: 3728 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8561 : 0 : p->error_indicator = 1;
8562 : 0 : p->level--;
8563 : 0 : return NULL;
8564 : : }
8565 : 3728 : int _start_lineno = p->tokens[_mark]->lineno;
8566 : : UNUSED(_start_lineno); // Only used by EXTRA macro
8567 : 3728 : 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 [ - + ]: 3728 : if (p->error_indicator) {
8571 : 0 : p->level--;
8572 : 0 : 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 [ + + ]: 3728 : if (
8579 : 3728 : (real = signed_real_number_rule(p)) // signed_real_number
8580 [ + + ]: 50 : &&
8581 : 50 : (_literal = _PyPegen_expect_token(p, 14)) // token='+'
8582 [ + + ]: 22 : &&
8583 : 22 : (imag = imaginary_number_rule(p)) // imaginary_number
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 : 20 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8588 [ - + ]: 20 : if (_token == NULL) {
8589 : 0 : p->level--;
8590 : 0 : return NULL;
8591 : : }
8592 : 20 : int _end_lineno = _token->end_lineno;
8593 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8594 : 20 : int _end_col_offset = _token->end_col_offset;
8595 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8596 : 20 : _res = _PyAST_BinOp ( real , Add , imag , EXTRA );
8597 [ - + - - ]: 20 : if (_res == NULL && PyErr_Occurred()) {
8598 : 0 : p->error_indicator = 1;
8599 : 0 : p->level--;
8600 : 0 : return NULL;
8601 : : }
8602 : 20 : goto done;
8603 : : }
8604 : 3708 : 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 [ + + ]: 3708 : if (p->error_indicator) {
8610 : 6 : p->level--;
8611 : 6 : 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 [ + + ]: 3702 : if (
8618 : 3702 : (real = signed_real_number_rule(p)) // signed_real_number
8619 [ + - ]: 28 : &&
8620 : 28 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
8621 [ + - ]: 28 : &&
8622 : 28 : (imag = imaginary_number_rule(p)) // imaginary_number
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 : 28 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8627 [ - + ]: 28 : if (_token == NULL) {
8628 : 0 : p->level--;
8629 : 0 : return NULL;
8630 : : }
8631 : 28 : int _end_lineno = _token->end_lineno;
8632 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8633 : 28 : int _end_col_offset = _token->end_col_offset;
8634 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8635 : 28 : _res = _PyAST_BinOp ( real , Sub , imag , EXTRA );
8636 [ - + - - ]: 28 : if (_res == NULL && PyErr_Occurred()) {
8637 : 0 : p->error_indicator = 1;
8638 : 0 : p->level--;
8639 : 0 : return NULL;
8640 : : }
8641 : 28 : goto done;
8642 : : }
8643 : 3674 : 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 : 3674 : _res = NULL;
8648 : 3722 : done:
8649 : 3722 : p->level--;
8650 : 3722 : return _res;
8651 : : }
8652 : :
8653 : : // signed_number: NUMBER | '-' NUMBER
8654 : : static expr_ty
8655 : 5608 : signed_number_rule(Parser *p)
8656 : : {
8657 [ - + ]: 5608 : if (p->level++ == MAXSTACK) {
8658 : 0 : p->error_indicator = 1;
8659 : : PyErr_NoMemory();
8660 : : }
8661 [ - + ]: 5608 : if (p->error_indicator) {
8662 : 0 : p->level--;
8663 : 0 : return NULL;
8664 : : }
8665 : 5608 : expr_ty _res = NULL;
8666 : 5608 : int _mark = p->mark;
8667 [ - + - - ]: 5608 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8668 : 0 : p->error_indicator = 1;
8669 : 0 : p->level--;
8670 : 0 : return NULL;
8671 : : }
8672 : 5608 : int _start_lineno = p->tokens[_mark]->lineno;
8673 : : UNUSED(_start_lineno); // Only used by EXTRA macro
8674 : 5608 : int _start_col_offset = p->tokens[_mark]->col_offset;
8675 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
8676 : : { // NUMBER
8677 [ - + ]: 5608 : if (p->error_indicator) {
8678 : 0 : p->level--;
8679 : 0 : 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 [ + + ]: 5608 : if (
8684 : 5608 : (number_var = _PyPegen_number_token(p)) // NUMBER
8685 : : )
8686 : : {
8687 : : D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8688 : 1856 : _res = number_var;
8689 : 1856 : goto done;
8690 : : }
8691 : 3752 : 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 [ - + ]: 3752 : if (p->error_indicator) {
8697 : 0 : p->level--;
8698 : 0 : 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 [ + + ]: 3752 : if (
8704 : 3752 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
8705 [ + - ]: 78 : &&
8706 : 78 : (number = _PyPegen_number_token(p)) // NUMBER
8707 : : )
8708 : : {
8709 : : D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' NUMBER"));
8710 : 78 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8711 [ - + ]: 78 : if (_token == NULL) {
8712 : 0 : p->level--;
8713 : 0 : return NULL;
8714 : : }
8715 : 78 : int _end_lineno = _token->end_lineno;
8716 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8717 : 78 : int _end_col_offset = _token->end_col_offset;
8718 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8719 : 78 : _res = _PyAST_UnaryOp ( USub , number , EXTRA );
8720 [ - + - - ]: 78 : if (_res == NULL && PyErr_Occurred()) {
8721 : 0 : p->error_indicator = 1;
8722 : 0 : p->level--;
8723 : 0 : return NULL;
8724 : : }
8725 : 78 : goto done;
8726 : : }
8727 : 3674 : 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 : 3674 : _res = NULL;
8732 : 5608 : done:
8733 : 5608 : p->level--;
8734 : 5608 : return _res;
8735 : : }
8736 : :
8737 : : // signed_real_number: real_number | '-' real_number
8738 : : static expr_ty
8739 : 7430 : signed_real_number_rule(Parser *p)
8740 : : {
8741 [ - + ]: 7430 : if (p->level++ == MAXSTACK) {
8742 : 0 : p->error_indicator = 1;
8743 : : PyErr_NoMemory();
8744 : : }
8745 [ - + ]: 7430 : if (p->error_indicator) {
8746 : 0 : p->level--;
8747 : 0 : return NULL;
8748 : : }
8749 : 7430 : expr_ty _res = NULL;
8750 : 7430 : int _mark = p->mark;
8751 [ - + - - ]: 7430 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8752 : 0 : p->error_indicator = 1;
8753 : 0 : p->level--;
8754 : 0 : return NULL;
8755 : : }
8756 : 7430 : int _start_lineno = p->tokens[_mark]->lineno;
8757 : : UNUSED(_start_lineno); // Only used by EXTRA macro
8758 : 7430 : int _start_col_offset = p->tokens[_mark]->col_offset;
8759 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
8760 : : { // real_number
8761 [ - + ]: 7430 : if (p->error_indicator) {
8762 : 0 : p->level--;
8763 : 0 : 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 [ + + ]: 7430 : if (
8768 : 7430 : (real_number_var = real_number_rule(p)) // real_number
8769 : : )
8770 : : {
8771 : : D(fprintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "real_number"));
8772 : 38 : _res = real_number_var;
8773 : 38 : goto done;
8774 : : }
8775 : 7392 : 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 [ + + ]: 7392 : if (p->error_indicator) {
8781 : 4 : p->level--;
8782 : 4 : 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 [ + + ]: 7388 : if (
8788 : 7388 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
8789 [ + - ]: 40 : &&
8790 : 40 : (real = real_number_rule(p)) // real_number
8791 : : )
8792 : : {
8793 : : D(fprintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' real_number"));
8794 : 40 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8795 [ - + ]: 40 : if (_token == NULL) {
8796 : 0 : p->level--;
8797 : 0 : return NULL;
8798 : : }
8799 : 40 : int _end_lineno = _token->end_lineno;
8800 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8801 : 40 : int _end_col_offset = _token->end_col_offset;
8802 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8803 : 40 : _res = _PyAST_UnaryOp ( USub , real , EXTRA );
8804 [ - + - - ]: 40 : if (_res == NULL && PyErr_Occurred()) {
8805 : 0 : p->error_indicator = 1;
8806 : 0 : p->level--;
8807 : 0 : return NULL;
8808 : : }
8809 : 40 : goto done;
8810 : : }
8811 : 7348 : 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 : 7348 : _res = NULL;
8816 : 7426 : done:
8817 : 7426 : p->level--;
8818 : 7426 : return _res;
8819 : : }
8820 : :
8821 : : // real_number: NUMBER
8822 : : static expr_ty
8823 : 7470 : real_number_rule(Parser *p)
8824 : : {
8825 [ - + ]: 7470 : if (p->level++ == MAXSTACK) {
8826 : 0 : p->error_indicator = 1;
8827 : : PyErr_NoMemory();
8828 : : }
8829 [ - + ]: 7470 : if (p->error_indicator) {
8830 : 0 : p->level--;
8831 : 0 : return NULL;
8832 : : }
8833 : 7470 : expr_ty _res = NULL;
8834 : 7470 : int _mark = p->mark;
8835 : : { // NUMBER
8836 [ - + ]: 7470 : if (p->error_indicator) {
8837 : 0 : p->level--;
8838 : 0 : 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 [ + + ]: 7470 : if (
8843 : 7470 : (real = _PyPegen_number_token(p)) // NUMBER
8844 : : )
8845 : : {
8846 : : D(fprintf(stderr, "%*c+ real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8847 : 82 : _res = _PyPegen_ensure_real ( p , real );
8848 [ + + + - ]: 82 : if (_res == NULL && PyErr_Occurred()) {
8849 : 4 : p->error_indicator = 1;
8850 : 4 : p->level--;
8851 : 4 : return NULL;
8852 : : }
8853 : 78 : goto done;
8854 : : }
8855 : 7388 : 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 : 7388 : _res = NULL;
8860 : 7466 : done:
8861 : 7466 : p->level--;
8862 : 7466 : return _res;
8863 : : }
8864 : :
8865 : : // imaginary_number: NUMBER
8866 : : static expr_ty
8867 : 50 : imaginary_number_rule(Parser *p)
8868 : : {
8869 [ - + ]: 50 : if (p->level++ == MAXSTACK) {
8870 : 0 : p->error_indicator = 1;
8871 : : PyErr_NoMemory();
8872 : : }
8873 [ - + ]: 50 : if (p->error_indicator) {
8874 : 0 : p->level--;
8875 : 0 : return NULL;
8876 : : }
8877 : 50 : expr_ty _res = NULL;
8878 : 50 : int _mark = p->mark;
8879 : : { // NUMBER
8880 [ - + ]: 50 : if (p->error_indicator) {
8881 : 0 : p->level--;
8882 : 0 : 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 [ + - ]: 50 : if (
8887 : 50 : (imag = _PyPegen_number_token(p)) // NUMBER
8888 : : )
8889 : : {
8890 : : D(fprintf(stderr, "%*c+ imaginary_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8891 : 50 : _res = _PyPegen_ensure_imaginary ( p , imag );
8892 [ + + + - ]: 50 : if (_res == NULL && PyErr_Occurred()) {
8893 : 2 : p->error_indicator = 1;
8894 : 2 : p->level--;
8895 : 2 : return NULL;
8896 : : }
8897 : 48 : goto done;
8898 : : }
8899 : 0 : 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 : 0 : _res = NULL;
8904 : 48 : done:
8905 : 48 : p->level--;
8906 : 48 : return _res;
8907 : : }
8908 : :
8909 : : // capture_pattern: pattern_capture_target
8910 : : static pattern_ty
8911 : 3244 : capture_pattern_rule(Parser *p)
8912 : : {
8913 [ - + ]: 3244 : if (p->level++ == MAXSTACK) {
8914 : 0 : p->error_indicator = 1;
8915 : : PyErr_NoMemory();
8916 : : }
8917 [ - + ]: 3244 : if (p->error_indicator) {
8918 : 0 : p->level--;
8919 : 0 : return NULL;
8920 : : }
8921 : 3244 : pattern_ty _res = NULL;
8922 : 3244 : int _mark = p->mark;
8923 [ - + - - ]: 3244 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8924 : 0 : p->error_indicator = 1;
8925 : 0 : p->level--;
8926 : 0 : return NULL;
8927 : : }
8928 : 3244 : int _start_lineno = p->tokens[_mark]->lineno;
8929 : : UNUSED(_start_lineno); // Only used by EXTRA macro
8930 : 3244 : int _start_col_offset = p->tokens[_mark]->col_offset;
8931 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
8932 : : { // pattern_capture_target
8933 [ - + ]: 3244 : if (p->error_indicator) {
8934 : 0 : p->level--;
8935 : 0 : 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 [ + + ]: 3244 : if (
8940 : 3244 : (target = pattern_capture_target_rule(p)) // pattern_capture_target
8941 : : )
8942 : : {
8943 : : D(fprintf(stderr, "%*c+ capture_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern_capture_target"));
8944 : 996 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8945 [ - + ]: 996 : if (_token == NULL) {
8946 : 0 : p->level--;
8947 : 0 : return NULL;
8948 : : }
8949 : 996 : int _end_lineno = _token->end_lineno;
8950 : : UNUSED(_end_lineno); // Only used by EXTRA macro
8951 : 996 : int _end_col_offset = _token->end_col_offset;
8952 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
8953 : 996 : _res = _PyAST_MatchAs ( NULL , target -> v . Name . id , EXTRA );
8954 [ - + - - ]: 996 : if (_res == NULL && PyErr_Occurred()) {
8955 : 0 : p->error_indicator = 1;
8956 : 0 : p->level--;
8957 : 0 : return NULL;
8958 : : }
8959 : 996 : goto done;
8960 : : }
8961 : 2248 : 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 : 2248 : _res = NULL;
8966 : 3244 : done:
8967 : 3244 : p->level--;
8968 : 3244 : return _res;
8969 : : }
8970 : :
8971 : : // pattern_capture_target: !"_" NAME !('.' | '(' | '=')
8972 : : static expr_ty
8973 : 3700 : pattern_capture_target_rule(Parser *p)
8974 : : {
8975 [ - + ]: 3700 : if (p->level++ == MAXSTACK) {
8976 : 0 : p->error_indicator = 1;
8977 : : PyErr_NoMemory();
8978 : : }
8979 [ - + ]: 3700 : if (p->error_indicator) {
8980 : 0 : p->level--;
8981 : 0 : return NULL;
8982 : : }
8983 : 3700 : expr_ty _res = NULL;
8984 : 3700 : int _mark = p->mark;
8985 : : { // !"_" NAME !('.' | '(' | '=')
8986 [ - + ]: 3700 : if (p->error_indicator) {
8987 : 0 : p->level--;
8988 : 0 : 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 [ + + ]: 3700 : if (
8993 : 3700 : _PyPegen_lookahead_with_string(0, _PyPegen_expect_soft_keyword, p, "_")
8994 [ + + ]: 3384 : &&
8995 : 3384 : (name = _PyPegen_name_token(p)) // NAME
8996 [ + + ]: 1820 : &&
8997 : 1820 : _PyPegen_lookahead(0, _tmp_69_rule, p)
8998 : : )
8999 : : {
9000 : : D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')"));
9001 : 1383 : _res = _PyPegen_set_expr_context ( p , name , Store );
9002 [ - + - - ]: 1383 : if (_res == NULL && PyErr_Occurred()) {
9003 : 0 : p->error_indicator = 1;
9004 : 0 : p->level--;
9005 : 0 : return NULL;
9006 : : }
9007 : 1383 : goto done;
9008 : : }
9009 : 2317 : 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 : 2317 : _res = NULL;
9014 : 3700 : done:
9015 : 3700 : p->level--;
9016 : 3700 : return _res;
9017 : : }
9018 : :
9019 : : // wildcard_pattern: "_"
9020 : : static pattern_ty
9021 : 2304 : wildcard_pattern_rule(Parser *p)
9022 : : {
9023 [ - + ]: 2304 : if (p->level++ == MAXSTACK) {
9024 : 0 : p->error_indicator = 1;
9025 : : PyErr_NoMemory();
9026 : : }
9027 [ - + ]: 2304 : if (p->error_indicator) {
9028 : 0 : p->level--;
9029 : 0 : return NULL;
9030 : : }
9031 : 2304 : pattern_ty _res = NULL;
9032 : 2304 : int _mark = p->mark;
9033 [ - + - - ]: 2304 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9034 : 0 : p->error_indicator = 1;
9035 : 0 : p->level--;
9036 : 0 : return NULL;
9037 : : }
9038 : 2304 : int _start_lineno = p->tokens[_mark]->lineno;
9039 : : UNUSED(_start_lineno); // Only used by EXTRA macro
9040 : 2304 : int _start_col_offset = p->tokens[_mark]->col_offset;
9041 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
9042 : : { // "_"
9043 [ - + ]: 2304 : if (p->error_indicator) {
9044 : 0 : p->level--;
9045 : 0 : return NULL;
9046 : : }
9047 : : D(fprintf(stderr, "%*c> wildcard_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"_\""));
9048 : : expr_ty _keyword;
9049 [ + + ]: 2304 : if (
9050 : 2304 : (_keyword = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"'
9051 : : )
9052 : : {
9053 : : D(fprintf(stderr, "%*c+ wildcard_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"_\""));
9054 : 306 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9055 [ - + ]: 306 : if (_token == NULL) {
9056 : 0 : p->level--;
9057 : 0 : return NULL;
9058 : : }
9059 : 306 : int _end_lineno = _token->end_lineno;
9060 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9061 : 306 : int _end_col_offset = _token->end_col_offset;
9062 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9063 : 306 : _res = _PyAST_MatchAs ( NULL , NULL , EXTRA );
9064 [ - + - - ]: 306 : if (_res == NULL && PyErr_Occurred()) {
9065 : 0 : p->error_indicator = 1;
9066 : 0 : p->level--;
9067 : 0 : return NULL;
9068 : : }
9069 : 306 : goto done;
9070 : : }
9071 : 1998 : 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 : 1998 : _res = NULL;
9076 : 2304 : done:
9077 : 2304 : p->level--;
9078 : 2304 : return _res;
9079 : : }
9080 : :
9081 : : // value_pattern: attr !('.' | '(' | '=')
9082 : : static pattern_ty
9083 : 1998 : value_pattern_rule(Parser *p)
9084 : : {
9085 [ - + ]: 1998 : if (p->level++ == MAXSTACK) {
9086 : 0 : p->error_indicator = 1;
9087 : : PyErr_NoMemory();
9088 : : }
9089 [ - + ]: 1998 : if (p->error_indicator) {
9090 : 0 : p->level--;
9091 : 0 : return NULL;
9092 : : }
9093 : 1998 : pattern_ty _res = NULL;
9094 : 1998 : int _mark = p->mark;
9095 [ - + - - ]: 1998 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9096 : 0 : p->error_indicator = 1;
9097 : 0 : p->level--;
9098 : 0 : return NULL;
9099 : : }
9100 : 1998 : int _start_lineno = p->tokens[_mark]->lineno;
9101 : : UNUSED(_start_lineno); // Only used by EXTRA macro
9102 : 1998 : int _start_col_offset = p->tokens[_mark]->col_offset;
9103 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
9104 : : { // attr !('.' | '(' | '=')
9105 [ - + ]: 1998 : if (p->error_indicator) {
9106 : 0 : p->level--;
9107 : 0 : 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 [ + + ]: 1998 : if (
9112 : 1998 : (attr = attr_rule(p)) // attr
9113 [ + + ]: 111 : &&
9114 : 111 : _PyPegen_lookahead(0, _tmp_70_rule, p)
9115 : : )
9116 : : {
9117 : : D(fprintf(stderr, "%*c+ value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr !('.' | '(' | '=')"));
9118 : 60 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9119 [ - + ]: 60 : if (_token == NULL) {
9120 : 0 : p->level--;
9121 : 0 : return NULL;
9122 : : }
9123 : 60 : int _end_lineno = _token->end_lineno;
9124 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9125 : 60 : int _end_col_offset = _token->end_col_offset;
9126 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9127 : 60 : _res = _PyAST_MatchValue ( attr , EXTRA );
9128 [ - + - - ]: 60 : if (_res == NULL && PyErr_Occurred()) {
9129 : 0 : p->error_indicator = 1;
9130 : 0 : p->level--;
9131 : 0 : return NULL;
9132 : : }
9133 : 60 : goto done;
9134 : : }
9135 : 1938 : 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 : 1938 : _res = NULL;
9140 : 1998 : done:
9141 : 1998 : p->level--;
9142 : 1998 : 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 : 5978 : attr_rule(Parser *p)
9150 : : {
9151 [ - + ]: 5978 : if (p->level++ == MAXSTACK) {
9152 : 0 : p->error_indicator = 1;
9153 : : PyErr_NoMemory();
9154 : : }
9155 : 5978 : expr_ty _res = NULL;
9156 [ + + ]: 5978 : if (_PyPegen_is_memoized(p, attr_type, &_res)) {
9157 : 3944 : p->level--;
9158 : 3944 : return _res;
9159 : : }
9160 : 2034 : int _mark = p->mark;
9161 : 2034 : int _resmark = p->mark;
9162 : 151 : while (1) {
9163 : 2185 : int tmpvar_1 = _PyPegen_update_memo(p, _mark, attr_type, _res);
9164 [ - + ]: 2185 : if (tmpvar_1) {
9165 : 0 : p->level--;
9166 : 0 : return _res;
9167 : : }
9168 : 2185 : p->mark = _mark;
9169 : 2185 : void *_raw = attr_raw(p);
9170 [ - + ]: 2185 : if (p->error_indicator) {
9171 : 0 : p->level--;
9172 : 0 : return NULL;
9173 : : }
9174 [ + + + - ]: 2185 : if (_raw == NULL || p->mark <= _resmark)
9175 : : break;
9176 : 151 : _resmark = p->mark;
9177 : 151 : _res = _raw;
9178 : : }
9179 : 2034 : p->mark = _resmark;
9180 : 2034 : p->level--;
9181 : 2034 : return _res;
9182 : : }
9183 : : static expr_ty
9184 : 2185 : attr_raw(Parser *p)
9185 : : {
9186 [ - + ]: 2185 : if (p->level++ == MAXSTACK) {
9187 : 0 : p->error_indicator = 1;
9188 : : PyErr_NoMemory();
9189 : : }
9190 [ - + ]: 2185 : if (p->error_indicator) {
9191 : 0 : p->level--;
9192 : 0 : return NULL;
9193 : : }
9194 : 2185 : expr_ty _res = NULL;
9195 : 2185 : int _mark = p->mark;
9196 [ - + - - ]: 2185 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9197 : 0 : p->error_indicator = 1;
9198 : 0 : p->level--;
9199 : 0 : return NULL;
9200 : : }
9201 : 2185 : int _start_lineno = p->tokens[_mark]->lineno;
9202 : : UNUSED(_start_lineno); // Only used by EXTRA macro
9203 : 2185 : 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 [ - + ]: 2185 : if (p->error_indicator) {
9207 : 0 : p->level--;
9208 : 0 : 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 [ + + ]: 2185 : if (
9215 : 2185 : (value = name_or_attr_rule(p)) // name_or_attr
9216 [ + + ]: 592 : &&
9217 : 592 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
9218 [ + - ]: 151 : &&
9219 : 151 : (attr = _PyPegen_name_token(p)) // NAME
9220 : : )
9221 : : {
9222 : : D(fprintf(stderr, "%*c+ attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '.' NAME"));
9223 : 151 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9224 [ - + ]: 151 : if (_token == NULL) {
9225 : 0 : p->level--;
9226 : 0 : return NULL;
9227 : : }
9228 : 151 : int _end_lineno = _token->end_lineno;
9229 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9230 : 151 : int _end_col_offset = _token->end_col_offset;
9231 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9232 : 151 : _res = _PyAST_Attribute ( value , attr -> v . Name . id , Load , EXTRA );
9233 [ - + - - ]: 151 : if (_res == NULL && PyErr_Occurred()) {
9234 : 0 : p->error_indicator = 1;
9235 : 0 : p->level--;
9236 : 0 : return NULL;
9237 : : }
9238 : 151 : goto done;
9239 : : }
9240 : 2034 : 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 : 2034 : _res = NULL;
9245 : 2185 : done:
9246 : 2185 : p->level--;
9247 : 2185 : return _res;
9248 : : }
9249 : :
9250 : : // Left-recursive
9251 : : // name_or_attr: attr | NAME
9252 : : static expr_ty
9253 : 3928 : name_or_attr_rule(Parser *p)
9254 : : {
9255 [ - + ]: 3928 : if (p->level++ == MAXSTACK) {
9256 : 0 : p->error_indicator = 1;
9257 : : PyErr_NoMemory();
9258 : : }
9259 [ - + ]: 3928 : if (p->error_indicator) {
9260 : 0 : p->level--;
9261 : 0 : return NULL;
9262 : : }
9263 : 3928 : expr_ty _res = NULL;
9264 : 3928 : int _mark = p->mark;
9265 : : { // attr
9266 [ - + ]: 3928 : if (p->error_indicator) {
9267 : 0 : p->level--;
9268 : 0 : 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 [ + + ]: 3928 : if (
9273 : 3928 : (attr_var = attr_rule(p)) // attr
9274 : : )
9275 : : {
9276 : : D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr"));
9277 : 219 : _res = attr_var;
9278 : 219 : goto done;
9279 : : }
9280 : 3709 : 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 [ - + ]: 3709 : if (p->error_indicator) {
9286 : 0 : p->level--;
9287 : 0 : 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 [ + + ]: 3709 : if (
9292 : 3709 : (name_var = _PyPegen_name_token(p)) // NAME
9293 : : )
9294 : : {
9295 : : D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
9296 : 1375 : _res = name_var;
9297 : 1375 : goto done;
9298 : : }
9299 : 2334 : 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 : 2334 : _res = NULL;
9304 : 3928 : done:
9305 : 3928 : p->level--;
9306 : 3928 : return _res;
9307 : : }
9308 : :
9309 : : // group_pattern: '(' pattern ')'
9310 : : static pattern_ty
9311 : 1938 : group_pattern_rule(Parser *p)
9312 : : {
9313 [ - + ]: 1938 : if (p->level++ == MAXSTACK) {
9314 : 0 : p->error_indicator = 1;
9315 : : PyErr_NoMemory();
9316 : : }
9317 [ - + ]: 1938 : if (p->error_indicator) {
9318 : 0 : p->level--;
9319 : 0 : return NULL;
9320 : : }
9321 : 1938 : pattern_ty _res = NULL;
9322 : 1938 : int _mark = p->mark;
9323 : : { // '(' pattern ')'
9324 [ - + ]: 1938 : if (p->error_indicator) {
9325 : 0 : p->level--;
9326 : 0 : 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 [ + + ]: 1938 : if (
9333 : 1938 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
9334 [ + + ]: 342 : &&
9335 : 342 : (pattern = pattern_rule(p)) // pattern
9336 [ + + ]: 326 : &&
9337 : 326 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
9338 : : )
9339 : : {
9340 : : D(fprintf(stderr, "%*c+ group_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' pattern ')'"));
9341 : 257 : _res = pattern;
9342 [ - + - - ]: 257 : if (_res == NULL && PyErr_Occurred()) {
9343 : 0 : p->error_indicator = 1;
9344 : 0 : p->level--;
9345 : 0 : return NULL;
9346 : : }
9347 : 257 : goto done;
9348 : : }
9349 : 1681 : 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 : 1681 : _res = NULL;
9354 : 1938 : done:
9355 : 1938 : p->level--;
9356 : 1938 : return _res;
9357 : : }
9358 : :
9359 : : // sequence_pattern: '[' maybe_sequence_pattern? ']' | '(' open_sequence_pattern? ')'
9360 : : static pattern_ty
9361 : 1681 : sequence_pattern_rule(Parser *p)
9362 : : {
9363 [ - + ]: 1681 : if (p->level++ == MAXSTACK) {
9364 : 0 : p->error_indicator = 1;
9365 : : PyErr_NoMemory();
9366 : : }
9367 [ - + ]: 1681 : if (p->error_indicator) {
9368 : 0 : p->level--;
9369 : 0 : return NULL;
9370 : : }
9371 : 1681 : pattern_ty _res = NULL;
9372 : 1681 : int _mark = p->mark;
9373 [ - + - - ]: 1681 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9374 : 0 : p->error_indicator = 1;
9375 : 0 : p->level--;
9376 : 0 : return NULL;
9377 : : }
9378 : 1681 : int _start_lineno = p->tokens[_mark]->lineno;
9379 : : UNUSED(_start_lineno); // Only used by EXTRA macro
9380 : 1681 : int _start_col_offset = p->tokens[_mark]->col_offset;
9381 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
9382 : : { // '[' maybe_sequence_pattern? ']'
9383 [ - + ]: 1681 : if (p->error_indicator) {
9384 : 0 : p->level--;
9385 : 0 : 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 [ + + ]: 1681 : if (
9392 : 1681 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
9393 : 604 : &&
9394 [ + - ]: 604 : (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator) // maybe_sequence_pattern?
9395 [ + - ]: 604 : &&
9396 : 604 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
9397 : : )
9398 : : {
9399 : : D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' maybe_sequence_pattern? ']'"));
9400 : 604 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9401 [ - + ]: 604 : if (_token == NULL) {
9402 : 0 : p->level--;
9403 : 0 : return NULL;
9404 : : }
9405 : 604 : int _end_lineno = _token->end_lineno;
9406 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9407 : 604 : int _end_col_offset = _token->end_col_offset;
9408 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9409 : 604 : _res = _PyAST_MatchSequence ( patterns , EXTRA );
9410 [ - + - - ]: 604 : if (_res == NULL && PyErr_Occurred()) {
9411 : 0 : p->error_indicator = 1;
9412 : 0 : p->level--;
9413 : 0 : return NULL;
9414 : : }
9415 : 604 : goto done;
9416 : : }
9417 : 1077 : 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 [ - + ]: 1077 : if (p->error_indicator) {
9423 : 0 : p->level--;
9424 : 0 : 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 [ + + ]: 1077 : if (
9431 : 1077 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
9432 : 85 : &&
9433 [ + - ]: 85 : (patterns = open_sequence_pattern_rule(p), !p->error_indicator) // open_sequence_pattern?
9434 [ + - ]: 85 : &&
9435 : 85 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
9436 : : )
9437 : : {
9438 : : D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' open_sequence_pattern? ')'"));
9439 : 85 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9440 [ - + ]: 85 : if (_token == NULL) {
9441 : 0 : p->level--;
9442 : 0 : return NULL;
9443 : : }
9444 : 85 : int _end_lineno = _token->end_lineno;
9445 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9446 : 85 : int _end_col_offset = _token->end_col_offset;
9447 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9448 : 85 : _res = _PyAST_MatchSequence ( patterns , EXTRA );
9449 [ - + - - ]: 85 : if (_res == NULL && PyErr_Occurred()) {
9450 : 0 : p->error_indicator = 1;
9451 : 0 : p->level--;
9452 : 0 : return NULL;
9453 : : }
9454 : 85 : goto done;
9455 : : }
9456 : 992 : 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 : 992 : _res = NULL;
9461 : 1681 : done:
9462 : 1681 : p->level--;
9463 : 1681 : return _res;
9464 : : }
9465 : :
9466 : : // open_sequence_pattern: maybe_star_pattern ',' maybe_sequence_pattern?
9467 : : static asdl_seq*
9468 : 1933 : open_sequence_pattern_rule(Parser *p)
9469 : : {
9470 [ - + ]: 1933 : if (p->level++ == MAXSTACK) {
9471 : 0 : p->error_indicator = 1;
9472 : : PyErr_NoMemory();
9473 : : }
9474 [ - + ]: 1933 : if (p->error_indicator) {
9475 : 0 : p->level--;
9476 : 0 : return NULL;
9477 : : }
9478 : 1933 : asdl_seq* _res = NULL;
9479 : 1933 : int _mark = p->mark;
9480 : : { // maybe_star_pattern ',' maybe_sequence_pattern?
9481 [ - + ]: 1933 : if (p->error_indicator) {
9482 : 0 : p->level--;
9483 : 0 : 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 [ + + ]: 1933 : if (
9490 : 1933 : (pattern = maybe_star_pattern_rule(p)) // maybe_star_pattern
9491 [ + + ]: 1878 : &&
9492 : 1878 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
9493 : 149 : &&
9494 [ + - ]: 149 : (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator) // maybe_sequence_pattern?
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 : 149 : _res = _PyPegen_seq_insert_in_front ( p , pattern , patterns );
9499 [ - + - - ]: 149 : if (_res == NULL && PyErr_Occurred()) {
9500 : 0 : p->error_indicator = 1;
9501 : 0 : p->level--;
9502 : 0 : return NULL;
9503 : : }
9504 : 149 : goto done;
9505 : : }
9506 : 1784 : 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 : 1784 : _res = NULL;
9511 : 1933 : done:
9512 : 1933 : p->level--;
9513 : 1933 : return _res;
9514 : : }
9515 : :
9516 : : // maybe_sequence_pattern: ','.maybe_star_pattern+ ','?
9517 : : static asdl_seq*
9518 : 753 : maybe_sequence_pattern_rule(Parser *p)
9519 : : {
9520 [ - + ]: 753 : if (p->level++ == MAXSTACK) {
9521 : 0 : p->error_indicator = 1;
9522 : : PyErr_NoMemory();
9523 : : }
9524 [ - + ]: 753 : if (p->error_indicator) {
9525 : 0 : p->level--;
9526 : 0 : return NULL;
9527 : : }
9528 : 753 : asdl_seq* _res = NULL;
9529 : 753 : int _mark = p->mark;
9530 : : { // ','.maybe_star_pattern+ ','?
9531 [ - + ]: 753 : if (p->error_indicator) {
9532 : 0 : p->level--;
9533 : 0 : 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 [ + + ]: 753 : if (
9540 : 753 : (patterns = _gather_71_rule(p)) // ','.maybe_star_pattern+
9541 : 627 : &&
9542 [ + - ]: 627 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9543 : : )
9544 : : {
9545 : : D(fprintf(stderr, "%*c+ maybe_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.maybe_star_pattern+ ','?"));
9546 : 627 : _res = patterns;
9547 [ - + - - ]: 627 : if (_res == NULL && PyErr_Occurred()) {
9548 : 0 : p->error_indicator = 1;
9549 : 0 : p->level--;
9550 : 0 : return NULL;
9551 : : }
9552 : 627 : goto done;
9553 : : }
9554 : 126 : 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 : 126 : _res = NULL;
9559 : 753 : done:
9560 : 753 : p->level--;
9561 : 753 : return _res;
9562 : : }
9563 : :
9564 : : // maybe_star_pattern: star_pattern | pattern
9565 : : static pattern_ty
9566 : 3457 : maybe_star_pattern_rule(Parser *p)
9567 : : {
9568 [ - + ]: 3457 : if (p->level++ == MAXSTACK) {
9569 : 0 : p->error_indicator = 1;
9570 : : PyErr_NoMemory();
9571 : : }
9572 [ - + ]: 3457 : if (p->error_indicator) {
9573 : 0 : p->level--;
9574 : 0 : return NULL;
9575 : : }
9576 : 3457 : pattern_ty _res = NULL;
9577 : 3457 : int _mark = p->mark;
9578 : : { // star_pattern
9579 [ - + ]: 3457 : if (p->error_indicator) {
9580 : 0 : p->level--;
9581 : 0 : 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 [ + + ]: 3457 : if (
9586 : 3457 : (star_pattern_var = star_pattern_rule(p)) // star_pattern
9587 : : )
9588 : : {
9589 : : D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_pattern"));
9590 : 175 : _res = star_pattern_var;
9591 : 175 : goto done;
9592 : : }
9593 : 3282 : 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 [ - + ]: 3282 : if (p->error_indicator) {
9599 : 0 : p->level--;
9600 : 0 : 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 [ + + ]: 3282 : if (
9605 : 3282 : (pattern_var = pattern_rule(p)) // pattern
9606 : : )
9607 : : {
9608 : : D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern"));
9609 : 3074 : _res = pattern_var;
9610 : 3074 : goto done;
9611 : : }
9612 : 208 : 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 : 208 : _res = NULL;
9617 : 3457 : done:
9618 : 3457 : p->level--;
9619 : 3457 : return _res;
9620 : : }
9621 : :
9622 : : // star_pattern: '*' pattern_capture_target | '*' wildcard_pattern
9623 : : static pattern_ty
9624 : 3457 : star_pattern_rule(Parser *p)
9625 : : {
9626 [ - + ]: 3457 : if (p->level++ == MAXSTACK) {
9627 : 0 : p->error_indicator = 1;
9628 : : PyErr_NoMemory();
9629 : : }
9630 [ - + ]: 3457 : if (p->error_indicator) {
9631 : 0 : p->level--;
9632 : 0 : return NULL;
9633 : : }
9634 : 3457 : pattern_ty _res = NULL;
9635 [ + + ]: 3457 : if (_PyPegen_is_memoized(p, star_pattern_type, &_res)) {
9636 : 20 : p->level--;
9637 : 20 : return _res;
9638 : : }
9639 : 3437 : int _mark = p->mark;
9640 [ - + - - ]: 3437 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9641 : 0 : p->error_indicator = 1;
9642 : 0 : p->level--;
9643 : 0 : return NULL;
9644 : : }
9645 : 3437 : int _start_lineno = p->tokens[_mark]->lineno;
9646 : : UNUSED(_start_lineno); // Only used by EXTRA macro
9647 : 3437 : int _start_col_offset = p->tokens[_mark]->col_offset;
9648 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
9649 : : { // '*' pattern_capture_target
9650 [ - + ]: 3437 : if (p->error_indicator) {
9651 : 0 : p->level--;
9652 : 0 : 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 [ + + ]: 3437 : if (
9658 : 3437 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
9659 [ + + ]: 175 : &&
9660 : 175 : (target = pattern_capture_target_rule(p)) // pattern_capture_target
9661 : : )
9662 : : {
9663 : : D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' pattern_capture_target"));
9664 : 119 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9665 [ - + ]: 119 : if (_token == NULL) {
9666 : 0 : p->level--;
9667 : 0 : return NULL;
9668 : : }
9669 : 119 : int _end_lineno = _token->end_lineno;
9670 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9671 : 119 : int _end_col_offset = _token->end_col_offset;
9672 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9673 : 119 : _res = _PyAST_MatchStar ( target -> v . Name . id , EXTRA );
9674 [ - + - - ]: 119 : if (_res == NULL && PyErr_Occurred()) {
9675 : 0 : p->error_indicator = 1;
9676 : 0 : p->level--;
9677 : 0 : return NULL;
9678 : : }
9679 : 119 : goto done;
9680 : : }
9681 : 3318 : 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 [ - + ]: 3318 : if (p->error_indicator) {
9687 : 0 : p->level--;
9688 : 0 : 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 [ + + ]: 3318 : if (
9694 : 3318 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
9695 [ + - ]: 56 : &&
9696 : 56 : (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern
9697 : : )
9698 : : {
9699 : : D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' wildcard_pattern"));
9700 : 56 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9701 [ - + ]: 56 : if (_token == NULL) {
9702 : 0 : p->level--;
9703 : 0 : return NULL;
9704 : : }
9705 : 56 : int _end_lineno = _token->end_lineno;
9706 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9707 : 56 : int _end_col_offset = _token->end_col_offset;
9708 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9709 : 56 : _res = _PyAST_MatchStar ( NULL , EXTRA );
9710 [ - + - - ]: 56 : if (_res == NULL && PyErr_Occurred()) {
9711 : 0 : p->error_indicator = 1;
9712 : 0 : p->level--;
9713 : 0 : return NULL;
9714 : : }
9715 : 56 : goto done;
9716 : : }
9717 : 3262 : 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 : 3262 : _res = NULL;
9722 : 3437 : done:
9723 : 3437 : _PyPegen_insert_memo(p, _mark, star_pattern_type, _res);
9724 : 3437 : p->level--;
9725 : 3437 : 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 : 992 : mapping_pattern_rule(Parser *p)
9735 : : {
9736 [ - + ]: 992 : if (p->level++ == MAXSTACK) {
9737 : 0 : p->error_indicator = 1;
9738 : : PyErr_NoMemory();
9739 : : }
9740 [ - + ]: 992 : if (p->error_indicator) {
9741 : 0 : p->level--;
9742 : 0 : return NULL;
9743 : : }
9744 : 992 : pattern_ty _res = NULL;
9745 : 992 : int _mark = p->mark;
9746 [ - + - - ]: 992 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9747 : 0 : p->error_indicator = 1;
9748 : 0 : p->level--;
9749 : 0 : return NULL;
9750 : : }
9751 : 992 : int _start_lineno = p->tokens[_mark]->lineno;
9752 : : UNUSED(_start_lineno); // Only used by EXTRA macro
9753 : 992 : int _start_col_offset = p->tokens[_mark]->col_offset;
9754 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
9755 : : { // '{' '}'
9756 [ - + ]: 992 : if (p->error_indicator) {
9757 : 0 : p->level--;
9758 : 0 : 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 [ + + ]: 992 : if (
9764 : 992 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9765 [ + + ]: 444 : &&
9766 : 444 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
9767 : : )
9768 : : {
9769 : : D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'"));
9770 : 98 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9771 [ - + ]: 98 : if (_token == NULL) {
9772 : 0 : p->level--;
9773 : 0 : return NULL;
9774 : : }
9775 : 98 : int _end_lineno = _token->end_lineno;
9776 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9777 : 98 : int _end_col_offset = _token->end_col_offset;
9778 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9779 : 98 : _res = _PyAST_MatchMapping ( NULL , NULL , NULL , EXTRA );
9780 [ - + - - ]: 98 : if (_res == NULL && PyErr_Occurred()) {
9781 : 0 : p->error_indicator = 1;
9782 : 0 : p->level--;
9783 : 0 : return NULL;
9784 : : }
9785 : 98 : goto done;
9786 : : }
9787 : 894 : 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 [ - + ]: 894 : if (p->error_indicator) {
9793 : 0 : p->level--;
9794 : 0 : 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 [ + + ]: 894 : if (
9803 : 894 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9804 [ + + ]: 346 : &&
9805 : 346 : (rest = double_star_pattern_rule(p)) // double_star_pattern
9806 : 18 : &&
9807 [ + - ]: 18 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9808 [ + + ]: 18 : &&
9809 : 18 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
9810 : : )
9811 : : {
9812 : : D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_star_pattern ','? '}'"));
9813 : 12 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9814 [ - + ]: 12 : if (_token == NULL) {
9815 : 0 : p->level--;
9816 : 0 : return NULL;
9817 : : }
9818 : 12 : int _end_lineno = _token->end_lineno;
9819 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9820 : 12 : int _end_col_offset = _token->end_col_offset;
9821 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9822 : 12 : _res = _PyAST_MatchMapping ( NULL , NULL , rest -> v . Name . id , EXTRA );
9823 [ - + - - ]: 12 : if (_res == NULL && PyErr_Occurred()) {
9824 : 0 : p->error_indicator = 1;
9825 : 0 : p->level--;
9826 : 0 : return NULL;
9827 : : }
9828 : 12 : goto done;
9829 : : }
9830 : 882 : 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 [ - + ]: 882 : if (p->error_indicator) {
9836 : 0 : p->level--;
9837 : 0 : 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 [ + + ]: 882 : if (
9848 : 882 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9849 [ + + ]: 334 : &&
9850 : 334 : (items = items_pattern_rule(p)) // items_pattern
9851 [ + + ]: 321 : &&
9852 : 321 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
9853 [ + - ]: 22 : &&
9854 : 22 : (rest = double_star_pattern_rule(p)) // double_star_pattern
9855 : 22 : &&
9856 [ + - ]: 22 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9857 [ + + ]: 22 : &&
9858 : 22 : (_literal_2 = _PyPegen_expect_token(p, 26)) // token='}'
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 : 20 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9863 [ - + ]: 20 : if (_token == NULL) {
9864 : 0 : p->level--;
9865 : 0 : return NULL;
9866 : : }
9867 : 20 : int _end_lineno = _token->end_lineno;
9868 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9869 : 20 : int _end_col_offset = _token->end_col_offset;
9870 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9871 : 20 : _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 [ - + - - ]: 20 : if (_res == NULL && PyErr_Occurred()) {
9873 : 0 : p->error_indicator = 1;
9874 : 0 : p->level--;
9875 : 0 : return NULL;
9876 : : }
9877 : 20 : goto done;
9878 : : }
9879 : 862 : 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 [ + + ]: 862 : if (p->error_indicator) {
9885 : 3 : p->level--;
9886 : 3 : 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 [ + + ]: 859 : if (
9895 : 859 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9896 [ + + ]: 311 : &&
9897 : 311 : (items = items_pattern_rule(p)) // items_pattern
9898 : 301 : &&
9899 [ + - ]: 301 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9900 [ + + ]: 301 : &&
9901 : 301 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
9902 : : )
9903 : : {
9904 : : D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ','? '}'"));
9905 : 299 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9906 [ - + ]: 299 : if (_token == NULL) {
9907 : 0 : p->level--;
9908 : 0 : return NULL;
9909 : : }
9910 : 299 : int _end_lineno = _token->end_lineno;
9911 : : UNUSED(_end_lineno); // Only used by EXTRA macro
9912 : 299 : int _end_col_offset = _token->end_col_offset;
9913 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
9914 : 299 : _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 [ - + - - ]: 299 : if (_res == NULL && PyErr_Occurred()) {
9916 : 0 : p->error_indicator = 1;
9917 : 0 : p->level--;
9918 : 0 : return NULL;
9919 : : }
9920 : 299 : goto done;
9921 : : }
9922 : 560 : 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 : 560 : _res = NULL;
9927 : 989 : done:
9928 : 989 : p->level--;
9929 : 989 : return _res;
9930 : : }
9931 : :
9932 : : // items_pattern: ','.key_value_pattern+
9933 : : static asdl_seq*
9934 : 645 : items_pattern_rule(Parser *p)
9935 : : {
9936 [ - + ]: 645 : if (p->level++ == MAXSTACK) {
9937 : 0 : p->error_indicator = 1;
9938 : : PyErr_NoMemory();
9939 : : }
9940 [ - + ]: 645 : if (p->error_indicator) {
9941 : 0 : p->level--;
9942 : 0 : return NULL;
9943 : : }
9944 : 645 : asdl_seq* _res = NULL;
9945 : 645 : int _mark = p->mark;
9946 : : { // ','.key_value_pattern+
9947 [ - + ]: 645 : if (p->error_indicator) {
9948 : 0 : p->level--;
9949 : 0 : 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 [ + + ]: 645 : if (
9954 : 645 : (_gather_73_var = _gather_73_rule(p)) // ','.key_value_pattern+
9955 : : )
9956 : : {
9957 : : D(fprintf(stderr, "%*c+ items_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+"));
9958 : 622 : _res = _gather_73_var;
9959 : 622 : goto done;
9960 : : }
9961 : 23 : 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 : 23 : _res = NULL;
9966 : 645 : done:
9967 : 645 : p->level--;
9968 : 645 : return _res;
9969 : : }
9970 : :
9971 : : // key_value_pattern: (literal_expr | attr) ':' pattern
9972 : : static KeyPatternPair*
9973 : 809 : key_value_pattern_rule(Parser *p)
9974 : : {
9975 [ - + ]: 809 : if (p->level++ == MAXSTACK) {
9976 : 0 : p->error_indicator = 1;
9977 : : PyErr_NoMemory();
9978 : : }
9979 [ - + ]: 809 : if (p->error_indicator) {
9980 : 0 : p->level--;
9981 : 0 : return NULL;
9982 : : }
9983 : 809 : KeyPatternPair* _res = NULL;
9984 : 809 : int _mark = p->mark;
9985 : : { // (literal_expr | attr) ':' pattern
9986 [ - + ]: 809 : if (p->error_indicator) {
9987 : 0 : p->level--;
9988 : 0 : 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 [ + + ]: 809 : if (
9995 : 809 : (key = _tmp_75_rule(p)) // literal_expr | attr
9996 [ + - ]: 762 : &&
9997 : 762 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
9998 [ + - ]: 762 : &&
9999 : 762 : (pattern = pattern_rule(p)) // pattern
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 : 762 : _res = _PyPegen_key_pattern_pair ( p , key , pattern );
10004 [ - + - - ]: 762 : if (_res == NULL && PyErr_Occurred()) {
10005 : 0 : p->error_indicator = 1;
10006 : 0 : p->level--;
10007 : 0 : return NULL;
10008 : : }
10009 : 762 : goto done;
10010 : : }
10011 : 47 : 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 : 47 : _res = NULL;
10016 : 809 : done:
10017 : 809 : p->level--;
10018 : 809 : return _res;
10019 : : }
10020 : :
10021 : : // double_star_pattern: '**' pattern_capture_target
10022 : : static expr_ty
10023 : 368 : double_star_pattern_rule(Parser *p)
10024 : : {
10025 [ - + ]: 368 : if (p->level++ == MAXSTACK) {
10026 : 0 : p->error_indicator = 1;
10027 : : PyErr_NoMemory();
10028 : : }
10029 [ - + ]: 368 : if (p->error_indicator) {
10030 : 0 : p->level--;
10031 : 0 : return NULL;
10032 : : }
10033 : 368 : expr_ty _res = NULL;
10034 : 368 : int _mark = p->mark;
10035 : : { // '**' pattern_capture_target
10036 [ - + ]: 368 : if (p->error_indicator) {
10037 : 0 : p->level--;
10038 : 0 : 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 [ + + ]: 368 : if (
10044 : 368 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
10045 [ + + ]: 44 : &&
10046 : 44 : (target = pattern_capture_target_rule(p)) // 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 : 40 : _res = target;
10051 [ - + - - ]: 40 : if (_res == NULL && PyErr_Occurred()) {
10052 : 0 : p->error_indicator = 1;
10053 : 0 : p->level--;
10054 : 0 : return NULL;
10055 : : }
10056 : 40 : goto done;
10057 : : }
10058 : 328 : 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 : 328 : _res = NULL;
10063 : 368 : done:
10064 : 368 : p->level--;
10065 : 368 : 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 : 560 : class_pattern_rule(Parser *p)
10076 : : {
10077 [ - + ]: 560 : if (p->level++ == MAXSTACK) {
10078 : 0 : p->error_indicator = 1;
10079 : : PyErr_NoMemory();
10080 : : }
10081 [ - + ]: 560 : if (p->error_indicator) {
10082 : 0 : p->level--;
10083 : 0 : return NULL;
10084 : : }
10085 : 560 : pattern_ty _res = NULL;
10086 : 560 : int _mark = p->mark;
10087 [ - + - - ]: 560 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10088 : 0 : p->error_indicator = 1;
10089 : 0 : p->level--;
10090 : 0 : return NULL;
10091 : : }
10092 : 560 : int _start_lineno = p->tokens[_mark]->lineno;
10093 : : UNUSED(_start_lineno); // Only used by EXTRA macro
10094 : 560 : int _start_col_offset = p->tokens[_mark]->col_offset;
10095 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
10096 : : { // name_or_attr '(' ')'
10097 [ - + ]: 560 : if (p->error_indicator) {
10098 : 0 : p->level--;
10099 : 0 : 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 [ + + ]: 560 : if (
10106 : 560 : (cls = name_or_attr_rule(p)) // name_or_attr
10107 [ + + ]: 377 : &&
10108 : 377 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
10109 [ + + ]: 300 : &&
10110 : 300 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
10111 : : )
10112 : : {
10113 : : D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' ')'"));
10114 : 40 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10115 [ - + ]: 40 : if (_token == NULL) {
10116 : 0 : p->level--;
10117 : 0 : return NULL;
10118 : : }
10119 : 40 : int _end_lineno = _token->end_lineno;
10120 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10121 : 40 : int _end_col_offset = _token->end_col_offset;
10122 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10123 : 40 : _res = _PyAST_MatchClass ( cls , NULL , NULL , NULL , EXTRA );
10124 [ - + - - ]: 40 : if (_res == NULL && PyErr_Occurred()) {
10125 : 0 : p->error_indicator = 1;
10126 : 0 : p->level--;
10127 : 0 : return NULL;
10128 : : }
10129 : 40 : goto done;
10130 : : }
10131 : 520 : 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 [ - + ]: 520 : if (p->error_indicator) {
10137 : 0 : p->level--;
10138 : 0 : 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 [ + + ]: 520 : if (
10148 : 520 : (cls = name_or_attr_rule(p)) // name_or_attr
10149 [ + + ]: 337 : &&
10150 : 337 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
10151 [ + + ]: 260 : &&
10152 : 260 : (patterns = positional_patterns_rule(p)) // positional_patterns
10153 : 228 : &&
10154 [ + - ]: 228 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10155 [ + + ]: 228 : &&
10156 : 228 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
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 : 185 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10161 [ - + ]: 185 : if (_token == NULL) {
10162 : 0 : p->level--;
10163 : 0 : return NULL;
10164 : : }
10165 : 185 : int _end_lineno = _token->end_lineno;
10166 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10167 : 185 : int _end_col_offset = _token->end_col_offset;
10168 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10169 : 185 : _res = _PyAST_MatchClass ( cls , patterns , NULL , NULL , EXTRA );
10170 [ - + - - ]: 185 : if (_res == NULL && PyErr_Occurred()) {
10171 : 0 : p->error_indicator = 1;
10172 : 0 : p->level--;
10173 : 0 : return NULL;
10174 : : }
10175 : 185 : goto done;
10176 : : }
10177 : 335 : 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 [ - + ]: 335 : if (p->error_indicator) {
10183 : 0 : p->level--;
10184 : 0 : 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 [ + + ]: 335 : if (
10194 : 335 : (cls = name_or_attr_rule(p)) // name_or_attr
10195 [ + + ]: 152 : &&
10196 : 152 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
10197 [ + + ]: 75 : &&
10198 : 75 : (keywords = keyword_patterns_rule(p)) // keyword_patterns
10199 : 32 : &&
10200 [ + - ]: 32 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10201 [ + + ]: 32 : &&
10202 : 32 : (_literal_1 = _PyPegen_expect_token(p, 8)) // 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 : 26 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10207 [ - + ]: 26 : if (_token == NULL) {
10208 : 0 : p->level--;
10209 : 0 : return NULL;
10210 : : }
10211 : 26 : int _end_lineno = _token->end_lineno;
10212 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10213 : 26 : int _end_col_offset = _token->end_col_offset;
10214 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10215 : 26 : _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 [ - + - - ]: 26 : if (_res == NULL && PyErr_Occurred()) {
10217 : 0 : p->error_indicator = 1;
10218 : 0 : p->level--;
10219 : 0 : return NULL;
10220 : : }
10221 : 26 : goto done;
10222 : : }
10223 : 309 : 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 [ - + ]: 309 : if (p->error_indicator) {
10229 : 0 : p->level--;
10230 : 0 : 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 [ + + ]: 309 : if (
10242 : 309 : (cls = name_or_attr_rule(p)) // name_or_attr
10243 [ + + ]: 126 : &&
10244 : 126 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
10245 [ + + ]: 49 : &&
10246 : 49 : (patterns = positional_patterns_rule(p)) // positional_patterns
10247 [ + - ]: 43 : &&
10248 : 43 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
10249 [ + - ]: 43 : &&
10250 : 43 : (keywords = keyword_patterns_rule(p)) // keyword_patterns
10251 : 43 : &&
10252 [ + - ]: 43 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10253 [ + + ]: 43 : &&
10254 : 43 : (_literal_2 = _PyPegen_expect_token(p, 8)) // 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 : 41 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10259 [ - + ]: 41 : if (_token == NULL) {
10260 : 0 : p->level--;
10261 : 0 : return NULL;
10262 : : }
10263 : 41 : int _end_lineno = _token->end_lineno;
10264 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10265 : 41 : int _end_col_offset = _token->end_col_offset;
10266 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10267 : 41 : _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 [ - + - - ]: 41 : if (_res == NULL && PyErr_Occurred()) {
10269 : 0 : p->error_indicator = 1;
10270 : 0 : p->level--;
10271 : 0 : return NULL;
10272 : : }
10273 : 41 : goto done;
10274 : : }
10275 : 268 : 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 [ + + ]: 268 : if (p->call_invalid_rules) { // invalid_class_pattern
10280 [ - + ]: 19 : if (p->error_indicator) {
10281 : 0 : p->level--;
10282 : 0 : 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 [ - + ]: 19 : if (
10287 : 19 : (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 : 0 : _res = invalid_class_pattern_var;
10292 : 0 : goto done;
10293 : : }
10294 : 19 : 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 : 268 : _res = NULL;
10299 : 560 : done:
10300 : 560 : p->level--;
10301 : 560 : return _res;
10302 : : }
10303 : :
10304 : : // positional_patterns: ','.pattern+
10305 : : static asdl_pattern_seq*
10306 : 317 : positional_patterns_rule(Parser *p)
10307 : : {
10308 [ - + ]: 317 : if (p->level++ == MAXSTACK) {
10309 : 0 : p->error_indicator = 1;
10310 : : PyErr_NoMemory();
10311 : : }
10312 [ - + ]: 317 : if (p->error_indicator) {
10313 : 0 : p->level--;
10314 : 0 : return NULL;
10315 : : }
10316 : 317 : asdl_pattern_seq* _res = NULL;
10317 : 317 : int _mark = p->mark;
10318 : : { // ','.pattern+
10319 [ - + ]: 317 : if (p->error_indicator) {
10320 : 0 : p->level--;
10321 : 0 : 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 [ + + ]: 317 : if (
10326 : 317 : (args = (asdl_pattern_seq*)_gather_76_rule(p)) // ','.pattern+
10327 : : )
10328 : : {
10329 : : D(fprintf(stderr, "%*c+ positional_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.pattern+"));
10330 : 276 : _res = args;
10331 [ - + - - ]: 276 : if (_res == NULL && PyErr_Occurred()) {
10332 : 0 : p->error_indicator = 1;
10333 : 0 : p->level--;
10334 : 0 : return NULL;
10335 : : }
10336 : 276 : goto done;
10337 : : }
10338 : 41 : 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 : 41 : _res = NULL;
10343 : 317 : done:
10344 : 317 : p->level--;
10345 : 317 : return _res;
10346 : : }
10347 : :
10348 : : // keyword_patterns: ','.keyword_pattern+
10349 : : static asdl_seq*
10350 : 122 : keyword_patterns_rule(Parser *p)
10351 : : {
10352 [ - + ]: 122 : if (p->level++ == MAXSTACK) {
10353 : 0 : p->error_indicator = 1;
10354 : : PyErr_NoMemory();
10355 : : }
10356 [ - + ]: 122 : if (p->error_indicator) {
10357 : 0 : p->level--;
10358 : 0 : return NULL;
10359 : : }
10360 : 122 : asdl_seq* _res = NULL;
10361 : 122 : int _mark = p->mark;
10362 : : { // ','.keyword_pattern+
10363 [ - + ]: 122 : if (p->error_indicator) {
10364 : 0 : p->level--;
10365 : 0 : 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 [ + + ]: 122 : if (
10370 : 122 : (_gather_78_var = _gather_78_rule(p)) // ','.keyword_pattern+
10371 : : )
10372 : : {
10373 : : D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+"));
10374 : 79 : _res = _gather_78_var;
10375 : 79 : goto done;
10376 : : }
10377 : 43 : 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 : 43 : _res = NULL;
10382 : 122 : done:
10383 : 122 : p->level--;
10384 : 122 : return _res;
10385 : : }
10386 : :
10387 : : // keyword_pattern: NAME '=' pattern
10388 : : static KeyPatternPair*
10389 : 178 : keyword_pattern_rule(Parser *p)
10390 : : {
10391 [ - + ]: 178 : if (p->level++ == MAXSTACK) {
10392 : 0 : p->error_indicator = 1;
10393 : : PyErr_NoMemory();
10394 : : }
10395 [ - + ]: 178 : if (p->error_indicator) {
10396 : 0 : p->level--;
10397 : 0 : return NULL;
10398 : : }
10399 : 178 : KeyPatternPair* _res = NULL;
10400 : 178 : int _mark = p->mark;
10401 : : { // NAME '=' pattern
10402 [ - + ]: 178 : if (p->error_indicator) {
10403 : 0 : p->level--;
10404 : 0 : 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 [ + + ]: 178 : if (
10411 : 178 : (arg = _PyPegen_name_token(p)) // NAME
10412 [ + + ]: 174 : &&
10413 : 174 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
10414 [ + - ]: 123 : &&
10415 : 123 : (value = pattern_rule(p)) // pattern
10416 : : )
10417 : : {
10418 : : D(fprintf(stderr, "%*c+ keyword_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' pattern"));
10419 : 123 : _res = _PyPegen_key_pattern_pair ( p , arg , value );
10420 [ - + - - ]: 123 : if (_res == NULL && PyErr_Occurred()) {
10421 : 0 : p->error_indicator = 1;
10422 : 0 : p->level--;
10423 : 0 : return NULL;
10424 : : }
10425 : 123 : goto done;
10426 : : }
10427 : 55 : 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 : 55 : _res = NULL;
10432 : 178 : done:
10433 : 178 : p->level--;
10434 : 178 : return _res;
10435 : : }
10436 : :
10437 : : // expressions: expression ((',' expression))+ ','? | expression ',' | expression
10438 : : static expr_ty
10439 : 72975 : expressions_rule(Parser *p)
10440 : : {
10441 [ - + ]: 72975 : if (p->level++ == MAXSTACK) {
10442 : 0 : p->error_indicator = 1;
10443 : : PyErr_NoMemory();
10444 : : }
10445 [ - + ]: 72975 : if (p->error_indicator) {
10446 : 0 : p->level--;
10447 : 0 : return NULL;
10448 : : }
10449 : 72975 : expr_ty _res = NULL;
10450 : 72975 : int _mark = p->mark;
10451 [ + + + + ]: 72975 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10452 : 86 : p->error_indicator = 1;
10453 : 86 : p->level--;
10454 : 86 : return NULL;
10455 : : }
10456 : 72889 : int _start_lineno = p->tokens[_mark]->lineno;
10457 : : UNUSED(_start_lineno); // Only used by EXTRA macro
10458 : 72889 : int _start_col_offset = p->tokens[_mark]->col_offset;
10459 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
10460 : : { // expression ((',' expression))+ ','?
10461 [ - + ]: 72889 : if (p->error_indicator) {
10462 : 0 : p->level--;
10463 : 0 : 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 [ + + ]: 72889 : if (
10471 : 72889 : (a = expression_rule(p)) // expression
10472 [ + + ]: 72089 : &&
10473 : 72089 : (b = _loop1_80_rule(p)) // ((',' expression))+
10474 : 213 : &&
10475 [ + - ]: 213 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10476 : : )
10477 : : {
10478 : : D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?"));
10479 : 213 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10480 [ - + ]: 213 : if (_token == NULL) {
10481 : 0 : p->level--;
10482 : 0 : return NULL;
10483 : : }
10484 : 213 : int _end_lineno = _token->end_lineno;
10485 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10486 : 213 : int _end_col_offset = _token->end_col_offset;
10487 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10488 : 213 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
10489 [ - + - - ]: 213 : if (_res == NULL && PyErr_Occurred()) {
10490 : 0 : p->error_indicator = 1;
10491 : 0 : p->level--;
10492 : 0 : return NULL;
10493 : : }
10494 : 213 : goto done;
10495 : : }
10496 : 72676 : 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 [ + + ]: 72676 : if (p->error_indicator) {
10502 : 769 : p->level--;
10503 : 769 : 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 [ + + ]: 71907 : if (
10509 : 71907 : (a = expression_rule(p)) // expression
10510 [ - + ]: 71876 : &&
10511 : 71876 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
10512 : : )
10513 : : {
10514 : : D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ','"));
10515 : 0 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10516 [ # # ]: 0 : if (_token == NULL) {
10517 : 0 : p->level--;
10518 : 0 : return NULL;
10519 : : }
10520 : 0 : int _end_lineno = _token->end_lineno;
10521 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10522 : 0 : int _end_col_offset = _token->end_col_offset;
10523 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10524 : 0 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
10525 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
10526 : 0 : p->error_indicator = 1;
10527 : 0 : p->level--;
10528 : 0 : return NULL;
10529 : : }
10530 : 0 : goto done;
10531 : : }
10532 : 71907 : 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 [ - + ]: 71907 : if (p->error_indicator) {
10538 : 0 : p->level--;
10539 : 0 : 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 [ + + ]: 71907 : if (
10544 : 71907 : (expression_var = expression_rule(p)) // expression
10545 : : )
10546 : : {
10547 : : D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
10548 : 71876 : _res = expression_var;
10549 : 71876 : goto done;
10550 : : }
10551 : 31 : 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 : 31 : _res = NULL;
10556 : 72120 : done:
10557 : 72120 : p->level--;
10558 : 72120 : 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 : 22780670 : expression_rule(Parser *p)
10569 : : {
10570 [ - + ]: 22780670 : if (p->level++ == MAXSTACK) {
10571 : 0 : p->error_indicator = 1;
10572 : : PyErr_NoMemory();
10573 : : }
10574 [ - + ]: 22780670 : if (p->error_indicator) {
10575 : 0 : p->level--;
10576 : 0 : return NULL;
10577 : : }
10578 : 22780670 : expr_ty _res = NULL;
10579 [ + + ]: 22780670 : if (_PyPegen_is_memoized(p, expression_type, &_res)) {
10580 : 10811003 : p->level--;
10581 : 10811003 : return _res;
10582 : : }
10583 : 11969667 : int _mark = p->mark;
10584 [ - + - - ]: 11969667 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10585 : 0 : p->error_indicator = 1;
10586 : 0 : p->level--;
10587 : 0 : return NULL;
10588 : : }
10589 : 11969667 : int _start_lineno = p->tokens[_mark]->lineno;
10590 : : UNUSED(_start_lineno); // Only used by EXTRA macro
10591 : 11969667 : int _start_col_offset = p->tokens[_mark]->col_offset;
10592 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
10593 [ + + ]: 11969667 : if (p->call_invalid_rules) { // invalid_expression
10594 [ - + ]: 2706 : if (p->error_indicator) {
10595 : 0 : p->level--;
10596 : 0 : 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 [ - + ]: 2706 : if (
10601 : 2706 : (invalid_expression_var = invalid_expression_rule(p)) // invalid_expression
10602 : : )
10603 : : {
10604 : : D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_expression"));
10605 : 0 : _res = invalid_expression_var;
10606 : 0 : goto done;
10607 : : }
10608 : 2706 : 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 [ + + ]: 11969667 : if (p->call_invalid_rules) { // invalid_legacy_expression
10613 [ + + ]: 2706 : if (p->error_indicator) {
10614 : 32 : p->level--;
10615 : 32 : 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 [ - + ]: 2674 : if (
10620 : 2674 : (invalid_legacy_expression_var = invalid_legacy_expression_rule(p)) // invalid_legacy_expression
10621 : : )
10622 : : {
10623 : : D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_legacy_expression"));
10624 : 0 : _res = invalid_legacy_expression_var;
10625 : 0 : goto done;
10626 : : }
10627 : 2674 : 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 [ + + ]: 11969635 : if (p->error_indicator) {
10633 : 27 : p->level--;
10634 : 27 : 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 [ + + ]: 11969608 : if (
10643 : 11969608 : (a = disjunction_rule(p)) // disjunction
10644 [ + + ]: 9678156 : &&
10645 : 9678156 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
10646 [ + + ]: 11094 : &&
10647 : 11094 : (b = disjunction_rule(p)) // disjunction
10648 [ + + ]: 11084 : &&
10649 : 11084 : (_keyword_1 = _PyPegen_expect_token(p, 637)) // token='else'
10650 [ + - ]: 11078 : &&
10651 : 11078 : (c = expression_rule(p)) // expression
10652 : : )
10653 : : {
10654 : : D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
10655 : 11078 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10656 [ - + ]: 11078 : if (_token == NULL) {
10657 : 0 : p->level--;
10658 : 0 : return NULL;
10659 : : }
10660 : 11078 : int _end_lineno = _token->end_lineno;
10661 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10662 : 11078 : int _end_col_offset = _token->end_col_offset;
10663 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10664 : 11078 : _res = _PyAST_IfExp ( b , a , c , EXTRA );
10665 [ - + - - ]: 11078 : if (_res == NULL && PyErr_Occurred()) {
10666 : 0 : p->error_indicator = 1;
10667 : 0 : p->level--;
10668 : 0 : return NULL;
10669 : : }
10670 : 11078 : goto done;
10671 : : }
10672 : 11958530 : 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 [ + + ]: 11958530 : if (p->error_indicator) {
10678 : 839 : p->level--;
10679 : 839 : 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 [ + + ]: 11957691 : if (
10684 : 11957691 : (disjunction_var = disjunction_rule(p)) // disjunction
10685 : : )
10686 : : {
10687 : : D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction"));
10688 : 9667068 : _res = disjunction_var;
10689 : 9667068 : goto done;
10690 : : }
10691 : 2290623 : 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 [ - + ]: 2290623 : if (p->error_indicator) {
10697 : 0 : p->level--;
10698 : 0 : 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 [ + + ]: 2290623 : if (
10703 : 2290623 : (lambdef_var = lambdef_rule(p)) // lambdef
10704 : : )
10705 : : {
10706 : : D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef"));
10707 : 37206 : _res = lambdef_var;
10708 : 37206 : goto done;
10709 : : }
10710 : 2253417 : 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 : 2253417 : _res = NULL;
10715 : 11968769 : done:
10716 : 11968769 : _PyPegen_insert_memo(p, _mark, expression_type, _res);
10717 : 11968769 : p->level--;
10718 : 11968769 : return _res;
10719 : : }
10720 : :
10721 : : // yield_expr: 'yield' 'from' expression | 'yield' star_expressions?
10722 : : static expr_ty
10723 : 1146091 : yield_expr_rule(Parser *p)
10724 : : {
10725 [ - + ]: 1146091 : if (p->level++ == MAXSTACK) {
10726 : 0 : p->error_indicator = 1;
10727 : : PyErr_NoMemory();
10728 : : }
10729 [ - + ]: 1146091 : if (p->error_indicator) {
10730 : 0 : p->level--;
10731 : 0 : return NULL;
10732 : : }
10733 : 1146091 : expr_ty _res = NULL;
10734 : 1146091 : int _mark = p->mark;
10735 [ + + - + ]: 1146091 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10736 : 0 : p->error_indicator = 1;
10737 : 0 : p->level--;
10738 : 0 : return NULL;
10739 : : }
10740 : 1146091 : int _start_lineno = p->tokens[_mark]->lineno;
10741 : : UNUSED(_start_lineno); // Only used by EXTRA macro
10742 : 1146091 : int _start_col_offset = p->tokens[_mark]->col_offset;
10743 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
10744 : : { // 'yield' 'from' expression
10745 [ - + ]: 1146091 : if (p->error_indicator) {
10746 : 0 : p->level--;
10747 : 0 : 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 [ + + ]: 1146091 : if (
10754 : 1146091 : (_keyword = _PyPegen_expect_token(p, 573)) // token='yield'
10755 [ + + ]: 15869 : &&
10756 : 15869 : (_keyword_1 = _PyPegen_expect_token(p, 572)) // token='from'
10757 [ + + ]: 2244 : &&
10758 : 2244 : (a = expression_rule(p)) // expression
10759 : : )
10760 : : {
10761 : : D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression"));
10762 : 2241 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10763 [ - + ]: 2241 : if (_token == NULL) {
10764 : 0 : p->level--;
10765 : 0 : return NULL;
10766 : : }
10767 : 2241 : int _end_lineno = _token->end_lineno;
10768 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10769 : 2241 : int _end_col_offset = _token->end_col_offset;
10770 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10771 : 2241 : _res = _PyAST_YieldFrom ( a , EXTRA );
10772 [ - + - - ]: 2241 : if (_res == NULL && PyErr_Occurred()) {
10773 : 0 : p->error_indicator = 1;
10774 : 0 : p->level--;
10775 : 0 : return NULL;
10776 : : }
10777 : 2241 : goto done;
10778 : : }
10779 : 1143850 : 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 [ - + ]: 1143850 : if (p->error_indicator) {
10785 : 0 : p->level--;
10786 : 0 : 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 [ + + ]: 1143850 : if (
10792 : 1143850 : (_keyword = _PyPegen_expect_token(p, 573)) // token='yield'
10793 : 13628 : &&
10794 [ + - ]: 13628 : (a = star_expressions_rule(p), !p->error_indicator) // star_expressions?
10795 : : )
10796 : : {
10797 : : D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?"));
10798 : 13628 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10799 [ - + ]: 13628 : if (_token == NULL) {
10800 : 0 : p->level--;
10801 : 0 : return NULL;
10802 : : }
10803 : 13628 : int _end_lineno = _token->end_lineno;
10804 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10805 : 13628 : int _end_col_offset = _token->end_col_offset;
10806 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10807 : 13628 : _res = _PyAST_Yield ( a , EXTRA );
10808 [ - + - - ]: 13628 : if (_res == NULL && PyErr_Occurred()) {
10809 : 0 : p->error_indicator = 1;
10810 : 0 : p->level--;
10811 : 0 : return NULL;
10812 : : }
10813 : 13628 : goto done;
10814 : : }
10815 : 1130222 : 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 : 1130222 : _res = NULL;
10820 : 1146091 : done:
10821 : 1146091 : p->level--;
10822 : 1146091 : return _res;
10823 : : }
10824 : :
10825 : : // star_expressions:
10826 : : // | star_expression ((',' star_expression))+ ','?
10827 : : // | star_expression ','
10828 : : // | star_expression
10829 : : static expr_ty
10830 : 3618724 : star_expressions_rule(Parser *p)
10831 : : {
10832 [ - + ]: 3618724 : if (p->level++ == MAXSTACK) {
10833 : 0 : p->error_indicator = 1;
10834 : : PyErr_NoMemory();
10835 : : }
10836 [ - + ]: 3618724 : if (p->error_indicator) {
10837 : 0 : p->level--;
10838 : 0 : return NULL;
10839 : : }
10840 : 3618724 : expr_ty _res = NULL;
10841 : 3618724 : int _mark = p->mark;
10842 [ + + - + ]: 3618724 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10843 : 0 : p->error_indicator = 1;
10844 : 0 : p->level--;
10845 : 0 : return NULL;
10846 : : }
10847 : 3618724 : int _start_lineno = p->tokens[_mark]->lineno;
10848 : : UNUSED(_start_lineno); // Only used by EXTRA macro
10849 : 3618724 : 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 [ - + ]: 3618724 : if (p->error_indicator) {
10853 : 0 : p->level--;
10854 : 0 : 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 [ + + ]: 3618724 : if (
10862 : 3618724 : (a = star_expression_rule(p)) // star_expression
10863 [ + + ]: 2094896 : &&
10864 : 2094896 : (b = _loop1_81_rule(p)) // ((',' star_expression))+
10865 : 19530 : &&
10866 [ + - ]: 19530 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10867 : : )
10868 : : {
10869 : : D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
10870 : 19530 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10871 [ - + ]: 19530 : if (_token == NULL) {
10872 : 0 : p->level--;
10873 : 0 : return NULL;
10874 : : }
10875 : 19530 : int _end_lineno = _token->end_lineno;
10876 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10877 : 19530 : int _end_col_offset = _token->end_col_offset;
10878 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10879 : 19530 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
10880 [ - + - - ]: 19530 : if (_res == NULL && PyErr_Occurred()) {
10881 : 0 : p->error_indicator = 1;
10882 : 0 : p->level--;
10883 : 0 : return NULL;
10884 : : }
10885 : 19530 : goto done;
10886 : : }
10887 : 3599194 : 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 [ + + ]: 3599194 : if (p->error_indicator) {
10893 : 28 : p->level--;
10894 : 28 : 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 [ + + ]: 3599166 : if (
10900 : 3599166 : (a = star_expression_rule(p)) // star_expression
10901 [ + + ]: 2075364 : &&
10902 : 2075364 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
10903 : : )
10904 : : {
10905 : : D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ','"));
10906 : 221 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10907 [ - + ]: 221 : if (_token == NULL) {
10908 : 0 : p->level--;
10909 : 0 : return NULL;
10910 : : }
10911 : 221 : int _end_lineno = _token->end_lineno;
10912 : : UNUSED(_end_lineno); // Only used by EXTRA macro
10913 : 221 : int _end_col_offset = _token->end_col_offset;
10914 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
10915 : 221 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
10916 [ - + - - ]: 221 : if (_res == NULL && PyErr_Occurred()) {
10917 : 0 : p->error_indicator = 1;
10918 : 0 : p->level--;
10919 : 0 : return NULL;
10920 : : }
10921 : 221 : goto done;
10922 : : }
10923 : 3598945 : 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 [ - + ]: 3598945 : if (p->error_indicator) {
10929 : 0 : p->level--;
10930 : 0 : 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 [ + + ]: 3598945 : if (
10935 : 3598945 : (star_expression_var = star_expression_rule(p)) // star_expression
10936 : : )
10937 : : {
10938 : : D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression"));
10939 : 2075143 : _res = star_expression_var;
10940 : 2075143 : goto done;
10941 : : }
10942 : 1523802 : 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 : 1523802 : _res = NULL;
10947 : 3618696 : done:
10948 : 3618696 : p->level--;
10949 : 3618696 : return _res;
10950 : : }
10951 : :
10952 : : // star_expression: '*' bitwise_or | expression
10953 : : static expr_ty
10954 : 10845112 : star_expression_rule(Parser *p)
10955 : : {
10956 [ - + ]: 10845112 : if (p->level++ == MAXSTACK) {
10957 : 0 : p->error_indicator = 1;
10958 : : PyErr_NoMemory();
10959 : : }
10960 [ - + ]: 10845112 : if (p->error_indicator) {
10961 : 0 : p->level--;
10962 : 0 : return NULL;
10963 : : }
10964 : 10845112 : expr_ty _res = NULL;
10965 [ + + ]: 10845112 : if (_PyPegen_is_memoized(p, star_expression_type, &_res)) {
10966 : 7199889 : p->level--;
10967 : 7199889 : return _res;
10968 : : }
10969 : 3645223 : int _mark = p->mark;
10970 [ - + - - ]: 3645223 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10971 : 0 : p->error_indicator = 1;
10972 : 0 : p->level--;
10973 : 0 : return NULL;
10974 : : }
10975 : 3645223 : int _start_lineno = p->tokens[_mark]->lineno;
10976 : : UNUSED(_start_lineno); // Only used by EXTRA macro
10977 : 3645223 : int _start_col_offset = p->tokens[_mark]->col_offset;
10978 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
10979 : : { // '*' bitwise_or
10980 [ - + ]: 3645223 : if (p->error_indicator) {
10981 : 0 : p->level--;
10982 : 0 : 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 [ + + ]: 3645223 : if (
10988 : 3645223 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
10989 [ + - ]: 52 : &&
10990 : 52 : (a = bitwise_or_rule(p)) // bitwise_or
10991 : : )
10992 : : {
10993 : : D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
10994 : 52 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10995 [ - + ]: 52 : if (_token == NULL) {
10996 : 0 : p->level--;
10997 : 0 : return NULL;
10998 : : }
10999 : 52 : int _end_lineno = _token->end_lineno;
11000 : : UNUSED(_end_lineno); // Only used by EXTRA macro
11001 : 52 : int _end_col_offset = _token->end_col_offset;
11002 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
11003 : 52 : _res = _PyAST_Starred ( a , Load , EXTRA );
11004 [ - + - - ]: 52 : if (_res == NULL && PyErr_Occurred()) {
11005 : 0 : p->error_indicator = 1;
11006 : 0 : p->level--;
11007 : 0 : return NULL;
11008 : : }
11009 : 52 : goto done;
11010 : : }
11011 : 3645171 : 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 [ - + ]: 3645171 : if (p->error_indicator) {
11017 : 0 : p->level--;
11018 : 0 : 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 [ + + ]: 3645171 : if (
11023 : 3645171 : (expression_var = expression_rule(p)) // expression
11024 : : )
11025 : : {
11026 : : D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
11027 : 2122424 : _res = expression_var;
11028 : 2122424 : goto done;
11029 : : }
11030 : 1522747 : 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 : 1522747 : _res = NULL;
11035 : 3645223 : done:
11036 : 3645223 : _PyPegen_insert_memo(p, _mark, star_expression_type, _res);
11037 : 3645223 : p->level--;
11038 : 3645223 : return _res;
11039 : : }
11040 : :
11041 : : // star_named_expressions: ','.star_named_expression+ ','?
11042 : : static asdl_expr_seq*
11043 : 823470 : star_named_expressions_rule(Parser *p)
11044 : : {
11045 [ - + ]: 823470 : if (p->level++ == MAXSTACK) {
11046 : 0 : p->error_indicator = 1;
11047 : : PyErr_NoMemory();
11048 : : }
11049 [ - + ]: 823470 : if (p->error_indicator) {
11050 : 0 : p->level--;
11051 : 0 : return NULL;
11052 : : }
11053 : 823470 : asdl_expr_seq* _res = NULL;
11054 : 823470 : int _mark = p->mark;
11055 : : { // ','.star_named_expression+ ','?
11056 [ - + ]: 823470 : if (p->error_indicator) {
11057 : 0 : p->level--;
11058 : 0 : 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 [ + + ]: 823470 : if (
11065 : 823470 : (a = (asdl_expr_seq*)_gather_82_rule(p)) // ','.star_named_expression+
11066 : 648263 : &&
11067 [ + + ]: 648263 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
11068 : : )
11069 : : {
11070 : : D(fprintf(stderr, "%*c+ star_named_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?"));
11071 : 648236 : _res = a;
11072 [ - + - - ]: 648236 : if (_res == NULL && PyErr_Occurred()) {
11073 : 0 : p->error_indicator = 1;
11074 : 0 : p->level--;
11075 : 0 : return NULL;
11076 : : }
11077 : 648236 : goto done;
11078 : : }
11079 : 175234 : 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 : 175234 : _res = NULL;
11084 : 823470 : done:
11085 : 823470 : p->level--;
11086 : 823470 : return _res;
11087 : : }
11088 : :
11089 : : // star_named_expression: '*' bitwise_or | named_expression
11090 : : static expr_ty
11091 : 4663594 : star_named_expression_rule(Parser *p)
11092 : : {
11093 [ - + ]: 4663594 : if (p->level++ == MAXSTACK) {
11094 : 0 : p->error_indicator = 1;
11095 : : PyErr_NoMemory();
11096 : : }
11097 [ - + ]: 4663594 : if (p->error_indicator) {
11098 : 0 : p->level--;
11099 : 0 : return NULL;
11100 : : }
11101 : 4663594 : expr_ty _res = NULL;
11102 : 4663594 : int _mark = p->mark;
11103 [ + + + + ]: 4663594 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11104 : 44 : p->error_indicator = 1;
11105 : 44 : p->level--;
11106 : 44 : return NULL;
11107 : : }
11108 : 4663550 : int _start_lineno = p->tokens[_mark]->lineno;
11109 : : UNUSED(_start_lineno); // Only used by EXTRA macro
11110 : 4663550 : int _start_col_offset = p->tokens[_mark]->col_offset;
11111 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
11112 : : { // '*' bitwise_or
11113 [ - + ]: 4663550 : if (p->error_indicator) {
11114 : 0 : p->level--;
11115 : 0 : 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 [ + + ]: 4663550 : if (
11121 : 4663550 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
11122 [ + + ]: 2658 : &&
11123 : 2658 : (a = bitwise_or_rule(p)) // bitwise_or
11124 : : )
11125 : : {
11126 : : D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
11127 : 2633 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11128 [ - + ]: 2633 : if (_token == NULL) {
11129 : 0 : p->level--;
11130 : 0 : return NULL;
11131 : : }
11132 : 2633 : int _end_lineno = _token->end_lineno;
11133 : : UNUSED(_end_lineno); // Only used by EXTRA macro
11134 : 2633 : int _end_col_offset = _token->end_col_offset;
11135 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
11136 : 2633 : _res = _PyAST_Starred ( a , Load , EXTRA );
11137 [ - + - - ]: 2633 : if (_res == NULL && PyErr_Occurred()) {
11138 : 0 : p->error_indicator = 1;
11139 : 0 : p->level--;
11140 : 0 : return NULL;
11141 : : }
11142 : 2633 : goto done;
11143 : : }
11144 : 4660917 : 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 [ - + ]: 4660917 : if (p->error_indicator) {
11150 : 0 : p->level--;
11151 : 0 : 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 [ + + ]: 4660917 : if (
11156 : 4660917 : (named_expression_var = named_expression_rule(p)) // named_expression
11157 : : )
11158 : : {
11159 : : D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
11160 : 4438141 : _res = named_expression_var;
11161 : 4438141 : goto done;
11162 : : }
11163 : 222776 : 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 : 222776 : _res = NULL;
11168 : 4663550 : done:
11169 : 4663550 : p->level--;
11170 : 4663550 : return _res;
11171 : : }
11172 : :
11173 : : // assignment_expression: NAME ':=' ~ expression
11174 : : static expr_ty
11175 : 12858422 : assignment_expression_rule(Parser *p)
11176 : : {
11177 [ - + ]: 12858422 : if (p->level++ == MAXSTACK) {
11178 : 0 : p->error_indicator = 1;
11179 : : PyErr_NoMemory();
11180 : : }
11181 [ - + ]: 12858422 : if (p->error_indicator) {
11182 : 0 : p->level--;
11183 : 0 : return NULL;
11184 : : }
11185 : 12858422 : expr_ty _res = NULL;
11186 : 12858422 : int _mark = p->mark;
11187 [ + + + + ]: 12858422 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11188 : 15 : p->error_indicator = 1;
11189 : 15 : p->level--;
11190 : 15 : return NULL;
11191 : : }
11192 : 12858407 : int _start_lineno = p->tokens[_mark]->lineno;
11193 : : UNUSED(_start_lineno); // Only used by EXTRA macro
11194 : 12858407 : int _start_col_offset = p->tokens[_mark]->col_offset;
11195 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
11196 : : { // NAME ':=' ~ expression
11197 [ - + ]: 12858407 : if (p->error_indicator) {
11198 : 0 : p->level--;
11199 : 0 : return NULL;
11200 : : }
11201 : : D(fprintf(stderr, "%*c> assignment_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
11202 : 12858407 : int _cut_var = 0;
11203 : : Token * _literal;
11204 : : expr_ty a;
11205 : : expr_ty b;
11206 [ + + ]: 12858407 : if (
11207 : 12858407 : (a = _PyPegen_name_token(p)) // NAME
11208 [ + + ]: 5401052 : &&
11209 : 5401052 : (_literal = _PyPegen_expect_token(p, 53)) // token=':='
11210 : : &&
11211 : 3510 : (_cut_var = 1)
11212 [ + - ]: 3510 : &&
11213 : 3510 : (b = expression_rule(p)) // expression
11214 : : )
11215 : : {
11216 : : D(fprintf(stderr, "%*c+ assignment_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
11217 : 3510 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11218 [ - + ]: 3510 : if (_token == NULL) {
11219 : 0 : p->level--;
11220 : 0 : return NULL;
11221 : : }
11222 : 3510 : int _end_lineno = _token->end_lineno;
11223 : : UNUSED(_end_lineno); // Only used by EXTRA macro
11224 : 3510 : int _end_col_offset = _token->end_col_offset;
11225 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
11226 : 3510 : _res = CHECK_VERSION ( expr_ty , 8 , "Assignment expressions are" , _PyAST_NamedExpr ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA ) );
11227 [ + + + - ]: 3510 : if (_res == NULL && PyErr_Occurred()) {
11228 : 1 : p->error_indicator = 1;
11229 : 1 : p->level--;
11230 : 1 : return NULL;
11231 : : }
11232 : 3509 : goto done;
11233 : : }
11234 : 12854897 : 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 [ - + ]: 12854897 : if (_cut_var) {
11238 : 0 : p->level--;
11239 : 0 : return NULL;
11240 : : }
11241 : : }
11242 : 12854897 : _res = NULL;
11243 : 12858406 : done:
11244 : 12858406 : p->level--;
11245 : 12858406 : return _res;
11246 : : }
11247 : :
11248 : : // named_expression: assignment_expression | invalid_named_expression | expression !':='
11249 : : static expr_ty
11250 : 7026903 : named_expression_rule(Parser *p)
11251 : : {
11252 [ - + ]: 7026903 : if (p->level++ == MAXSTACK) {
11253 : 0 : p->error_indicator = 1;
11254 : : PyErr_NoMemory();
11255 : : }
11256 [ - + ]: 7026903 : if (p->error_indicator) {
11257 : 0 : p->level--;
11258 : 0 : return NULL;
11259 : : }
11260 : 7026903 : expr_ty _res = NULL;
11261 : 7026903 : int _mark = p->mark;
11262 : : { // assignment_expression
11263 [ - + ]: 7026903 : if (p->error_indicator) {
11264 : 0 : p->level--;
11265 : 0 : 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 [ + + ]: 7026903 : if (
11270 : 7026903 : (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
11271 : : )
11272 : : {
11273 : : D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
11274 : 3418 : _res = assignment_expression_var;
11275 : 3418 : goto done;
11276 : : }
11277 : 7023485 : 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 [ + + ]: 7023485 : if (p->call_invalid_rules) { // invalid_named_expression
11282 [ - + ]: 2435 : if (p->error_indicator) {
11283 : 0 : p->level--;
11284 : 0 : 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 [ - + ]: 2435 : if (
11289 : 2435 : (invalid_named_expression_var = invalid_named_expression_rule(p)) // invalid_named_expression
11290 : : )
11291 : : {
11292 : : D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_named_expression"));
11293 : 0 : _res = invalid_named_expression_var;
11294 : 0 : goto done;
11295 : : }
11296 : 2435 : 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 [ + + ]: 7023485 : if (p->error_indicator) {
11302 : 132 : p->level--;
11303 : 132 : 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 [ + + ]: 7023353 : if (
11308 : 7023353 : (expression_var = expression_rule(p)) // expression
11309 [ + + ]: 6796479 : &&
11310 : 6796479 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
11311 : : )
11312 : : {
11313 : : D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
11314 : 6796467 : _res = expression_var;
11315 : 6796467 : goto done;
11316 : : }
11317 : 226886 : 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 : 226886 : _res = NULL;
11322 : 7026771 : done:
11323 : 7026771 : p->level--;
11324 : 7026771 : return _res;
11325 : : }
11326 : :
11327 : : // disjunction: conjunction (('or' conjunction))+ | conjunction
11328 : : static expr_ty
11329 : 24010047 : disjunction_rule(Parser *p)
11330 : : {
11331 [ - + ]: 24010047 : if (p->level++ == MAXSTACK) {
11332 : 0 : p->error_indicator = 1;
11333 : : PyErr_NoMemory();
11334 : : }
11335 [ - + ]: 24010047 : if (p->error_indicator) {
11336 : 0 : p->level--;
11337 : 0 : return NULL;
11338 : : }
11339 : 24010047 : expr_ty _res = NULL;
11340 [ + + ]: 24010047 : if (_PyPegen_is_memoized(p, disjunction_type, &_res)) {
11341 : 12000545 : p->level--;
11342 : 12000545 : return _res;
11343 : : }
11344 : 12009502 : int _mark = p->mark;
11345 [ - + - - ]: 12009502 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11346 : 0 : p->error_indicator = 1;
11347 : 0 : p->level--;
11348 : 0 : return NULL;
11349 : : }
11350 : 12009502 : int _start_lineno = p->tokens[_mark]->lineno;
11351 : : UNUSED(_start_lineno); // Only used by EXTRA macro
11352 : 12009502 : int _start_col_offset = p->tokens[_mark]->col_offset;
11353 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
11354 : : { // conjunction (('or' conjunction))+
11355 [ - + ]: 12009502 : if (p->error_indicator) {
11356 : 0 : p->level--;
11357 : 0 : 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 [ + + ]: 12009502 : if (
11363 : 12009502 : (a = conjunction_rule(p)) // conjunction
11364 [ + + ]: 9717377 : &&
11365 : 9717377 : (b = _loop1_84_rule(p)) // (('or' conjunction))+
11366 : : )
11367 : : {
11368 : : D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+"));
11369 : 26126 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11370 [ - + ]: 26126 : if (_token == NULL) {
11371 : 0 : p->level--;
11372 : 0 : return NULL;
11373 : : }
11374 : 26126 : int _end_lineno = _token->end_lineno;
11375 : : UNUSED(_end_lineno); // Only used by EXTRA macro
11376 : 26126 : int _end_col_offset = _token->end_col_offset;
11377 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
11378 : 26126 : _res = _PyAST_BoolOp ( Or , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
11379 [ - + - - ]: 26126 : if (_res == NULL && PyErr_Occurred()) {
11380 : 0 : p->error_indicator = 1;
11381 : 0 : p->level--;
11382 : 0 : return NULL;
11383 : : }
11384 : 26126 : goto done;
11385 : : }
11386 : 11983376 : 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 [ + + ]: 11983376 : if (p->error_indicator) {
11392 : 851 : p->level--;
11393 : 851 : 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 [ + + ]: 11982525 : if (
11398 : 11982525 : (conjunction_var = conjunction_rule(p)) // conjunction
11399 : : )
11400 : : {
11401 : : D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction"));
11402 : 9691251 : _res = conjunction_var;
11403 : 9691251 : goto done;
11404 : : }
11405 : 2291274 : 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 : 2291274 : _res = NULL;
11410 : 12008651 : done:
11411 : 12008651 : _PyPegen_insert_memo(p, _mark, disjunction_type, _res);
11412 : 12008651 : p->level--;
11413 : 12008651 : return _res;
11414 : : }
11415 : :
11416 : : // conjunction: inversion (('and' inversion))+ | inversion
11417 : : static expr_ty
11418 : 24020892 : conjunction_rule(Parser *p)
11419 : : {
11420 [ - + ]: 24020892 : if (p->level++ == MAXSTACK) {
11421 : 0 : p->error_indicator = 1;
11422 : : PyErr_NoMemory();
11423 : : }
11424 [ - + ]: 24020892 : if (p->error_indicator) {
11425 : 0 : p->level--;
11426 : 0 : return NULL;
11427 : : }
11428 : 24020892 : expr_ty _res = NULL;
11429 [ + + ]: 24020892 : if (_PyPegen_is_memoized(p, conjunction_type, &_res)) {
11430 : 11982525 : p->level--;
11431 : 11982525 : return _res;
11432 : : }
11433 : 12038367 : int _mark = p->mark;
11434 [ - + - - ]: 12038367 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11435 : 0 : p->error_indicator = 1;
11436 : 0 : p->level--;
11437 : 0 : return NULL;
11438 : : }
11439 : 12038367 : int _start_lineno = p->tokens[_mark]->lineno;
11440 : : UNUSED(_start_lineno); // Only used by EXTRA macro
11441 : 12038367 : int _start_col_offset = p->tokens[_mark]->col_offset;
11442 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
11443 : : { // inversion (('and' inversion))+
11444 [ - + ]: 12038367 : if (p->error_indicator) {
11445 : 0 : p->level--;
11446 : 0 : 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 [ + + ]: 12038367 : if (
11452 : 12038367 : (a = inversion_rule(p)) // inversion
11453 [ + + ]: 9746242 : &&
11454 : 9746242 : (b = _loop1_85_rule(p)) // (('and' inversion))+
11455 : : )
11456 : : {
11457 : : D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+"));
11458 : 39064 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11459 [ - + ]: 39064 : if (_token == NULL) {
11460 : 0 : p->level--;
11461 : 0 : return NULL;
11462 : : }
11463 : 39064 : int _end_lineno = _token->end_lineno;
11464 : : UNUSED(_end_lineno); // Only used by EXTRA macro
11465 : 39064 : int _end_col_offset = _token->end_col_offset;
11466 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
11467 : 39064 : _res = _PyAST_BoolOp ( And , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
11468 [ - + - - ]: 39064 : if (_res == NULL && PyErr_Occurred()) {
11469 : 0 : p->error_indicator = 1;
11470 : 0 : p->level--;
11471 : 0 : return NULL;
11472 : : }
11473 : 39064 : goto done;
11474 : : }
11475 : 11999303 : 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 [ + + ]: 11999303 : if (p->error_indicator) {
11481 : 851 : p->level--;
11482 : 851 : 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 [ + + ]: 11998452 : if (
11487 : 11998452 : (inversion_var = inversion_rule(p)) // inversion
11488 : : )
11489 : : {
11490 : : D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion"));
11491 : 9707178 : _res = inversion_var;
11492 : 9707178 : goto done;
11493 : : }
11494 : 2291274 : 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 : 2291274 : _res = NULL;
11499 : 12037516 : done:
11500 : 12037516 : _PyPegen_insert_memo(p, _mark, conjunction_type, _res);
11501 : 12037516 : p->level--;
11502 : 12037516 : return _res;
11503 : : }
11504 : :
11505 : : // inversion: 'not' inversion | comparison
11506 : : static expr_ty
11507 : 24139599 : inversion_rule(Parser *p)
11508 : : {
11509 [ - + ]: 24139599 : if (p->level++ == MAXSTACK) {
11510 : 0 : p->error_indicator = 1;
11511 : : PyErr_NoMemory();
11512 : : }
11513 [ - + ]: 24139599 : if (p->error_indicator) {
11514 : 0 : p->level--;
11515 : 0 : return NULL;
11516 : : }
11517 : 24139599 : expr_ty _res = NULL;
11518 [ + + ]: 24139599 : if (_PyPegen_is_memoized(p, inversion_type, &_res)) {
11519 : 11998452 : p->level--;
11520 : 11998452 : return _res;
11521 : : }
11522 : 12141147 : int _mark = p->mark;
11523 [ - + - - ]: 12141147 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11524 : 0 : p->error_indicator = 1;
11525 : 0 : p->level--;
11526 : 0 : return NULL;
11527 : : }
11528 : 12141147 : int _start_lineno = p->tokens[_mark]->lineno;
11529 : : UNUSED(_start_lineno); // Only used by EXTRA macro
11530 : 12141147 : int _start_col_offset = p->tokens[_mark]->col_offset;
11531 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
11532 : : { // 'not' inversion
11533 [ - + ]: 12141147 : if (p->error_indicator) {
11534 : 0 : p->level--;
11535 : 0 : 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 [ + + ]: 12141147 : if (
11541 : 12141147 : (_keyword = _PyPegen_expect_token(p, 581)) // token='not'
11542 [ + + ]: 56887 : &&
11543 : 56887 : (a = inversion_rule(p)) // inversion
11544 : : )
11545 : : {
11546 : : D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
11547 : 56885 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11548 [ - + ]: 56885 : if (_token == NULL) {
11549 : 0 : p->level--;
11550 : 0 : return NULL;
11551 : : }
11552 : 56885 : int _end_lineno = _token->end_lineno;
11553 : : UNUSED(_end_lineno); // Only used by EXTRA macro
11554 : 56885 : int _end_col_offset = _token->end_col_offset;
11555 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
11556 : 56885 : _res = _PyAST_UnaryOp ( Not , a , EXTRA );
11557 [ - + - - ]: 56885 : if (_res == NULL && PyErr_Occurred()) {
11558 : 0 : p->error_indicator = 1;
11559 : 0 : p->level--;
11560 : 0 : return NULL;
11561 : : }
11562 : 56885 : goto done;
11563 : : }
11564 : 12084262 : 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 [ - + ]: 12084262 : if (p->error_indicator) {
11570 : 0 : p->level--;
11571 : 0 : 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 [ + + ]: 12084262 : if (
11576 : 12084262 : (comparison_var = comparison_rule(p)) // comparison
11577 : : )
11578 : : {
11579 : : D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "comparison"));
11580 : 9792135 : _res = comparison_var;
11581 : 9792135 : goto done;
11582 : : }
11583 : 2292127 : 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 : 2292127 : _res = NULL;
11588 : 12141147 : done:
11589 : 12141147 : _PyPegen_insert_memo(p, _mark, inversion_type, _res);
11590 : 12141147 : p->level--;
11591 : 12141147 : return _res;
11592 : : }
11593 : :
11594 : : // comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or
11595 : : static expr_ty
11596 : 12084262 : comparison_rule(Parser *p)
11597 : : {
11598 [ - + ]: 12084262 : if (p->level++ == MAXSTACK) {
11599 : 0 : p->error_indicator = 1;
11600 : : PyErr_NoMemory();
11601 : : }
11602 [ - + ]: 12084262 : if (p->error_indicator) {
11603 : 0 : p->level--;
11604 : 0 : return NULL;
11605 : : }
11606 : 12084262 : expr_ty _res = NULL;
11607 : 12084262 : int _mark = p->mark;
11608 [ - + - - ]: 12084262 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11609 : 0 : p->error_indicator = 1;
11610 : 0 : p->level--;
11611 : 0 : return NULL;
11612 : : }
11613 : 12084262 : int _start_lineno = p->tokens[_mark]->lineno;
11614 : : UNUSED(_start_lineno); // Only used by EXTRA macro
11615 : 12084262 : 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 [ - + ]: 12084262 : if (p->error_indicator) {
11619 : 0 : p->level--;
11620 : 0 : 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 [ + + ]: 12084262 : if (
11626 : 12084262 : (a = bitwise_or_rule(p)) // bitwise_or
11627 [ + + ]: 9792136 : &&
11628 : 9792136 : (b = _loop1_86_rule(p)) // compare_op_bitwise_or_pair+
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 : 241766 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11633 [ - + ]: 241766 : if (_token == NULL) {
11634 : 0 : p->level--;
11635 : 0 : return NULL;
11636 : : }
11637 : 241766 : int _end_lineno = _token->end_lineno;
11638 : : UNUSED(_end_lineno); // Only used by EXTRA macro
11639 : 241766 : int _end_col_offset = _token->end_col_offset;
11640 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
11641 : 241766 : _res = _PyAST_Compare ( a , CHECK ( asdl_int_seq* , _PyPegen_get_cmpops ( p , b ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_exprs ( p , b ) ) , EXTRA );
11642 [ - + - - ]: 241766 : if (_res == NULL && PyErr_Occurred()) {
11643 : 0 : p->error_indicator = 1;
11644 : 0 : p->level--;
11645 : 0 : return NULL;
11646 : : }
11647 : 241766 : goto done;
11648 : : }
11649 : 11842496 : 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 [ + + ]: 11842496 : if (p->error_indicator) {
11655 : 851 : p->level--;
11656 : 851 : 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 [ + + ]: 11841645 : if (
11661 : 11841645 : (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
11662 : : )
11663 : : {
11664 : : D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or"));
11665 : 9550369 : _res = bitwise_or_var;
11666 : 9550369 : goto done;
11667 : : }
11668 : 2291276 : 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 : 2291276 : _res = NULL;
11673 : 12083411 : done:
11674 : 12083411 : p->level--;
11675 : 12083411 : 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 : 10037237 : compare_op_bitwise_or_pair_rule(Parser *p)
11691 : : {
11692 [ - + ]: 10037237 : if (p->level++ == MAXSTACK) {
11693 : 0 : p->error_indicator = 1;
11694 : : PyErr_NoMemory();
11695 : : }
11696 [ - + ]: 10037237 : if (p->error_indicator) {
11697 : 0 : p->level--;
11698 : 0 : return NULL;
11699 : : }
11700 : 10037237 : CmpopExprPair* _res = NULL;
11701 : 10037237 : int _mark = p->mark;
11702 : : { // eq_bitwise_or
11703 [ - + ]: 10037237 : if (p->error_indicator) {
11704 : 0 : p->level--;
11705 : 0 : 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 [ + + ]: 10037237 : if (
11710 : 10037237 : (eq_bitwise_or_var = eq_bitwise_or_rule(p)) // eq_bitwise_or
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 : 71201 : _res = eq_bitwise_or_var;
11715 : 71201 : goto done;
11716 : : }
11717 : 9966036 : 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 [ - + ]: 9966036 : if (p->error_indicator) {
11723 : 0 : p->level--;
11724 : 0 : 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 [ + + ]: 9966036 : if (
11729 : 9966036 : (noteq_bitwise_or_var = noteq_bitwise_or_rule(p)) // noteq_bitwise_or
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 : 17554 : _res = noteq_bitwise_or_var;
11734 : 17554 : goto done;
11735 : : }
11736 : 9948482 : 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 [ + + ]: 9948482 : if (p->error_indicator) {
11742 : 1 : p->level--;
11743 : 1 : 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 [ + + ]: 9948481 : if (
11748 : 9948481 : (lte_bitwise_or_var = lte_bitwise_or_rule(p)) // lte_bitwise_or
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 : 8889 : _res = lte_bitwise_or_var;
11753 : 8889 : goto done;
11754 : : }
11755 : 9939592 : 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 [ - + ]: 9939592 : if (p->error_indicator) {
11761 : 0 : p->level--;
11762 : 0 : 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 [ + + ]: 9939592 : if (
11767 : 9939592 : (lt_bitwise_or_var = lt_bitwise_or_rule(p)) // lt_bitwise_or
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 : 15081 : _res = lt_bitwise_or_var;
11772 : 15081 : goto done;
11773 : : }
11774 : 9924511 : 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 [ - + ]: 9924511 : if (p->error_indicator) {
11780 : 0 : p->level--;
11781 : 0 : 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 [ + + ]: 9924511 : if (
11786 : 9924511 : (gte_bitwise_or_var = gte_bitwise_or_rule(p)) // gte_bitwise_or
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 : 8204 : _res = gte_bitwise_or_var;
11791 : 8204 : goto done;
11792 : : }
11793 : 9916307 : 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 [ - + ]: 9916307 : if (p->error_indicator) {
11799 : 0 : p->level--;
11800 : 0 : 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 [ + + ]: 9916307 : if (
11805 : 9916307 : (gt_bitwise_or_var = gt_bitwise_or_rule(p)) // gt_bitwise_or
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 : 13402 : _res = gt_bitwise_or_var;
11810 : 13402 : goto done;
11811 : : }
11812 : 9902905 : 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 [ - + ]: 9902905 : if (p->error_indicator) {
11818 : 0 : p->level--;
11819 : 0 : 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 [ + + ]: 9902905 : if (
11824 : 9902905 : (notin_bitwise_or_var = notin_bitwise_or_rule(p)) // notin_bitwise_or
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 : 10798 : _res = notin_bitwise_or_var;
11829 : 10798 : goto done;
11830 : : }
11831 : 9892107 : 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 [ - + ]: 9892107 : if (p->error_indicator) {
11837 : 0 : p->level--;
11838 : 0 : 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 [ + + ]: 9892107 : if (
11843 : 9892107 : (in_bitwise_or_var = in_bitwise_or_rule(p)) // in_bitwise_or
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 : 32047 : _res = in_bitwise_or_var;
11848 : 32047 : goto done;
11849 : : }
11850 : 9860060 : 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 [ - + ]: 9860060 : if (p->error_indicator) {
11856 : 0 : p->level--;
11857 : 0 : 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 [ + + ]: 9860060 : if (
11862 : 9860060 : (isnot_bitwise_or_var = isnot_bitwise_or_rule(p)) // isnot_bitwise_or
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 : 28341 : _res = isnot_bitwise_or_var;
11867 : 28341 : goto done;
11868 : : }
11869 : 9831719 : 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 [ - + ]: 9831719 : if (p->error_indicator) {
11875 : 0 : p->level--;
11876 : 0 : 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 [ + + ]: 9831719 : if (
11881 : 9831719 : (is_bitwise_or_var = is_bitwise_or_rule(p)) // is_bitwise_or
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 : 39584 : _res = is_bitwise_or_var;
11886 : 39584 : goto done;
11887 : : }
11888 : 9792135 : 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 : 9792135 : _res = NULL;
11893 : 10037236 : done:
11894 : 10037236 : p->level--;
11895 : 10037236 : return _res;
11896 : : }
11897 : :
11898 : : // eq_bitwise_or: '==' bitwise_or
11899 : : static CmpopExprPair*
11900 : 10037237 : eq_bitwise_or_rule(Parser *p)
11901 : : {
11902 [ - + ]: 10037237 : if (p->level++ == MAXSTACK) {
11903 : 0 : p->error_indicator = 1;
11904 : : PyErr_NoMemory();
11905 : : }
11906 [ - + ]: 10037237 : if (p->error_indicator) {
11907 : 0 : p->level--;
11908 : 0 : return NULL;
11909 : : }
11910 : 10037237 : CmpopExprPair* _res = NULL;
11911 : 10037237 : int _mark = p->mark;
11912 : : { // '==' bitwise_or
11913 [ - + ]: 10037237 : if (p->error_indicator) {
11914 : 0 : p->level--;
11915 : 0 : 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 [ + + ]: 10037237 : if (
11921 : 10037237 : (_literal = _PyPegen_expect_token(p, 27)) // token='=='
11922 [ + - ]: 71201 : &&
11923 : 71201 : (a = bitwise_or_rule(p)) // bitwise_or
11924 : : )
11925 : : {
11926 : : D(fprintf(stderr, "%*c+ eq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or"));
11927 : 71201 : _res = _PyPegen_cmpop_expr_pair ( p , Eq , a );
11928 [ - + - - ]: 71201 : if (_res == NULL && PyErr_Occurred()) {
11929 : 0 : p->error_indicator = 1;
11930 : 0 : p->level--;
11931 : 0 : return NULL;
11932 : : }
11933 : 71201 : goto done;
11934 : : }
11935 : 9966036 : 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 : 9966036 : _res = NULL;
11940 : 10037237 : done:
11941 : 10037237 : p->level--;
11942 : 10037237 : return _res;
11943 : : }
11944 : :
11945 : : // noteq_bitwise_or: ('!=') bitwise_or
11946 : : static CmpopExprPair*
11947 : 9966036 : noteq_bitwise_or_rule(Parser *p)
11948 : : {
11949 [ - + ]: 9966036 : if (p->level++ == MAXSTACK) {
11950 : 0 : p->error_indicator = 1;
11951 : : PyErr_NoMemory();
11952 : : }
11953 [ - + ]: 9966036 : if (p->error_indicator) {
11954 : 0 : p->level--;
11955 : 0 : return NULL;
11956 : : }
11957 : 9966036 : CmpopExprPair* _res = NULL;
11958 : 9966036 : int _mark = p->mark;
11959 : : { // ('!=') bitwise_or
11960 [ - + ]: 9966036 : if (p->error_indicator) {
11961 : 0 : p->level--;
11962 : 0 : 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 [ + + ]: 9966036 : if (
11968 : 9966036 : (_tmp_87_var = _tmp_87_rule(p)) // '!='
11969 [ + - ]: 17554 : &&
11970 : 17554 : (a = bitwise_or_rule(p)) // bitwise_or
11971 : : )
11972 : : {
11973 : : D(fprintf(stderr, "%*c+ noteq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or"));
11974 : 17554 : _res = _PyPegen_cmpop_expr_pair ( p , NotEq , a );
11975 [ - + - - ]: 17554 : if (_res == NULL && PyErr_Occurred()) {
11976 : 0 : p->error_indicator = 1;
11977 : 0 : p->level--;
11978 : 0 : return NULL;
11979 : : }
11980 : 17554 : goto done;
11981 : : }
11982 : 9948482 : 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 : 9948482 : _res = NULL;
11987 : 9966036 : done:
11988 : 9966036 : p->level--;
11989 : 9966036 : return _res;
11990 : : }
11991 : :
11992 : : // lte_bitwise_or: '<=' bitwise_or
11993 : : static CmpopExprPair*
11994 : 9948481 : lte_bitwise_or_rule(Parser *p)
11995 : : {
11996 [ - + ]: 9948481 : if (p->level++ == MAXSTACK) {
11997 : 0 : p->error_indicator = 1;
11998 : : PyErr_NoMemory();
11999 : : }
12000 [ - + ]: 9948481 : if (p->error_indicator) {
12001 : 0 : p->level--;
12002 : 0 : return NULL;
12003 : : }
12004 : 9948481 : CmpopExprPair* _res = NULL;
12005 : 9948481 : int _mark = p->mark;
12006 : : { // '<=' bitwise_or
12007 [ - + ]: 9948481 : if (p->error_indicator) {
12008 : 0 : p->level--;
12009 : 0 : 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 [ + + ]: 9948481 : if (
12015 : 9948481 : (_literal = _PyPegen_expect_token(p, 29)) // token='<='
12016 [ + - ]: 8889 : &&
12017 : 8889 : (a = bitwise_or_rule(p)) // bitwise_or
12018 : : )
12019 : : {
12020 : : D(fprintf(stderr, "%*c+ lte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or"));
12021 : 8889 : _res = _PyPegen_cmpop_expr_pair ( p , LtE , a );
12022 [ - + - - ]: 8889 : if (_res == NULL && PyErr_Occurred()) {
12023 : 0 : p->error_indicator = 1;
12024 : 0 : p->level--;
12025 : 0 : return NULL;
12026 : : }
12027 : 8889 : goto done;
12028 : : }
12029 : 9939592 : 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 : 9939592 : _res = NULL;
12034 : 9948481 : done:
12035 : 9948481 : p->level--;
12036 : 9948481 : return _res;
12037 : : }
12038 : :
12039 : : // lt_bitwise_or: '<' bitwise_or
12040 : : static CmpopExprPair*
12041 : 9939592 : lt_bitwise_or_rule(Parser *p)
12042 : : {
12043 [ - + ]: 9939592 : if (p->level++ == MAXSTACK) {
12044 : 0 : p->error_indicator = 1;
12045 : : PyErr_NoMemory();
12046 : : }
12047 [ - + ]: 9939592 : if (p->error_indicator) {
12048 : 0 : p->level--;
12049 : 0 : return NULL;
12050 : : }
12051 : 9939592 : CmpopExprPair* _res = NULL;
12052 : 9939592 : int _mark = p->mark;
12053 : : { // '<' bitwise_or
12054 [ - + ]: 9939592 : if (p->error_indicator) {
12055 : 0 : p->level--;
12056 : 0 : 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 [ + + ]: 9939592 : if (
12062 : 9939592 : (_literal = _PyPegen_expect_token(p, 20)) // token='<'
12063 [ + - ]: 15081 : &&
12064 : 15081 : (a = bitwise_or_rule(p)) // bitwise_or
12065 : : )
12066 : : {
12067 : : D(fprintf(stderr, "%*c+ lt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or"));
12068 : 15081 : _res = _PyPegen_cmpop_expr_pair ( p , Lt , a );
12069 [ - + - - ]: 15081 : if (_res == NULL && PyErr_Occurred()) {
12070 : 0 : p->error_indicator = 1;
12071 : 0 : p->level--;
12072 : 0 : return NULL;
12073 : : }
12074 : 15081 : goto done;
12075 : : }
12076 : 9924511 : 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 : 9924511 : _res = NULL;
12081 : 9939592 : done:
12082 : 9939592 : p->level--;
12083 : 9939592 : return _res;
12084 : : }
12085 : :
12086 : : // gte_bitwise_or: '>=' bitwise_or
12087 : : static CmpopExprPair*
12088 : 9924511 : gte_bitwise_or_rule(Parser *p)
12089 : : {
12090 [ - + ]: 9924511 : if (p->level++ == MAXSTACK) {
12091 : 0 : p->error_indicator = 1;
12092 : : PyErr_NoMemory();
12093 : : }
12094 [ - + ]: 9924511 : if (p->error_indicator) {
12095 : 0 : p->level--;
12096 : 0 : return NULL;
12097 : : }
12098 : 9924511 : CmpopExprPair* _res = NULL;
12099 : 9924511 : int _mark = p->mark;
12100 : : { // '>=' bitwise_or
12101 [ - + ]: 9924511 : if (p->error_indicator) {
12102 : 0 : p->level--;
12103 : 0 : 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 [ + + ]: 9924511 : if (
12109 : 9924511 : (_literal = _PyPegen_expect_token(p, 30)) // token='>='
12110 [ + - ]: 8204 : &&
12111 : 8204 : (a = bitwise_or_rule(p)) // bitwise_or
12112 : : )
12113 : : {
12114 : : D(fprintf(stderr, "%*c+ gte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or"));
12115 : 8204 : _res = _PyPegen_cmpop_expr_pair ( p , GtE , a );
12116 [ - + - - ]: 8204 : if (_res == NULL && PyErr_Occurred()) {
12117 : 0 : p->error_indicator = 1;
12118 : 0 : p->level--;
12119 : 0 : return NULL;
12120 : : }
12121 : 8204 : goto done;
12122 : : }
12123 : 9916307 : 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 : 9916307 : _res = NULL;
12128 : 9924511 : done:
12129 : 9924511 : p->level--;
12130 : 9924511 : return _res;
12131 : : }
12132 : :
12133 : : // gt_bitwise_or: '>' bitwise_or
12134 : : static CmpopExprPair*
12135 : 9916307 : gt_bitwise_or_rule(Parser *p)
12136 : : {
12137 [ - + ]: 9916307 : if (p->level++ == MAXSTACK) {
12138 : 0 : p->error_indicator = 1;
12139 : : PyErr_NoMemory();
12140 : : }
12141 [ - + ]: 9916307 : if (p->error_indicator) {
12142 : 0 : p->level--;
12143 : 0 : return NULL;
12144 : : }
12145 : 9916307 : CmpopExprPair* _res = NULL;
12146 : 9916307 : int _mark = p->mark;
12147 : : { // '>' bitwise_or
12148 [ - + ]: 9916307 : if (p->error_indicator) {
12149 : 0 : p->level--;
12150 : 0 : 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 [ + + ]: 9916307 : if (
12156 : 9916307 : (_literal = _PyPegen_expect_token(p, 21)) // token='>'
12157 [ + - ]: 13402 : &&
12158 : 13402 : (a = bitwise_or_rule(p)) // bitwise_or
12159 : : )
12160 : : {
12161 : : D(fprintf(stderr, "%*c+ gt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or"));
12162 : 13402 : _res = _PyPegen_cmpop_expr_pair ( p , Gt , a );
12163 [ - + - - ]: 13402 : if (_res == NULL && PyErr_Occurred()) {
12164 : 0 : p->error_indicator = 1;
12165 : 0 : p->level--;
12166 : 0 : return NULL;
12167 : : }
12168 : 13402 : goto done;
12169 : : }
12170 : 9902905 : 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 : 9902905 : _res = NULL;
12175 : 9916307 : done:
12176 : 9916307 : p->level--;
12177 : 9916307 : return _res;
12178 : : }
12179 : :
12180 : : // notin_bitwise_or: 'not' 'in' bitwise_or
12181 : : static CmpopExprPair*
12182 : 9902905 : notin_bitwise_or_rule(Parser *p)
12183 : : {
12184 [ - + ]: 9902905 : if (p->level++ == MAXSTACK) {
12185 : 0 : p->error_indicator = 1;
12186 : : PyErr_NoMemory();
12187 : : }
12188 [ - + ]: 9902905 : if (p->error_indicator) {
12189 : 0 : p->level--;
12190 : 0 : return NULL;
12191 : : }
12192 : 9902905 : CmpopExprPair* _res = NULL;
12193 : 9902905 : int _mark = p->mark;
12194 : : { // 'not' 'in' bitwise_or
12195 [ - + ]: 9902905 : if (p->error_indicator) {
12196 : 0 : p->level--;
12197 : 0 : 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 [ + + ]: 9902905 : if (
12204 : 9902905 : (_keyword = _PyPegen_expect_token(p, 581)) // token='not'
12205 [ + - ]: 10798 : &&
12206 : 10798 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
12207 [ + - ]: 10798 : &&
12208 : 10798 : (a = bitwise_or_rule(p)) // bitwise_or
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 : 10798 : _res = _PyPegen_cmpop_expr_pair ( p , NotIn , a );
12213 [ - + - - ]: 10798 : if (_res == NULL && PyErr_Occurred()) {
12214 : 0 : p->error_indicator = 1;
12215 : 0 : p->level--;
12216 : 0 : return NULL;
12217 : : }
12218 : 10798 : goto done;
12219 : : }
12220 : 9892107 : 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 : 9892107 : _res = NULL;
12225 : 9902905 : done:
12226 : 9902905 : p->level--;
12227 : 9902905 : return _res;
12228 : : }
12229 : :
12230 : : // in_bitwise_or: 'in' bitwise_or
12231 : : static CmpopExprPair*
12232 : 9892107 : in_bitwise_or_rule(Parser *p)
12233 : : {
12234 [ - + ]: 9892107 : if (p->level++ == MAXSTACK) {
12235 : 0 : p->error_indicator = 1;
12236 : : PyErr_NoMemory();
12237 : : }
12238 [ - + ]: 9892107 : if (p->error_indicator) {
12239 : 0 : p->level--;
12240 : 0 : return NULL;
12241 : : }
12242 : 9892107 : CmpopExprPair* _res = NULL;
12243 : 9892107 : int _mark = p->mark;
12244 : : { // 'in' bitwise_or
12245 [ - + ]: 9892107 : if (p->error_indicator) {
12246 : 0 : p->level--;
12247 : 0 : 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 [ + + ]: 9892107 : if (
12253 : 9892107 : (_keyword = _PyPegen_expect_token(p, 643)) // token='in'
12254 [ + - ]: 32047 : &&
12255 : 32047 : (a = bitwise_or_rule(p)) // bitwise_or
12256 : : )
12257 : : {
12258 : : D(fprintf(stderr, "%*c+ in_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or"));
12259 : 32047 : _res = _PyPegen_cmpop_expr_pair ( p , In , a );
12260 [ - + - - ]: 32047 : if (_res == NULL && PyErr_Occurred()) {
12261 : 0 : p->error_indicator = 1;
12262 : 0 : p->level--;
12263 : 0 : return NULL;
12264 : : }
12265 : 32047 : goto done;
12266 : : }
12267 : 9860060 : 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 : 9860060 : _res = NULL;
12272 : 9892107 : done:
12273 : 9892107 : p->level--;
12274 : 9892107 : return _res;
12275 : : }
12276 : :
12277 : : // isnot_bitwise_or: 'is' 'not' bitwise_or
12278 : : static CmpopExprPair*
12279 : 9860060 : isnot_bitwise_or_rule(Parser *p)
12280 : : {
12281 [ - + ]: 9860060 : if (p->level++ == MAXSTACK) {
12282 : 0 : p->error_indicator = 1;
12283 : : PyErr_NoMemory();
12284 : : }
12285 [ - + ]: 9860060 : if (p->error_indicator) {
12286 : 0 : p->level--;
12287 : 0 : return NULL;
12288 : : }
12289 : 9860060 : CmpopExprPair* _res = NULL;
12290 : 9860060 : int _mark = p->mark;
12291 : : { // 'is' 'not' bitwise_or
12292 [ - + ]: 9860060 : if (p->error_indicator) {
12293 : 0 : p->level--;
12294 : 0 : 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 [ + + ]: 9860060 : if (
12301 : 9860060 : (_keyword = _PyPegen_expect_token(p, 582)) // token='is'
12302 [ + + ]: 67925 : &&
12303 : 67925 : (_keyword_1 = _PyPegen_expect_token(p, 581)) // token='not'
12304 [ + - ]: 28341 : &&
12305 : 28341 : (a = bitwise_or_rule(p)) // bitwise_or
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 : 28341 : _res = _PyPegen_cmpop_expr_pair ( p , IsNot , a );
12310 [ - + - - ]: 28341 : if (_res == NULL && PyErr_Occurred()) {
12311 : 0 : p->error_indicator = 1;
12312 : 0 : p->level--;
12313 : 0 : return NULL;
12314 : : }
12315 : 28341 : goto done;
12316 : : }
12317 : 9831719 : 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 : 9831719 : _res = NULL;
12322 : 9860060 : done:
12323 : 9860060 : p->level--;
12324 : 9860060 : return _res;
12325 : : }
12326 : :
12327 : : // is_bitwise_or: 'is' bitwise_or
12328 : : static CmpopExprPair*
12329 : 9831719 : is_bitwise_or_rule(Parser *p)
12330 : : {
12331 [ - + ]: 9831719 : if (p->level++ == MAXSTACK) {
12332 : 0 : p->error_indicator = 1;
12333 : : PyErr_NoMemory();
12334 : : }
12335 [ - + ]: 9831719 : if (p->error_indicator) {
12336 : 0 : p->level--;
12337 : 0 : return NULL;
12338 : : }
12339 : 9831719 : CmpopExprPair* _res = NULL;
12340 : 9831719 : int _mark = p->mark;
12341 : : { // 'is' bitwise_or
12342 [ - + ]: 9831719 : if (p->error_indicator) {
12343 : 0 : p->level--;
12344 : 0 : 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 [ + + ]: 9831719 : if (
12350 : 9831719 : (_keyword = _PyPegen_expect_token(p, 582)) // token='is'
12351 [ + - ]: 39584 : &&
12352 : 39584 : (a = bitwise_or_rule(p)) // bitwise_or
12353 : : )
12354 : : {
12355 : : D(fprintf(stderr, "%*c+ is_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or"));
12356 : 39584 : _res = _PyPegen_cmpop_expr_pair ( p , Is , a );
12357 [ - + - - ]: 39584 : if (_res == NULL && PyErr_Occurred()) {
12358 : 0 : p->error_indicator = 1;
12359 : 0 : p->level--;
12360 : 0 : return NULL;
12361 : : }
12362 : 39584 : goto done;
12363 : : }
12364 : 9792135 : 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 : 9792135 : _res = NULL;
12369 : 9831719 : done:
12370 : 9831719 : p->level--;
12371 : 9831719 : 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 : 46557699 : bitwise_or_rule(Parser *p)
12379 : : {
12380 [ - + ]: 46557699 : if (p->level++ == MAXSTACK) {
12381 : 0 : p->error_indicator = 1;
12382 : : PyErr_NoMemory();
12383 : : }
12384 : 46557699 : expr_ty _res = NULL;
12385 [ + + ]: 46557699 : if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) {
12386 : 34225786 : p->level--;
12387 : 34225786 : return _res;
12388 : : }
12389 : 12331913 : int _mark = p->mark;
12390 : 12331913 : int _resmark = p->mark;
12391 : 10047751 : while (1) {
12392 : 22379664 : int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res);
12393 [ - + ]: 22379664 : if (tmpvar_2) {
12394 : 0 : p->level--;
12395 : 0 : return _res;
12396 : : }
12397 : 22379664 : p->mark = _mark;
12398 : 22379664 : void *_raw = bitwise_or_raw(p);
12399 [ + + ]: 22379664 : if (p->error_indicator) {
12400 : 850 : p->level--;
12401 : 850 : return NULL;
12402 : : }
12403 [ + + + + ]: 22378814 : if (_raw == NULL || p->mark <= _resmark)
12404 : : break;
12405 : 10047751 : _resmark = p->mark;
12406 : 10047751 : _res = _raw;
12407 : : }
12408 : 12331063 : p->mark = _resmark;
12409 : 12331063 : p->level--;
12410 : 12331063 : return _res;
12411 : : }
12412 : : static expr_ty
12413 : 22379664 : bitwise_or_raw(Parser *p)
12414 : : {
12415 [ - + ]: 22379664 : if (p->level++ == MAXSTACK) {
12416 : 0 : p->error_indicator = 1;
12417 : : PyErr_NoMemory();
12418 : : }
12419 [ - + ]: 22379664 : if (p->error_indicator) {
12420 : 0 : p->level--;
12421 : 0 : return NULL;
12422 : : }
12423 : 22379664 : expr_ty _res = NULL;
12424 : 22379664 : int _mark = p->mark;
12425 [ - + - - ]: 22379664 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
12426 : 0 : p->error_indicator = 1;
12427 : 0 : p->level--;
12428 : 0 : return NULL;
12429 : : }
12430 : 22379664 : int _start_lineno = p->tokens[_mark]->lineno;
12431 : : UNUSED(_start_lineno); // Only used by EXTRA macro
12432 : 22379664 : 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 [ - + ]: 22379664 : if (p->error_indicator) {
12436 : 0 : p->level--;
12437 : 0 : 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 [ + + ]: 22379664 : if (
12444 : 22379664 : (a = bitwise_or_rule(p)) // bitwise_or
12445 [ + + ]: 10047751 : &&
12446 : 10047751 : (_literal = _PyPegen_expect_token(p, 18)) // token='|'
12447 [ + + ]: 7968 : &&
12448 : 7968 : (b = bitwise_xor_rule(p)) // bitwise_xor
12449 : : )
12450 : : {
12451 : : D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor"));
12452 : 7964 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12453 [ - + ]: 7964 : if (_token == NULL) {
12454 : 0 : p->level--;
12455 : 0 : return NULL;
12456 : : }
12457 : 7964 : int _end_lineno = _token->end_lineno;
12458 : : UNUSED(_end_lineno); // Only used by EXTRA macro
12459 : 7964 : int _end_col_offset = _token->end_col_offset;
12460 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
12461 : 7964 : _res = _PyAST_BinOp ( a , BitOr , b , EXTRA );
12462 [ - + - - ]: 7964 : if (_res == NULL && PyErr_Occurred()) {
12463 : 0 : p->error_indicator = 1;
12464 : 0 : p->level--;
12465 : 0 : return NULL;
12466 : : }
12467 : 7964 : goto done;
12468 : : }
12469 : 22371700 : 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 [ - + ]: 22371700 : if (p->error_indicator) {
12475 : 0 : p->level--;
12476 : 0 : 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 [ + + ]: 22371700 : if (
12481 : 22371700 : (bitwise_xor_var = bitwise_xor_rule(p)) // bitwise_xor
12482 : : )
12483 : : {
12484 : : D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));
12485 : 20079574 : _res = bitwise_xor_var;
12486 : 20079574 : goto done;
12487 : : }
12488 : 2292126 : 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 : 2292126 : _res = NULL;
12493 : 22379664 : done:
12494 : 22379664 : p->level--;
12495 : 22379664 : 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 : 44768314 : bitwise_xor_rule(Parser *p)
12503 : : {
12504 [ - + ]: 44768314 : if (p->level++ == MAXSTACK) {
12505 : 0 : p->error_indicator = 1;
12506 : : PyErr_NoMemory();
12507 : : }
12508 : 44768314 : expr_ty _res = NULL;
12509 [ + + ]: 44768314 : if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) {
12510 : 32428433 : p->level--;
12511 : 32428433 : return _res;
12512 : : }
12513 : 12339881 : int _mark = p->mark;
12514 : 12339881 : int _resmark = p->mark;
12515 : 10048765 : while (1) {
12516 : 22388646 : int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res);
12517 [ - + ]: 22388646 : if (tmpvar_3) {
12518 : 0 : p->level--;
12519 : 0 : return _res;
12520 : : }
12521 : 22388646 : p->mark = _mark;
12522 : 22388646 : void *_raw = bitwise_xor_raw(p);
12523 [ + + ]: 22388646 : if (p->error_indicator) {
12524 : 850 : p->level--;
12525 : 850 : return NULL;
12526 : : }
12527 [ + + + + ]: 22387796 : if (_raw == NULL || p->mark <= _resmark)
12528 : : break;
12529 : 10048765 : _resmark = p->mark;
12530 : 10048765 : _res = _raw;
12531 : : }
12532 : 12339031 : p->mark = _resmark;
12533 : 12339031 : p->level--;
12534 : 12339031 : return _res;
12535 : : }
12536 : : static expr_ty
12537 : 22388646 : bitwise_xor_raw(Parser *p)
12538 : : {
12539 [ - + ]: 22388646 : if (p->level++ == MAXSTACK) {
12540 : 0 : p->error_indicator = 1;
12541 : : PyErr_NoMemory();
12542 : : }
12543 [ - + ]: 22388646 : if (p->error_indicator) {
12544 : 0 : p->level--;
12545 : 0 : return NULL;
12546 : : }
12547 : 22388646 : expr_ty _res = NULL;
12548 : 22388646 : int _mark = p->mark;
12549 [ - + - - ]: 22388646 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
12550 : 0 : p->error_indicator = 1;
12551 : 0 : p->level--;
12552 : 0 : return NULL;
12553 : : }
12554 : 22388646 : int _start_lineno = p->tokens[_mark]->lineno;
12555 : : UNUSED(_start_lineno); // Only used by EXTRA macro
12556 : 22388646 : 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 [ - + ]: 22388646 : if (p->error_indicator) {
12560 : 0 : p->level--;
12561 : 0 : 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 [ + + ]: 22388646 : if (
12568 : 22388646 : (a = bitwise_xor_rule(p)) // bitwise_xor
12569 [ + + ]: 10048765 : &&
12570 : 10048765 : (_literal = _PyPegen_expect_token(p, 32)) // token='^'
12571 [ + - ]: 1014 : &&
12572 : 1014 : (b = bitwise_and_rule(p)) // bitwise_and
12573 : : )
12574 : : {
12575 : : D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and"));
12576 : 1014 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12577 [ - + ]: 1014 : if (_token == NULL) {
12578 : 0 : p->level--;
12579 : 0 : return NULL;
12580 : : }
12581 : 1014 : int _end_lineno = _token->end_lineno;
12582 : : UNUSED(_end_lineno); // Only used by EXTRA macro
12583 : 1014 : int _end_col_offset = _token->end_col_offset;
12584 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
12585 : 1014 : _res = _PyAST_BinOp ( a , BitXor , b , EXTRA );
12586 [ - + - - ]: 1014 : if (_res == NULL && PyErr_Occurred()) {
12587 : 0 : p->error_indicator = 1;
12588 : 0 : p->level--;
12589 : 0 : return NULL;
12590 : : }
12591 : 1014 : goto done;
12592 : : }
12593 : 22387632 : 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 [ - + ]: 22387632 : if (p->error_indicator) {
12599 : 0 : p->level--;
12600 : 0 : 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 [ + + ]: 22387632 : if (
12605 : 22387632 : (bitwise_and_var = bitwise_and_rule(p)) // bitwise_and
12606 : : )
12607 : : {
12608 : : D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and"));
12609 : 20095502 : _res = bitwise_and_var;
12610 : 20095502 : goto done;
12611 : : }
12612 : 2292130 : 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 : 2292130 : _res = NULL;
12617 : 22388646 : done:
12618 : 22388646 : p->level--;
12619 : 22388646 : 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 : 44784691 : bitwise_and_rule(Parser *p)
12627 : : {
12628 [ - + ]: 44784691 : if (p->level++ == MAXSTACK) {
12629 : 0 : p->error_indicator = 1;
12630 : : PyErr_NoMemory();
12631 : : }
12632 : 44784691 : expr_ty _res = NULL;
12633 [ + + ]: 44784691 : if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) {
12634 : 32443796 : p->level--;
12635 : 32443796 : return _res;
12636 : : }
12637 : 12340895 : int _mark = p->mark;
12638 : 12340895 : int _resmark = p->mark;
12639 : 10055150 : while (1) {
12640 : 22396045 : int tmpvar_4 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res);
12641 [ - + ]: 22396045 : if (tmpvar_4) {
12642 : 0 : p->level--;
12643 : 0 : return _res;
12644 : : }
12645 : 22396045 : p->mark = _mark;
12646 : 22396045 : void *_raw = bitwise_and_raw(p);
12647 [ + + ]: 22396045 : if (p->error_indicator) {
12648 : 850 : p->level--;
12649 : 850 : return NULL;
12650 : : }
12651 [ + + + + ]: 22395195 : if (_raw == NULL || p->mark <= _resmark)
12652 : : break;
12653 : 10055150 : _resmark = p->mark;
12654 : 10055150 : _res = _raw;
12655 : : }
12656 : 12340045 : p->mark = _resmark;
12657 : 12340045 : p->level--;
12658 : 12340045 : return _res;
12659 : : }
12660 : : static expr_ty
12661 : 22396045 : bitwise_and_raw(Parser *p)
12662 : : {
12663 [ - + ]: 22396045 : if (p->level++ == MAXSTACK) {
12664 : 0 : p->error_indicator = 1;
12665 : : PyErr_NoMemory();
12666 : : }
12667 [ - + ]: 22396045 : if (p->error_indicator) {
12668 : 0 : p->level--;
12669 : 0 : return NULL;
12670 : : }
12671 : 22396045 : expr_ty _res = NULL;
12672 : 22396045 : int _mark = p->mark;
12673 [ - + - - ]: 22396045 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
12674 : 0 : p->error_indicator = 1;
12675 : 0 : p->level--;
12676 : 0 : return NULL;
12677 : : }
12678 : 22396045 : int _start_lineno = p->tokens[_mark]->lineno;
12679 : : UNUSED(_start_lineno); // Only used by EXTRA macro
12680 : 22396045 : 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 [ - + ]: 22396045 : if (p->error_indicator) {
12684 : 0 : p->level--;
12685 : 0 : 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 [ + + ]: 22396045 : if (
12692 : 22396045 : (a = bitwise_and_rule(p)) // bitwise_and
12693 [ + + ]: 10055150 : &&
12694 : 10055150 : (_literal = _PyPegen_expect_token(p, 19)) // token='&'
12695 [ + - ]: 6385 : &&
12696 : 6385 : (b = shift_expr_rule(p)) // shift_expr
12697 : : )
12698 : : {
12699 : : D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr"));
12700 : 6385 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12701 [ - + ]: 6385 : if (_token == NULL) {
12702 : 0 : p->level--;
12703 : 0 : return NULL;
12704 : : }
12705 : 6385 : int _end_lineno = _token->end_lineno;
12706 : : UNUSED(_end_lineno); // Only used by EXTRA macro
12707 : 6385 : int _end_col_offset = _token->end_col_offset;
12708 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
12709 : 6385 : _res = _PyAST_BinOp ( a , BitAnd , b , EXTRA );
12710 [ - + - - ]: 6385 : if (_res == NULL && PyErr_Occurred()) {
12711 : 0 : p->error_indicator = 1;
12712 : 0 : p->level--;
12713 : 0 : return NULL;
12714 : : }
12715 : 6385 : goto done;
12716 : : }
12717 : 22389660 : 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 [ - + ]: 22389660 : if (p->error_indicator) {
12723 : 0 : p->level--;
12724 : 0 : 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 [ + + ]: 22389660 : if (
12729 : 22389660 : (shift_expr_var = shift_expr_rule(p)) // shift_expr
12730 : : )
12731 : : {
12732 : : D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr"));
12733 : 20097530 : _res = shift_expr_var;
12734 : 20097530 : goto done;
12735 : : }
12736 : 2292130 : 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 : 2292130 : _res = NULL;
12741 : 22396045 : done:
12742 : 22396045 : p->level--;
12743 : 22396045 : 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 : 67207102 : shift_expr_rule(Parser *p)
12751 : : {
12752 [ - + ]: 67207102 : if (p->level++ == MAXSTACK) {
12753 : 0 : p->error_indicator = 1;
12754 : : PyErr_NoMemory();
12755 : : }
12756 : 67207102 : expr_ty _res = NULL;
12757 [ + + ]: 67207102 : if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) {
12758 : 54859822 : p->level--;
12759 : 54859822 : return _res;
12760 : : }
12761 : 12347280 : int _mark = p->mark;
12762 : 12347280 : int _resmark = p->mark;
12763 : 10060012 : while (1) {
12764 : 22407292 : int tmpvar_5 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res);
12765 [ - + ]: 22407292 : if (tmpvar_5) {
12766 : 0 : p->level--;
12767 : 0 : return _res;
12768 : : }
12769 : 22407292 : p->mark = _mark;
12770 : 22407292 : void *_raw = shift_expr_raw(p);
12771 [ + + ]: 22407292 : if (p->error_indicator) {
12772 : 850 : p->level--;
12773 : 850 : return NULL;
12774 : : }
12775 [ + + + + ]: 22406442 : if (_raw == NULL || p->mark <= _resmark)
12776 : : break;
12777 : 10060012 : _resmark = p->mark;
12778 : 10060012 : _res = _raw;
12779 : : }
12780 : 12346430 : p->mark = _resmark;
12781 : 12346430 : p->level--;
12782 : 12346430 : return _res;
12783 : : }
12784 : : static expr_ty
12785 : 22407292 : shift_expr_raw(Parser *p)
12786 : : {
12787 [ - + ]: 22407292 : if (p->level++ == MAXSTACK) {
12788 : 0 : p->error_indicator = 1;
12789 : : PyErr_NoMemory();
12790 : : }
12791 [ - + ]: 22407292 : if (p->error_indicator) {
12792 : 0 : p->level--;
12793 : 0 : return NULL;
12794 : : }
12795 : 22407292 : expr_ty _res = NULL;
12796 : 22407292 : int _mark = p->mark;
12797 [ - + - - ]: 22407292 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
12798 : 0 : p->error_indicator = 1;
12799 : 0 : p->level--;
12800 : 0 : return NULL;
12801 : : }
12802 : 22407292 : int _start_lineno = p->tokens[_mark]->lineno;
12803 : : UNUSED(_start_lineno); // Only used by EXTRA macro
12804 : 22407292 : int _start_col_offset = p->tokens[_mark]->col_offset;
12805 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
12806 : : { // shift_expr '<<' sum
12807 [ - + ]: 22407292 : if (p->error_indicator) {
12808 : 0 : p->level--;
12809 : 0 : 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 [ + + ]: 22407292 : if (
12816 : 22407292 : (a = shift_expr_rule(p)) // shift_expr
12817 [ + + ]: 10060012 : &&
12818 : 10060012 : (_literal = _PyPegen_expect_token(p, 33)) // token='<<'
12819 [ + - ]: 3527 : &&
12820 : 3527 : (b = sum_rule(p)) // sum
12821 : : )
12822 : : {
12823 : : D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum"));
12824 : 3527 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12825 [ - + ]: 3527 : if (_token == NULL) {
12826 : 0 : p->level--;
12827 : 0 : return NULL;
12828 : : }
12829 : 3527 : int _end_lineno = _token->end_lineno;
12830 : : UNUSED(_end_lineno); // Only used by EXTRA macro
12831 : 3527 : int _end_col_offset = _token->end_col_offset;
12832 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
12833 : 3527 : _res = _PyAST_BinOp ( a , LShift , b , EXTRA );
12834 [ - + - - ]: 3527 : if (_res == NULL && PyErr_Occurred()) {
12835 : 0 : p->error_indicator = 1;
12836 : 0 : p->level--;
12837 : 0 : return NULL;
12838 : : }
12839 : 3527 : goto done;
12840 : : }
12841 : 22403765 : 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 [ - + ]: 22403765 : if (p->error_indicator) {
12847 : 0 : p->level--;
12848 : 0 : 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 [ + + ]: 22403765 : if (
12855 : 22403765 : (a = shift_expr_rule(p)) // shift_expr
12856 [ + + ]: 10056485 : &&
12857 : 10056485 : (_literal = _PyPegen_expect_token(p, 34)) // token='>>'
12858 [ + - ]: 1335 : &&
12859 : 1335 : (b = sum_rule(p)) // sum
12860 : : )
12861 : : {
12862 : : D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum"));
12863 : 1335 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12864 [ - + ]: 1335 : if (_token == NULL) {
12865 : 0 : p->level--;
12866 : 0 : return NULL;
12867 : : }
12868 : 1335 : int _end_lineno = _token->end_lineno;
12869 : : UNUSED(_end_lineno); // Only used by EXTRA macro
12870 : 1335 : int _end_col_offset = _token->end_col_offset;
12871 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
12872 : 1335 : _res = _PyAST_BinOp ( a , RShift , b , EXTRA );
12873 [ - + - - ]: 1335 : if (_res == NULL && PyErr_Occurred()) {
12874 : 0 : p->error_indicator = 1;
12875 : 0 : p->level--;
12876 : 0 : return NULL;
12877 : : }
12878 : 1335 : goto done;
12879 : : }
12880 : 22402430 : 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 [ - + ]: 22402430 : if (p->error_indicator) {
12886 : 0 : p->level--;
12887 : 0 : 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 [ + + ]: 22402430 : if (
12892 : 22402430 : (sum_var = sum_rule(p)) // sum
12893 : : )
12894 : : {
12895 : : D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum"));
12896 : 20110300 : _res = sum_var;
12897 : 20110300 : goto done;
12898 : : }
12899 : 2292130 : 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 : 2292130 : _res = NULL;
12904 : 22407292 : done:
12905 : 22407292 : p->level--;
12906 : 22407292 : 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 : 67423508 : sum_rule(Parser *p)
12914 : : {
12915 [ - + ]: 67423508 : if (p->level++ == MAXSTACK) {
12916 : 0 : p->error_indicator = 1;
12917 : : PyErr_NoMemory();
12918 : : }
12919 : 67423508 : expr_ty _res = NULL;
12920 [ + + ]: 67423508 : if (_PyPegen_is_memoized(p, sum_type, &_res)) {
12921 : 55071366 : p->level--;
12922 : 55071366 : return _res;
12923 : : }
12924 : 12352142 : int _mark = p->mark;
12925 : 12352142 : int _resmark = p->mark;
12926 : 10203014 : while (1) {
12927 : 22555156 : int tmpvar_6 = _PyPegen_update_memo(p, _mark, sum_type, _res);
12928 [ - + ]: 22555156 : if (tmpvar_6) {
12929 : 0 : p->level--;
12930 : 0 : return _res;
12931 : : }
12932 : 22555156 : p->mark = _mark;
12933 : 22555156 : void *_raw = sum_raw(p);
12934 [ + + ]: 22555156 : if (p->error_indicator) {
12935 : 850 : p->level--;
12936 : 850 : return NULL;
12937 : : }
12938 [ + + + + ]: 22554306 : if (_raw == NULL || p->mark <= _resmark)
12939 : : break;
12940 : 10203014 : _resmark = p->mark;
12941 : 10203014 : _res = _raw;
12942 : : }
12943 : 12351292 : p->mark = _resmark;
12944 : 12351292 : p->level--;
12945 : 12351292 : return _res;
12946 : : }
12947 : : static expr_ty
12948 : 22555156 : sum_raw(Parser *p)
12949 : : {
12950 [ - + ]: 22555156 : if (p->level++ == MAXSTACK) {
12951 : 0 : p->error_indicator = 1;
12952 : : PyErr_NoMemory();
12953 : : }
12954 [ - + ]: 22555156 : if (p->error_indicator) {
12955 : 0 : p->level--;
12956 : 0 : return NULL;
12957 : : }
12958 : 22555156 : expr_ty _res = NULL;
12959 : 22555156 : int _mark = p->mark;
12960 [ - + - - ]: 22555156 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
12961 : 0 : p->error_indicator = 1;
12962 : 0 : p->level--;
12963 : 0 : return NULL;
12964 : : }
12965 : 22555156 : int _start_lineno = p->tokens[_mark]->lineno;
12966 : : UNUSED(_start_lineno); // Only used by EXTRA macro
12967 : 22555156 : int _start_col_offset = p->tokens[_mark]->col_offset;
12968 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
12969 : : { // sum '+' term
12970 [ - + ]: 22555156 : if (p->error_indicator) {
12971 : 0 : p->level--;
12972 : 0 : 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 [ + + ]: 22555156 : if (
12979 : 22555156 : (a = sum_rule(p)) // sum
12980 [ + + ]: 10203014 : &&
12981 : 10203014 : (_literal = _PyPegen_expect_token(p, 14)) // token='+'
12982 [ + + ]: 94128 : &&
12983 : 94128 : (b = term_rule(p)) // term
12984 : : )
12985 : : {
12986 : : D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term"));
12987 : 94080 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12988 [ - + ]: 94080 : if (_token == NULL) {
12989 : 0 : p->level--;
12990 : 0 : return NULL;
12991 : : }
12992 : 94080 : int _end_lineno = _token->end_lineno;
12993 : : UNUSED(_end_lineno); // Only used by EXTRA macro
12994 : 94080 : int _end_col_offset = _token->end_col_offset;
12995 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
12996 : 94080 : _res = _PyAST_BinOp ( a , Add , b , EXTRA );
12997 [ - + - - ]: 94080 : if (_res == NULL && PyErr_Occurred()) {
12998 : 0 : p->error_indicator = 1;
12999 : 0 : p->level--;
13000 : 0 : return NULL;
13001 : : }
13002 : 94080 : goto done;
13003 : : }
13004 : 22461076 : 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 [ + + ]: 22461076 : if (p->error_indicator) {
13010 : 16 : p->level--;
13011 : 16 : 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 [ + + ]: 22461060 : if (
13018 : 22461060 : (a = sum_rule(p)) // sum
13019 [ + + ]: 10108918 : &&
13020 : 10108918 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
13021 [ + + ]: 48906 : &&
13022 : 48906 : (b = term_rule(p)) // term
13023 : : )
13024 : : {
13025 : : D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term"));
13026 : 48905 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13027 [ - + ]: 48905 : if (_token == NULL) {
13028 : 0 : p->level--;
13029 : 0 : return NULL;
13030 : : }
13031 : 48905 : int _end_lineno = _token->end_lineno;
13032 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13033 : 48905 : int _end_col_offset = _token->end_col_offset;
13034 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13035 : 48905 : _res = _PyAST_BinOp ( a , Sub , b , EXTRA );
13036 [ - + - - ]: 48905 : if (_res == NULL && PyErr_Occurred()) {
13037 : 0 : p->error_indicator = 1;
13038 : 0 : p->level--;
13039 : 0 : return NULL;
13040 : : }
13041 : 48905 : goto done;
13042 : : }
13043 : 22412155 : 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 [ + + ]: 22412155 : if (p->error_indicator) {
13049 : 1 : p->level--;
13050 : 1 : 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 [ + + ]: 22412154 : if (
13055 : 22412154 : (term_var = term_rule(p)) // term
13056 : : )
13057 : : {
13058 : : D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term"));
13059 : 20120041 : _res = term_var;
13060 : 20120041 : goto done;
13061 : : }
13062 : 2292113 : 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 : 2292113 : _res = NULL;
13067 : 22555139 : done:
13068 : 22555139 : p->level--;
13069 : 22555139 : 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 : 136663092 : term_rule(Parser *p)
13083 : : {
13084 [ - + ]: 136663092 : if (p->level++ == MAXSTACK) {
13085 : 0 : p->error_indicator = 1;
13086 : : PyErr_NoMemory();
13087 : : }
13088 : 136663092 : expr_ty _res = NULL;
13089 [ + + ]: 136663092 : if (_PyPegen_is_memoized(p, term_type, &_res)) {
13090 : 124167927 : p->level--;
13091 : 124167927 : return _res;
13092 : : }
13093 : 12495165 : int _mark = p->mark;
13094 : 12495165 : int _resmark = p->mark;
13095 : 10609899 : while (1) {
13096 : 23105064 : int tmpvar_7 = _PyPegen_update_memo(p, _mark, term_type, _res);
13097 [ - + ]: 23105064 : if (tmpvar_7) {
13098 : 0 : p->level--;
13099 : 0 : return _res;
13100 : : }
13101 : 23105064 : p->mark = _mark;
13102 : 23105064 : void *_raw = term_raw(p);
13103 [ + + ]: 23105064 : if (p->error_indicator) {
13104 : 840 : p->level--;
13105 : 840 : return NULL;
13106 : : }
13107 [ + + + + ]: 23104224 : if (_raw == NULL || p->mark <= _resmark)
13108 : : break;
13109 : 10609899 : _resmark = p->mark;
13110 : 10609899 : _res = _raw;
13111 : : }
13112 : 12494325 : p->mark = _resmark;
13113 : 12494325 : p->level--;
13114 : 12494325 : return _res;
13115 : : }
13116 : : static expr_ty
13117 : 23105064 : term_raw(Parser *p)
13118 : : {
13119 [ - + ]: 23105064 : if (p->level++ == MAXSTACK) {
13120 : 0 : p->error_indicator = 1;
13121 : : PyErr_NoMemory();
13122 : : }
13123 [ - + ]: 23105064 : if (p->error_indicator) {
13124 : 0 : p->level--;
13125 : 0 : return NULL;
13126 : : }
13127 : 23105064 : expr_ty _res = NULL;
13128 : 23105064 : int _mark = p->mark;
13129 [ - + - - ]: 23105064 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13130 : 0 : p->error_indicator = 1;
13131 : 0 : p->level--;
13132 : 0 : return NULL;
13133 : : }
13134 : 23105064 : int _start_lineno = p->tokens[_mark]->lineno;
13135 : : UNUSED(_start_lineno); // Only used by EXTRA macro
13136 : 23105064 : int _start_col_offset = p->tokens[_mark]->col_offset;
13137 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
13138 : : { // term '*' factor
13139 [ - + ]: 23105064 : if (p->error_indicator) {
13140 : 0 : p->level--;
13141 : 0 : 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 [ + + ]: 23105064 : if (
13148 : 23105064 : (a = term_rule(p)) // term
13149 [ + + ]: 10609899 : &&
13150 : 10609899 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
13151 [ + - ]: 330923 : &&
13152 : 330923 : (b = factor_rule(p)) // factor
13153 : : )
13154 : : {
13155 : : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' factor"));
13156 : 330923 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13157 [ - + ]: 330923 : if (_token == NULL) {
13158 : 0 : p->level--;
13159 : 0 : return NULL;
13160 : : }
13161 : 330923 : int _end_lineno = _token->end_lineno;
13162 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13163 : 330923 : int _end_col_offset = _token->end_col_offset;
13164 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13165 : 330923 : _res = _PyAST_BinOp ( a , Mult , b , EXTRA );
13166 [ - + - - ]: 330923 : if (_res == NULL && PyErr_Occurred()) {
13167 : 0 : p->error_indicator = 1;
13168 : 0 : p->level--;
13169 : 0 : return NULL;
13170 : : }
13171 : 330923 : goto done;
13172 : : }
13173 : 22774141 : 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 [ - + ]: 22774141 : if (p->error_indicator) {
13179 : 0 : p->level--;
13180 : 0 : 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 [ + + ]: 22774141 : if (
13187 : 22774141 : (a = term_rule(p)) // term
13188 [ + + ]: 10278976 : &&
13189 : 10278976 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
13190 [ + + ]: 7193 : &&
13191 : 7193 : (b = factor_rule(p)) // factor
13192 : : )
13193 : : {
13194 : : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' factor"));
13195 : 7187 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13196 [ - + ]: 7187 : if (_token == NULL) {
13197 : 0 : p->level--;
13198 : 0 : return NULL;
13199 : : }
13200 : 7187 : int _end_lineno = _token->end_lineno;
13201 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13202 : 7187 : int _end_col_offset = _token->end_col_offset;
13203 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13204 : 7187 : _res = _PyAST_BinOp ( a , Div , b , EXTRA );
13205 [ - + - - ]: 7187 : if (_res == NULL && PyErr_Occurred()) {
13206 : 0 : p->error_indicator = 1;
13207 : 0 : p->level--;
13208 : 0 : return NULL;
13209 : : }
13210 : 7187 : goto done;
13211 : : }
13212 : 22766954 : 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 [ - + ]: 22766954 : if (p->error_indicator) {
13218 : 0 : p->level--;
13219 : 0 : 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 [ + + ]: 22766954 : if (
13226 : 22766954 : (a = term_rule(p)) // term
13227 [ + + ]: 10271789 : &&
13228 : 10271789 : (_literal = _PyPegen_expect_token(p, 47)) // token='//'
13229 [ + - ]: 3459 : &&
13230 : 3459 : (b = factor_rule(p)) // factor
13231 : : )
13232 : : {
13233 : : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' factor"));
13234 : 3459 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13235 [ - + ]: 3459 : if (_token == NULL) {
13236 : 0 : p->level--;
13237 : 0 : return NULL;
13238 : : }
13239 : 3459 : int _end_lineno = _token->end_lineno;
13240 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13241 : 3459 : int _end_col_offset = _token->end_col_offset;
13242 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13243 : 3459 : _res = _PyAST_BinOp ( a , FloorDiv , b , EXTRA );
13244 [ - + - - ]: 3459 : if (_res == NULL && PyErr_Occurred()) {
13245 : 0 : p->error_indicator = 1;
13246 : 0 : p->level--;
13247 : 0 : return NULL;
13248 : : }
13249 : 3459 : goto done;
13250 : : }
13251 : 22763495 : 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 [ - + ]: 22763495 : if (p->error_indicator) {
13257 : 0 : p->level--;
13258 : 0 : 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 [ + + ]: 22763495 : if (
13265 : 22763495 : (a = term_rule(p)) // term
13266 [ + + ]: 10268330 : &&
13267 : 10268330 : (_literal = _PyPegen_expect_token(p, 24)) // token='%'
13268 [ + - ]: 65245 : &&
13269 : 65245 : (b = factor_rule(p)) // factor
13270 : : )
13271 : : {
13272 : : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' factor"));
13273 : 65245 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13274 [ - + ]: 65245 : if (_token == NULL) {
13275 : 0 : p->level--;
13276 : 0 : return NULL;
13277 : : }
13278 : 65245 : int _end_lineno = _token->end_lineno;
13279 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13280 : 65245 : int _end_col_offset = _token->end_col_offset;
13281 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13282 : 65245 : _res = _PyAST_BinOp ( a , Mod , b , EXTRA );
13283 [ - + - - ]: 65245 : if (_res == NULL && PyErr_Occurred()) {
13284 : 0 : p->error_indicator = 1;
13285 : 0 : p->level--;
13286 : 0 : return NULL;
13287 : : }
13288 : 65245 : goto done;
13289 : : }
13290 : 22698250 : 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 [ - + ]: 22698250 : if (p->error_indicator) {
13296 : 0 : p->level--;
13297 : 0 : 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 [ + + ]: 22698250 : if (
13304 : 22698250 : (a = term_rule(p)) // term
13305 [ + + ]: 10203085 : &&
13306 : 10203085 : (_literal = _PyPegen_expect_token(p, 49)) // token='@'
13307 [ + + ]: 77 : &&
13308 : 77 : (b = factor_rule(p)) // factor
13309 : : )
13310 : : {
13311 : : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '@' factor"));
13312 : 72 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13313 [ - + ]: 72 : if (_token == NULL) {
13314 : 0 : p->level--;
13315 : 0 : return NULL;
13316 : : }
13317 : 72 : int _end_lineno = _token->end_lineno;
13318 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13319 : 72 : int _end_col_offset = _token->end_col_offset;
13320 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13321 : 72 : _res = CHECK_VERSION ( expr_ty , 5 , "The '@' operator is" , _PyAST_BinOp ( a , MatMult , b , EXTRA ) );
13322 [ + + + - ]: 72 : if (_res == NULL && PyErr_Occurred()) {
13323 : 1 : p->error_indicator = 1;
13324 : 1 : p->level--;
13325 : 1 : return NULL;
13326 : : }
13327 : 71 : goto done;
13328 : : }
13329 : 22698178 : 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 [ - + ]: 22698178 : if (p->error_indicator) {
13335 : 0 : p->level--;
13336 : 0 : 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 [ + + ]: 22698178 : if (
13341 : 22698178 : (factor_var = factor_rule(p)) // factor
13342 : : )
13343 : : {
13344 : : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "factor"));
13345 : 20406027 : _res = factor_var;
13346 : 20406027 : goto done;
13347 : : }
13348 : 2292151 : 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 : 2292151 : _res = NULL;
13353 : 23105063 : done:
13354 : 23105063 : p->level--;
13355 : 23105063 : return _res;
13356 : : }
13357 : :
13358 : : // factor: '+' factor | '-' factor | '~' factor | power
13359 : : static expr_ty
13360 : 23174052 : factor_rule(Parser *p)
13361 : : {
13362 [ + + ]: 23174052 : if (p->level++ == MAXSTACK) {
13363 : 3 : p->error_indicator = 1;
13364 : : PyErr_NoMemory();
13365 : : }
13366 [ + + ]: 23174052 : if (p->error_indicator) {
13367 : 3 : p->level--;
13368 : 3 : return NULL;
13369 : : }
13370 : 23174049 : expr_ty _res = NULL;
13371 [ + + ]: 23174049 : if (_PyPegen_is_memoized(p, factor_type, &_res)) {
13372 : 10203045 : p->level--;
13373 : 10203045 : return _res;
13374 : : }
13375 : 12971004 : int _mark = p->mark;
13376 [ - + - - ]: 12971004 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13377 : 0 : p->error_indicator = 1;
13378 : 0 : p->level--;
13379 : 0 : return NULL;
13380 : : }
13381 : 12971004 : int _start_lineno = p->tokens[_mark]->lineno;
13382 : : UNUSED(_start_lineno); // Only used by EXTRA macro
13383 : 12971004 : int _start_col_offset = p->tokens[_mark]->col_offset;
13384 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
13385 : : { // '+' factor
13386 [ - + ]: 12971004 : if (p->error_indicator) {
13387 : 0 : p->level--;
13388 : 0 : 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 [ + + ]: 12971004 : if (
13394 : 12971004 : (_literal = _PyPegen_expect_token(p, 14)) // token='+'
13395 [ + + ]: 887 : &&
13396 : 887 : (a = factor_rule(p)) // factor
13397 : : )
13398 : : {
13399 : : D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' factor"));
13400 : 863 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13401 [ - + ]: 863 : if (_token == NULL) {
13402 : 0 : p->level--;
13403 : 0 : return NULL;
13404 : : }
13405 : 863 : int _end_lineno = _token->end_lineno;
13406 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13407 : 863 : int _end_col_offset = _token->end_col_offset;
13408 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13409 : 863 : _res = _PyAST_UnaryOp ( UAdd , a , EXTRA );
13410 [ - + - - ]: 863 : if (_res == NULL && PyErr_Occurred()) {
13411 : 0 : p->error_indicator = 1;
13412 : 0 : p->level--;
13413 : 0 : return NULL;
13414 : : }
13415 : 863 : goto done;
13416 : : }
13417 : 12970141 : 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 [ - + ]: 12970141 : if (p->error_indicator) {
13423 : 0 : p->level--;
13424 : 0 : 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 [ + + ]: 12970141 : if (
13430 : 12970141 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
13431 [ + + ]: 61551 : &&
13432 : 61551 : (a = factor_rule(p)) // factor
13433 : : )
13434 : : {
13435 : : D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' factor"));
13436 : 43618 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13437 [ - + ]: 43618 : if (_token == NULL) {
13438 : 0 : p->level--;
13439 : 0 : return NULL;
13440 : : }
13441 : 43618 : int _end_lineno = _token->end_lineno;
13442 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13443 : 43618 : int _end_col_offset = _token->end_col_offset;
13444 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13445 : 43618 : _res = _PyAST_UnaryOp ( USub , a , EXTRA );
13446 [ - + - - ]: 43618 : if (_res == NULL && PyErr_Occurred()) {
13447 : 0 : p->error_indicator = 1;
13448 : 0 : p->level--;
13449 : 0 : return NULL;
13450 : : }
13451 : 43618 : goto done;
13452 : : }
13453 : 12926523 : 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 [ + + ]: 12926523 : if (p->error_indicator) {
13459 : 17933 : p->level--;
13460 : 17933 : 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 [ + + ]: 12908590 : if (
13466 : 12908590 : (_literal = _PyPegen_expect_token(p, 31)) // token='~'
13467 [ + - ]: 1064 : &&
13468 : 1064 : (a = factor_rule(p)) // factor
13469 : : )
13470 : : {
13471 : : D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' factor"));
13472 : 1064 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13473 [ - + ]: 1064 : if (_token == NULL) {
13474 : 0 : p->level--;
13475 : 0 : return NULL;
13476 : : }
13477 : 1064 : int _end_lineno = _token->end_lineno;
13478 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13479 : 1064 : int _end_col_offset = _token->end_col_offset;
13480 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13481 : 1064 : _res = _PyAST_UnaryOp ( Invert , a , EXTRA );
13482 [ - + - - ]: 1064 : if (_res == NULL && PyErr_Occurred()) {
13483 : 0 : p->error_indicator = 1;
13484 : 0 : p->level--;
13485 : 0 : return NULL;
13486 : : }
13487 : 1064 : goto done;
13488 : : }
13489 : 12907526 : 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 [ - + ]: 12907526 : if (p->error_indicator) {
13495 : 0 : p->level--;
13496 : 0 : 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 [ + + ]: 12907526 : if (
13501 : 12907526 : (power_var = power_rule(p)) // power
13502 : : )
13503 : : {
13504 : : D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "power"));
13505 : 10615352 : _res = power_var;
13506 : 10615352 : goto done;
13507 : : }
13508 : 2292174 : 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 : 2292174 : _res = NULL;
13513 : 12953071 : done:
13514 : 12953071 : _PyPegen_insert_memo(p, _mark, factor_type, _res);
13515 : 12953071 : p->level--;
13516 : 12953071 : return _res;
13517 : : }
13518 : :
13519 : : // power: await_primary '**' factor | await_primary
13520 : : static expr_ty
13521 : 12907526 : power_rule(Parser *p)
13522 : : {
13523 [ - + ]: 12907526 : if (p->level++ == MAXSTACK) {
13524 : 0 : p->error_indicator = 1;
13525 : : PyErr_NoMemory();
13526 : : }
13527 [ - + ]: 12907526 : if (p->error_indicator) {
13528 : 0 : p->level--;
13529 : 0 : return NULL;
13530 : : }
13531 : 12907526 : expr_ty _res = NULL;
13532 : 12907526 : int _mark = p->mark;
13533 [ - + - - ]: 12907526 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13534 : 0 : p->error_indicator = 1;
13535 : 0 : p->level--;
13536 : 0 : return NULL;
13537 : : }
13538 : 12907526 : int _start_lineno = p->tokens[_mark]->lineno;
13539 : : UNUSED(_start_lineno); // Only used by EXTRA macro
13540 : 12907526 : int _start_col_offset = p->tokens[_mark]->col_offset;
13541 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
13542 : : { // await_primary '**' factor
13543 [ - + ]: 12907526 : if (p->error_indicator) {
13544 : 0 : p->level--;
13545 : 0 : 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 [ + + ]: 12907526 : if (
13552 : 12907526 : (a = await_primary_rule(p)) // await_primary
13553 [ + + ]: 10615354 : &&
13554 : 10615354 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
13555 [ + + ]: 5475 : &&
13556 : 5475 : (b = factor_rule(p)) // factor
13557 : : )
13558 : : {
13559 : : D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor"));
13560 : 5470 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13561 [ - + ]: 5470 : if (_token == NULL) {
13562 : 0 : p->level--;
13563 : 0 : return NULL;
13564 : : }
13565 : 5470 : int _end_lineno = _token->end_lineno;
13566 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13567 : 5470 : int _end_col_offset = _token->end_col_offset;
13568 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13569 : 5470 : _res = _PyAST_BinOp ( a , Pow , b , EXTRA );
13570 [ - + - - ]: 5470 : if (_res == NULL && PyErr_Occurred()) {
13571 : 0 : p->error_indicator = 1;
13572 : 0 : p->level--;
13573 : 0 : return NULL;
13574 : : }
13575 : 5470 : goto done;
13576 : : }
13577 : 12902056 : 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 [ + + ]: 12902056 : if (p->error_indicator) {
13583 : 836 : p->level--;
13584 : 836 : 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 [ + + ]: 12901220 : if (
13589 : 12901220 : (await_primary_var = await_primary_rule(p)) // await_primary
13590 : : )
13591 : : {
13592 : : D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary"));
13593 : 10609882 : _res = await_primary_var;
13594 : 10609882 : goto done;
13595 : : }
13596 : 2291338 : 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 : 2291338 : _res = NULL;
13601 : 12906690 : done:
13602 : 12906690 : p->level--;
13603 : 12906690 : return _res;
13604 : : }
13605 : :
13606 : : // await_primary: AWAIT primary | primary
13607 : : static expr_ty
13608 : 25808746 : await_primary_rule(Parser *p)
13609 : : {
13610 [ - + ]: 25808746 : if (p->level++ == MAXSTACK) {
13611 : 0 : p->error_indicator = 1;
13612 : : PyErr_NoMemory();
13613 : : }
13614 [ - + ]: 25808746 : if (p->error_indicator) {
13615 : 0 : p->level--;
13616 : 0 : return NULL;
13617 : : }
13618 : 25808746 : expr_ty _res = NULL;
13619 [ + + ]: 25808746 : if (_PyPegen_is_memoized(p, await_primary_type, &_res)) {
13620 : 12901220 : p->level--;
13621 : 12901220 : return _res;
13622 : : }
13623 : 12907526 : int _mark = p->mark;
13624 [ - + - - ]: 12907526 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13625 : 0 : p->error_indicator = 1;
13626 : 0 : p->level--;
13627 : 0 : return NULL;
13628 : : }
13629 : 12907526 : int _start_lineno = p->tokens[_mark]->lineno;
13630 : : UNUSED(_start_lineno); // Only used by EXTRA macro
13631 : 12907526 : int _start_col_offset = p->tokens[_mark]->col_offset;
13632 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
13633 : : { // AWAIT primary
13634 [ - + ]: 12907526 : if (p->error_indicator) {
13635 : 0 : p->level--;
13636 : 0 : 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 [ + + ]: 12907526 : if (
13642 : 12907526 : (await_var = _PyPegen_expect_token(p, AWAIT)) // token='AWAIT'
13643 [ + + ]: 2404 : &&
13644 : 2404 : (a = primary_rule(p)) // primary
13645 : : )
13646 : : {
13647 : : D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AWAIT primary"));
13648 : 2372 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13649 [ - + ]: 2372 : if (_token == NULL) {
13650 : 0 : p->level--;
13651 : 0 : return NULL;
13652 : : }
13653 : 2372 : int _end_lineno = _token->end_lineno;
13654 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13655 : 2372 : int _end_col_offset = _token->end_col_offset;
13656 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13657 : 2372 : _res = CHECK_VERSION ( expr_ty , 5 , "Await expressions are" , _PyAST_Await ( a , EXTRA ) );
13658 [ + + + - ]: 2372 : if (_res == NULL && PyErr_Occurred()) {
13659 : 1 : p->error_indicator = 1;
13660 : 1 : p->level--;
13661 : 1 : return NULL;
13662 : : }
13663 : 2371 : goto done;
13664 : : }
13665 : 12905154 : 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 [ - + ]: 12905154 : if (p->error_indicator) {
13671 : 0 : p->level--;
13672 : 0 : 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 [ + + ]: 12905154 : if (
13677 : 12905154 : (primary_var = primary_rule(p)) // primary
13678 : : )
13679 : : {
13680 : : D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary"));
13681 : 10612983 : _res = primary_var;
13682 : 10612983 : goto done;
13683 : : }
13684 : 2292171 : 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 : 2292171 : _res = NULL;
13689 : 12907525 : done:
13690 : 12907525 : _PyPegen_insert_memo(p, _mark, await_primary_type, _res);
13691 : 12907525 : p->level--;
13692 : 12907525 : 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 : 116564733 : primary_rule(Parser *p)
13705 : : {
13706 [ - + ]: 116564733 : if (p->level++ == MAXSTACK) {
13707 : 0 : p->error_indicator = 1;
13708 : : PyErr_NoMemory();
13709 : : }
13710 : 116564733 : expr_ty _res = NULL;
13711 [ + + ]: 116564733 : if (_PyPegen_is_memoized(p, primary_type, &_res)) {
13712 : 103657175 : p->level--;
13713 : 103657175 : return _res;
13714 : : }
13715 : 12907558 : int _mark = p->mark;
13716 : 12907558 : int _resmark = p->mark;
13717 : 14948712 : while (1) {
13718 : 27856270 : int tmpvar_8 = _PyPegen_update_memo(p, _mark, primary_type, _res);
13719 [ - + ]: 27856270 : if (tmpvar_8) {
13720 : 0 : p->level--;
13721 : 0 : return _res;
13722 : : }
13723 : 27856270 : p->mark = _mark;
13724 : 27856270 : void *_raw = primary_raw(p);
13725 [ + + ]: 27856270 : if (p->error_indicator) {
13726 : 833 : p->level--;
13727 : 833 : return NULL;
13728 : : }
13729 [ + + + + ]: 27855437 : if (_raw == NULL || p->mark <= _resmark)
13730 : : break;
13731 : 14948712 : _resmark = p->mark;
13732 : 14948712 : _res = _raw;
13733 : : }
13734 : 12906725 : p->mark = _resmark;
13735 : 12906725 : p->level--;
13736 : 12906725 : return _res;
13737 : : }
13738 : : static expr_ty
13739 : 27856270 : primary_raw(Parser *p)
13740 : : {
13741 [ - + ]: 27856270 : if (p->level++ == MAXSTACK) {
13742 : 0 : p->error_indicator = 1;
13743 : : PyErr_NoMemory();
13744 : : }
13745 [ - + ]: 27856270 : if (p->error_indicator) {
13746 : 0 : p->level--;
13747 : 0 : return NULL;
13748 : : }
13749 : 27856270 : expr_ty _res = NULL;
13750 : 27856270 : int _mark = p->mark;
13751 [ - + - - ]: 27856270 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13752 : 0 : p->error_indicator = 1;
13753 : 0 : p->level--;
13754 : 0 : return NULL;
13755 : : }
13756 : 27856270 : int _start_lineno = p->tokens[_mark]->lineno;
13757 : : UNUSED(_start_lineno); // Only used by EXTRA macro
13758 : 27856270 : int _start_col_offset = p->tokens[_mark]->col_offset;
13759 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
13760 : : { // primary '.' NAME
13761 [ - + ]: 27856270 : if (p->error_indicator) {
13762 : 0 : p->level--;
13763 : 0 : 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 [ + + ]: 27856270 : if (
13770 : 27856270 : (a = primary_rule(p)) // primary
13771 [ + + ]: 14948712 : &&
13772 : 14948712 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
13773 [ + + ]: 1957469 : &&
13774 : 1957469 : (b = _PyPegen_name_token(p)) // NAME
13775 : : )
13776 : : {
13777 : : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));
13778 : 1957443 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13779 [ - + ]: 1957443 : if (_token == NULL) {
13780 : 0 : p->level--;
13781 : 0 : return NULL;
13782 : : }
13783 : 1957443 : int _end_lineno = _token->end_lineno;
13784 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13785 : 1957443 : int _end_col_offset = _token->end_col_offset;
13786 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13787 : 1957443 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA );
13788 [ - + - - ]: 1957443 : if (_res == NULL && PyErr_Occurred()) {
13789 : 0 : p->error_indicator = 1;
13790 : 0 : p->level--;
13791 : 0 : return NULL;
13792 : : }
13793 : 1957443 : goto done;
13794 : : }
13795 : 25898827 : 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 [ + + ]: 25898827 : if (p->error_indicator) {
13801 : 23 : p->level--;
13802 : 23 : 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 [ + + ]: 25898804 : if (
13808 : 25898804 : (a = primary_rule(p)) // primary
13809 [ + + ]: 12991246 : &&
13810 : 12991246 : (b = genexp_rule(p)) // genexp
13811 : : )
13812 : : {
13813 : : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary genexp"));
13814 : 6777 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13815 [ - + ]: 6777 : if (_token == NULL) {
13816 : 0 : p->level--;
13817 : 0 : return NULL;
13818 : : }
13819 : 6777 : int _end_lineno = _token->end_lineno;
13820 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13821 : 6777 : int _end_col_offset = _token->end_col_offset;
13822 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13823 : 6777 : _res = _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
13824 [ - + - - ]: 6777 : if (_res == NULL && PyErr_Occurred()) {
13825 : 0 : p->error_indicator = 1;
13826 : 0 : p->level--;
13827 : 0 : return NULL;
13828 : : }
13829 : 6777 : goto done;
13830 : : }
13831 : 25892027 : 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 [ + + ]: 25892027 : if (p->error_indicator) {
13837 : 4 : p->level--;
13838 : 4 : 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 [ + + ]: 25892023 : if (
13846 : 25892023 : (a = primary_rule(p)) // primary
13847 [ + + ]: 12984465 : &&
13848 : 12984465 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
13849 : 1882029 : &&
13850 [ + + ]: 1882029 : (b = arguments_rule(p), !p->error_indicator) // arguments?
13851 [ + + ]: 1882015 : &&
13852 : 1882015 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
13853 : : )
13854 : : {
13855 : : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'"));
13856 : 1881931 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13857 [ - + ]: 1881931 : if (_token == NULL) {
13858 : 0 : p->level--;
13859 : 0 : return NULL;
13860 : : }
13861 : 1881931 : int _end_lineno = _token->end_lineno;
13862 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13863 : 1881931 : int _end_col_offset = _token->end_col_offset;
13864 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13865 [ + + + + ]: 1881931 : _res = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
13866 [ - + - - ]: 1881931 : if (_res == NULL && PyErr_Occurred()) {
13867 : 0 : p->error_indicator = 1;
13868 : 0 : p->level--;
13869 : 0 : return NULL;
13870 : : }
13871 : 1881931 : goto done;
13872 : : }
13873 : 24010092 : 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 [ + + ]: 24010092 : if (p->error_indicator) {
13879 : 14 : p->level--;
13880 : 14 : 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 [ + + ]: 24010078 : if (
13888 : 24010078 : (a = primary_rule(p)) // primary
13889 [ + + ]: 11102520 : &&
13890 : 11102520 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
13891 [ + + ]: 487202 : &&
13892 : 487202 : (b = slices_rule(p)) // slices
13893 [ + + ]: 487182 : &&
13894 : 487182 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
13895 : : )
13896 : : {
13897 : : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'"));
13898 : 487164 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13899 [ - + ]: 487164 : if (_token == NULL) {
13900 : 0 : p->level--;
13901 : 0 : return NULL;
13902 : : }
13903 : 487164 : int _end_lineno = _token->end_lineno;
13904 : : UNUSED(_end_lineno); // Only used by EXTRA macro
13905 : 487164 : int _end_col_offset = _token->end_col_offset;
13906 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
13907 : 487164 : _res = _PyAST_Subscript ( a , b , Load , EXTRA );
13908 [ - + - - ]: 487164 : if (_res == NULL && PyErr_Occurred()) {
13909 : 0 : p->error_indicator = 1;
13910 : 0 : p->level--;
13911 : 0 : return NULL;
13912 : : }
13913 : 487164 : goto done;
13914 : : }
13915 : 23522914 : 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 [ + + ]: 23522914 : if (p->error_indicator) {
13921 : 1 : p->level--;
13922 : 1 : 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 [ + + ]: 23522913 : if (
13927 : 23522913 : (atom_var = atom_rule(p)) // atom
13928 : : )
13929 : : {
13930 : : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom"));
13931 : 21230752 : _res = atom_var;
13932 : 21230752 : goto done;
13933 : : }
13934 : 2292161 : 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 : 2292161 : _res = NULL;
13939 : 27856228 : done:
13940 : 27856228 : p->level--;
13941 : 27856228 : return _res;
13942 : : }
13943 : :
13944 : : // slices: slice !',' | ','.(slice | starred_expression)+ ','?
13945 : : static expr_ty
13946 : 999522 : slices_rule(Parser *p)
13947 : : {
13948 [ - + ]: 999522 : if (p->level++ == MAXSTACK) {
13949 : 0 : p->error_indicator = 1;
13950 : : PyErr_NoMemory();
13951 : : }
13952 [ - + ]: 999522 : if (p->error_indicator) {
13953 : 0 : p->level--;
13954 : 0 : return NULL;
13955 : : }
13956 : 999522 : expr_ty _res = NULL;
13957 : 999522 : int _mark = p->mark;
13958 [ + + + + ]: 999522 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13959 : 2 : p->error_indicator = 1;
13960 : 2 : p->level--;
13961 : 2 : return NULL;
13962 : : }
13963 : 999520 : int _start_lineno = p->tokens[_mark]->lineno;
13964 : : UNUSED(_start_lineno); // Only used by EXTRA macro
13965 : 999520 : int _start_col_offset = p->tokens[_mark]->col_offset;
13966 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
13967 : : { // slice !','
13968 [ - + ]: 999520 : if (p->error_indicator) {
13969 : 0 : p->level--;
13970 : 0 : return NULL;
13971 : : }
13972 : : D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','"));
13973 : : expr_ty a;
13974 [ + + ]: 999520 : if (
13975 : 999520 : (a = slice_rule(p)) // slice
13976 [ + + ]: 998594 : &&
13977 : 998594 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
13978 : : )
13979 : : {
13980 : : D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice !','"));
13981 : 977743 : _res = a;
13982 [ - + - - ]: 977743 : if (_res == NULL && PyErr_Occurred()) {
13983 : 0 : p->error_indicator = 1;
13984 : 0 : p->level--;
13985 : 0 : return NULL;
13986 : : }
13987 : 977743 : goto done;
13988 : : }
13989 : 21777 : 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 [ + + ]: 21777 : if (p->error_indicator) {
13995 : 13 : p->level--;
13996 : 13 : 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 [ + + ]: 21764 : if (
14003 : 21764 : (a = (asdl_expr_seq*)_gather_88_rule(p)) // ','.(slice | starred_expression)+
14004 : 21669 : &&
14005 [ + + ]: 21669 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
14006 : : )
14007 : : {
14008 : : D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(slice | starred_expression)+ ','?"));
14009 : 21667 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14010 [ - + ]: 21667 : if (_token == NULL) {
14011 : 0 : p->level--;
14012 : 0 : return NULL;
14013 : : }
14014 : 21667 : int _end_lineno = _token->end_lineno;
14015 : : UNUSED(_end_lineno); // Only used by EXTRA macro
14016 : 21667 : int _end_col_offset = _token->end_col_offset;
14017 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
14018 : 21667 : _res = _PyAST_Tuple ( a , Load , EXTRA );
14019 [ - + - - ]: 21667 : if (_res == NULL && PyErr_Occurred()) {
14020 : 0 : p->error_indicator = 1;
14021 : 0 : p->level--;
14022 : 0 : return NULL;
14023 : : }
14024 : 21667 : goto done;
14025 : : }
14026 : 97 : 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 : 97 : _res = NULL;
14031 : 999507 : done:
14032 : 999507 : p->level--;
14033 : 999507 : return _res;
14034 : : }
14035 : :
14036 : : // slice: expression? ':' expression? [':' expression?] | named_expression
14037 : : static expr_ty
14038 : 1047534 : slice_rule(Parser *p)
14039 : : {
14040 [ - + ]: 1047534 : if (p->level++ == MAXSTACK) {
14041 : 0 : p->error_indicator = 1;
14042 : : PyErr_NoMemory();
14043 : : }
14044 [ - + ]: 1047534 : if (p->error_indicator) {
14045 : 0 : p->level--;
14046 : 0 : return NULL;
14047 : : }
14048 : 1047534 : expr_ty _res = NULL;
14049 : 1047534 : int _mark = p->mark;
14050 [ + + + + ]: 1047534 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14051 : 2 : p->error_indicator = 1;
14052 : 2 : p->level--;
14053 : 2 : return NULL;
14054 : : }
14055 : 1047532 : int _start_lineno = p->tokens[_mark]->lineno;
14056 : : UNUSED(_start_lineno); // Only used by EXTRA macro
14057 : 1047532 : int _start_col_offset = p->tokens[_mark]->col_offset;
14058 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
14059 : : { // expression? ':' expression? [':' expression?]
14060 [ - + ]: 1047532 : if (p->error_indicator) {
14061 : 0 : p->level--;
14062 : 0 : 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 : 1047532 : if (
14070 [ + + ]: 1047532 : (a = expression_rule(p), !p->error_indicator) // expression?
14071 [ + + ]: 1047528 : &&
14072 : 1047528 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
14073 : 68536 : &&
14074 [ + + ]: 68536 : (b = expression_rule(p), !p->error_indicator) // expression?
14075 : 68531 : &&
14076 [ + + ]: 68531 : (c = _tmp_90_rule(p), !p->error_indicator) // [':' expression?]
14077 : : )
14078 : : {
14079 : : D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]"));
14080 : 68527 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14081 [ - + ]: 68527 : if (_token == NULL) {
14082 : 0 : p->level--;
14083 : 0 : return NULL;
14084 : : }
14085 : 68527 : int _end_lineno = _token->end_lineno;
14086 : : UNUSED(_end_lineno); // Only used by EXTRA macro
14087 : 68527 : int _end_col_offset = _token->end_col_offset;
14088 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
14089 : 68527 : _res = _PyAST_Slice ( a , b , c , EXTRA );
14090 [ - + - - ]: 68527 : if (_res == NULL && PyErr_Occurred()) {
14091 : 0 : p->error_indicator = 1;
14092 : 0 : p->level--;
14093 : 0 : return NULL;
14094 : : }
14095 : 68527 : goto done;
14096 : : }
14097 : 979005 : 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 [ + + ]: 979005 : if (p->error_indicator) {
14103 : 13 : p->level--;
14104 : 13 : 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 [ + + ]: 978992 : if (
14109 : 978992 : (a = named_expression_rule(p)) // named_expression
14110 : : )
14111 : : {
14112 : : D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
14113 : 976011 : _res = a;
14114 [ - + - - ]: 976011 : if (_res == NULL && PyErr_Occurred()) {
14115 : 0 : p->error_indicator = 1;
14116 : 0 : p->level--;
14117 : 0 : return NULL;
14118 : : }
14119 : 976011 : goto done;
14120 : : }
14121 : 2981 : 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 : 2981 : _res = NULL;
14126 : 1047519 : done:
14127 : 1047519 : p->level--;
14128 : 1047519 : 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 : 28987665 : atom_rule(Parser *p)
14144 : : {
14145 [ - + ]: 28987665 : if (p->level++ == MAXSTACK) {
14146 : 0 : p->error_indicator = 1;
14147 : : PyErr_NoMemory();
14148 : : }
14149 [ - + ]: 28987665 : if (p->error_indicator) {
14150 : 0 : p->level--;
14151 : 0 : return NULL;
14152 : : }
14153 : 28987665 : expr_ty _res = NULL;
14154 : 28987665 : int _mark = p->mark;
14155 [ - + - - ]: 28987665 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14156 : 0 : p->error_indicator = 1;
14157 : 0 : p->level--;
14158 : 0 : return NULL;
14159 : : }
14160 : 28987665 : int _start_lineno = p->tokens[_mark]->lineno;
14161 : : UNUSED(_start_lineno); // Only used by EXTRA macro
14162 : 28987665 : int _start_col_offset = p->tokens[_mark]->col_offset;
14163 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
14164 : : { // NAME
14165 [ - + ]: 28987665 : if (p->error_indicator) {
14166 : 0 : p->level--;
14167 : 0 : 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 [ + + ]: 28987665 : if (
14172 : 28987665 : (name_var = _PyPegen_name_token(p)) // NAME
14173 : : )
14174 : : {
14175 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
14176 : 14016908 : _res = name_var;
14177 : 14016908 : goto done;
14178 : : }
14179 : 14970757 : 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 [ - + ]: 14970757 : if (p->error_indicator) {
14185 : 0 : p->level--;
14186 : 0 : return NULL;
14187 : : }
14188 : : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
14189 : : Token * _keyword;
14190 [ + + ]: 14970757 : if (
14191 : 14970757 : (_keyword = _PyPegen_expect_token(p, 600)) // token='True'
14192 : : )
14193 : : {
14194 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
14195 : 120247 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14196 [ - + ]: 120247 : if (_token == NULL) {
14197 : 0 : p->level--;
14198 : 0 : return NULL;
14199 : : }
14200 : 120247 : int _end_lineno = _token->end_lineno;
14201 : : UNUSED(_end_lineno); // Only used by EXTRA macro
14202 : 120247 : int _end_col_offset = _token->end_col_offset;
14203 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
14204 : 120247 : _res = _PyAST_Constant ( Py_True , NULL , EXTRA );
14205 [ - + - - ]: 120247 : if (_res == NULL && PyErr_Occurred()) {
14206 : 0 : p->error_indicator = 1;
14207 : 0 : p->level--;
14208 : 0 : return NULL;
14209 : : }
14210 : 120247 : goto done;
14211 : : }
14212 : 14850510 : 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 [ - + ]: 14850510 : if (p->error_indicator) {
14218 : 0 : p->level--;
14219 : 0 : return NULL;
14220 : : }
14221 : : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
14222 : : Token * _keyword;
14223 [ + + ]: 14850510 : if (
14224 : 14850510 : (_keyword = _PyPegen_expect_token(p, 602)) // token='False'
14225 : : )
14226 : : {
14227 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
14228 : 114867 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14229 [ - + ]: 114867 : if (_token == NULL) {
14230 : 0 : p->level--;
14231 : 0 : return NULL;
14232 : : }
14233 : 114867 : int _end_lineno = _token->end_lineno;
14234 : : UNUSED(_end_lineno); // Only used by EXTRA macro
14235 : 114867 : int _end_col_offset = _token->end_col_offset;
14236 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
14237 : 114867 : _res = _PyAST_Constant ( Py_False , NULL , EXTRA );
14238 [ - + - - ]: 114867 : if (_res == NULL && PyErr_Occurred()) {
14239 : 0 : p->error_indicator = 1;
14240 : 0 : p->level--;
14241 : 0 : return NULL;
14242 : : }
14243 : 114867 : goto done;
14244 : : }
14245 : 14735643 : 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 [ - + ]: 14735643 : if (p->error_indicator) {
14251 : 0 : p->level--;
14252 : 0 : return NULL;
14253 : : }
14254 : : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
14255 : : Token * _keyword;
14256 [ + + ]: 14735643 : if (
14257 : 14735643 : (_keyword = _PyPegen_expect_token(p, 601)) // token='None'
14258 : : )
14259 : : {
14260 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
14261 : 375615 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14262 [ - + ]: 375615 : if (_token == NULL) {
14263 : 0 : p->level--;
14264 : 0 : return NULL;
14265 : : }
14266 : 375615 : int _end_lineno = _token->end_lineno;
14267 : : UNUSED(_end_lineno); // Only used by EXTRA macro
14268 : 375615 : int _end_col_offset = _token->end_col_offset;
14269 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
14270 : 375615 : _res = _PyAST_Constant ( Py_None , NULL , EXTRA );
14271 [ - + - - ]: 375615 : if (_res == NULL && PyErr_Occurred()) {
14272 : 0 : p->error_indicator = 1;
14273 : 0 : p->level--;
14274 : 0 : return NULL;
14275 : : }
14276 : 375615 : goto done;
14277 : : }
14278 : 14360028 : 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 [ - + ]: 14360028 : if (p->error_indicator) {
14284 : 0 : p->level--;
14285 : 0 : 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 [ + + ]: 14360028 : if (
14290 : 14360028 : _PyPegen_lookahead(1, _PyPegen_string_token, p)
14291 [ + + ]: 3407740 : &&
14292 : 3407740 : (strings_var = strings_rule(p)) // strings
14293 : : )
14294 : : {
14295 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&STRING strings"));
14296 : 3406971 : _res = strings_var;
14297 : 3406971 : goto done;
14298 : : }
14299 : 10953057 : 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 [ + + ]: 10953057 : if (p->error_indicator) {
14305 : 769 : p->level--;
14306 : 769 : 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 [ + + ]: 10952288 : if (
14311 : 10952288 : (number_var = _PyPegen_number_token(p)) // NUMBER
14312 : : )
14313 : : {
14314 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
14315 : 5871630 : _res = number_var;
14316 : 5871630 : goto done;
14317 : : }
14318 : 5080658 : 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 [ + + ]: 5080658 : if (p->error_indicator) {
14324 : 2 : p->level--;
14325 : 2 : 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 [ + + ]: 5080656 : if (
14330 : 5080656 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='('
14331 [ + + ]: 863699 : &&
14332 : 863699 : (_tmp_91_var = _tmp_91_rule(p)) // tuple | group | genexp
14333 : : )
14334 : : {
14335 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)"));
14336 : 863518 : _res = _tmp_91_var;
14337 : 863518 : goto done;
14338 : : }
14339 : 4217138 : 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 [ + + ]: 4217138 : if (p->error_indicator) {
14345 : 68 : p->level--;
14346 : 68 : 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 [ + + ]: 4217070 : if (
14351 : 4217070 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='['
14352 [ + + ]: 261397 : &&
14353 : 261397 : (_tmp_92_var = _tmp_92_rule(p)) // list | listcomp
14354 : : )
14355 : : {
14356 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)"));
14357 : 261274 : _res = _tmp_92_var;
14358 : 261274 : goto done;
14359 : : }
14360 : 3955796 : 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 [ + + ]: 3955796 : if (p->error_indicator) {
14366 : 53 : p->level--;
14367 : 53 : 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 [ + + ]: 3955743 : if (
14372 : 3955743 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{'
14373 [ + + ]: 112968 : &&
14374 : 112968 : (_tmp_93_var = _tmp_93_rule(p)) // dict | set | dictcomp | setcomp
14375 : : )
14376 : : {
14377 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
14378 : 112872 : _res = _tmp_93_var;
14379 : 112872 : goto done;
14380 : : }
14381 : 3842871 : 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 [ + + ]: 3842871 : if (p->error_indicator) {
14387 : 39 : p->level--;
14388 : 39 : return NULL;
14389 : : }
14390 : : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
14391 : : Token * _literal;
14392 [ + + ]: 3842832 : if (
14393 : 3842832 : (_literal = _PyPegen_expect_token(p, 52)) // token='...'
14394 : : )
14395 : : {
14396 : : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
14397 : 11973 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14398 [ - + ]: 11973 : if (_token == NULL) {
14399 : 0 : p->level--;
14400 : 0 : return NULL;
14401 : : }
14402 : 11973 : int _end_lineno = _token->end_lineno;
14403 : : UNUSED(_end_lineno); // Only used by EXTRA macro
14404 : 11973 : int _end_col_offset = _token->end_col_offset;
14405 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
14406 : 11973 : _res = _PyAST_Constant ( Py_Ellipsis , NULL , EXTRA );
14407 [ - + - - ]: 11973 : if (_res == NULL && PyErr_Occurred()) {
14408 : 0 : p->error_indicator = 1;
14409 : 0 : p->level--;
14410 : 0 : return NULL;
14411 : : }
14412 : 11973 : goto done;
14413 : : }
14414 : 3830859 : 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 : 3830859 : _res = NULL;
14419 : 28986734 : done:
14420 : 28986734 : p->level--;
14421 : 28986734 : return _res;
14422 : : }
14423 : :
14424 : : // group: '(' (yield_expr | named_expression) ')' | invalid_group
14425 : : static expr_ty
14426 : 293747 : group_rule(Parser *p)
14427 : : {
14428 [ - + ]: 293747 : if (p->level++ == MAXSTACK) {
14429 : 0 : p->error_indicator = 1;
14430 : : PyErr_NoMemory();
14431 : : }
14432 [ - + ]: 293747 : if (p->error_indicator) {
14433 : 0 : p->level--;
14434 : 0 : return NULL;
14435 : : }
14436 : 293747 : expr_ty _res = NULL;
14437 : 293747 : int _mark = p->mark;
14438 : : { // '(' (yield_expr | named_expression) ')'
14439 [ - + ]: 293747 : if (p->error_indicator) {
14440 : 0 : p->level--;
14441 : 0 : 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 [ + - ]: 293747 : if (
14448 : 293747 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
14449 [ + + ]: 293747 : &&
14450 : 293747 : (a = _tmp_94_rule(p)) // yield_expr | named_expression
14451 [ + + ]: 293687 : &&
14452 : 293687 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
14453 : : )
14454 : : {
14455 : : D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
14456 : 288226 : _res = a;
14457 [ - + - - ]: 288226 : if (_res == NULL && PyErr_Occurred()) {
14458 : 0 : p->error_indicator = 1;
14459 : 0 : p->level--;
14460 : 0 : return NULL;
14461 : : }
14462 : 288226 : goto done;
14463 : : }
14464 : 5521 : 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 [ + + ]: 5521 : if (p->call_invalid_rules) { // invalid_group
14469 [ - + ]: 50 : if (p->error_indicator) {
14470 : 0 : p->level--;
14471 : 0 : 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 [ - + ]: 50 : if (
14476 : 50 : (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 : 0 : _res = invalid_group_var;
14481 : 0 : goto done;
14482 : : }
14483 : 50 : 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 : 5521 : _res = NULL;
14488 : 293747 : done:
14489 : 293747 : p->level--;
14490 : 293747 : return _res;
14491 : : }
14492 : :
14493 : : // lambdef: 'lambda' lambda_params? ':' expression
14494 : : static expr_ty
14495 : 2291729 : lambdef_rule(Parser *p)
14496 : : {
14497 [ - + ]: 2291729 : if (p->level++ == MAXSTACK) {
14498 : 0 : p->error_indicator = 1;
14499 : : PyErr_NoMemory();
14500 : : }
14501 [ - + ]: 2291729 : if (p->error_indicator) {
14502 : 0 : p->level--;
14503 : 0 : return NULL;
14504 : : }
14505 : 2291729 : expr_ty _res = NULL;
14506 : 2291729 : int _mark = p->mark;
14507 [ - + - - ]: 2291729 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14508 : 0 : p->error_indicator = 1;
14509 : 0 : p->level--;
14510 : 0 : return NULL;
14511 : : }
14512 : 2291729 : int _start_lineno = p->tokens[_mark]->lineno;
14513 : : UNUSED(_start_lineno); // Only used by EXTRA macro
14514 : 2291729 : 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 [ - + ]: 2291729 : if (p->error_indicator) {
14518 : 0 : p->level--;
14519 : 0 : 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 [ + + ]: 2291729 : if (
14527 : 2291729 : (_keyword = _PyPegen_expect_token(p, 586)) // token='lambda'
14528 : 37303 : &&
14529 [ + + ]: 37303 : (a = lambda_params_rule(p), !p->error_indicator) // lambda_params?
14530 [ + + ]: 37263 : &&
14531 : 37263 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
14532 [ + + ]: 37213 : &&
14533 : 37213 : (b = expression_rule(p)) // expression
14534 : : )
14535 : : {
14536 : : D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression"));
14537 : 37206 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14538 [ - + ]: 37206 : if (_token == NULL) {
14539 : 0 : p->level--;
14540 : 0 : return NULL;
14541 : : }
14542 : 37206 : int _end_lineno = _token->end_lineno;
14543 : : UNUSED(_end_lineno); // Only used by EXTRA macro
14544 : 37206 : int _end_col_offset = _token->end_col_offset;
14545 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
14546 [ + + ]: 37206 : _res = _PyAST_Lambda ( ( a ) ? a : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , EXTRA );
14547 [ - + - - ]: 37206 : if (_res == NULL && PyErr_Occurred()) {
14548 : 0 : p->error_indicator = 1;
14549 : 0 : p->level--;
14550 : 0 : return NULL;
14551 : : }
14552 : 37206 : goto done;
14553 : : }
14554 : 2254523 : 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 : 2254523 : _res = NULL;
14559 : 2291729 : done:
14560 : 2291729 : p->level--;
14561 : 2291729 : return _res;
14562 : : }
14563 : :
14564 : : // lambda_params: invalid_lambda_parameters | lambda_parameters
14565 : : static arguments_ty
14566 : 37303 : lambda_params_rule(Parser *p)
14567 : : {
14568 [ - + ]: 37303 : if (p->level++ == MAXSTACK) {
14569 : 0 : p->error_indicator = 1;
14570 : : PyErr_NoMemory();
14571 : : }
14572 [ - + ]: 37303 : if (p->error_indicator) {
14573 : 0 : p->level--;
14574 : 0 : return NULL;
14575 : : }
14576 : 37303 : arguments_ty _res = NULL;
14577 : 37303 : int _mark = p->mark;
14578 [ + + ]: 37303 : if (p->call_invalid_rules) { // invalid_lambda_parameters
14579 [ - + ]: 52 : if (p->error_indicator) {
14580 : 0 : p->level--;
14581 : 0 : 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 [ - + ]: 52 : if (
14586 : 52 : (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 : 0 : _res = invalid_lambda_parameters_var;
14591 : 0 : goto done;
14592 : : }
14593 : 52 : 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 [ + + ]: 37303 : if (p->error_indicator) {
14599 : 27 : p->level--;
14600 : 27 : 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 [ + + ]: 37276 : if (
14605 : 37276 : (lambda_parameters_var = lambda_parameters_rule(p)) // lambda_parameters
14606 : : )
14607 : : {
14608 : : D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_parameters"));
14609 : 34516 : _res = lambda_parameters_var;
14610 : 34516 : goto done;
14611 : : }
14612 : 2760 : 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 : 2760 : _res = NULL;
14617 : 37276 : done:
14618 : 37276 : p->level--;
14619 : 37276 : 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 : 37276 : lambda_parameters_rule(Parser *p)
14630 : : {
14631 [ - + ]: 37276 : if (p->level++ == MAXSTACK) {
14632 : 0 : p->error_indicator = 1;
14633 : : PyErr_NoMemory();
14634 : : }
14635 [ - + ]: 37276 : if (p->error_indicator) {
14636 : 0 : p->level--;
14637 : 0 : return NULL;
14638 : : }
14639 : 37276 : arguments_ty _res = NULL;
14640 : 37276 : int _mark = p->mark;
14641 : : { // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
14642 [ - + ]: 37276 : if (p->error_indicator) {
14643 : 0 : p->level--;
14644 : 0 : 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 [ + + ]: 37276 : if (
14652 : 37276 : (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default
14653 [ + - ]: 79 : &&
14654 : 79 : (b = (asdl_arg_seq*)_loop0_95_rule(p)) // lambda_param_no_default*
14655 [ + - ]: 79 : &&
14656 : 79 : (c = _loop0_96_rule(p)) // lambda_param_with_default*
14657 : 79 : &&
14658 [ + + ]: 79 : (d = lambda_star_etc_rule(p), !p->error_indicator) // 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 : 77 : _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
14663 [ - + - - ]: 77 : if (_res == NULL && PyErr_Occurred()) {
14664 : 0 : p->error_indicator = 1;
14665 : 0 : p->level--;
14666 : 0 : return NULL;
14667 : : }
14668 : 77 : goto done;
14669 : : }
14670 : 37199 : 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 [ + + ]: 37199 : if (p->error_indicator) {
14676 : 2 : p->level--;
14677 : 2 : 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 [ + + ]: 37197 : if (
14684 : 37197 : (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default
14685 [ + - ]: 58 : &&
14686 : 58 : (b = _loop0_97_rule(p)) // lambda_param_with_default*
14687 : 58 : &&
14688 [ + + ]: 58 : (c = lambda_star_etc_rule(p), !p->error_indicator) // 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 : 57 : _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
14693 [ - + - - ]: 57 : if (_res == NULL && PyErr_Occurred()) {
14694 : 0 : p->error_indicator = 1;
14695 : 0 : p->level--;
14696 : 0 : return NULL;
14697 : : }
14698 : 57 : goto done;
14699 : : }
14700 : 37140 : 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 [ + + ]: 37140 : if (p->error_indicator) {
14706 : 1 : p->level--;
14707 : 1 : 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 [ + + ]: 37139 : if (
14714 : 37139 : (a = (asdl_arg_seq*)_loop1_98_rule(p)) // lambda_param_no_default+
14715 [ + - ]: 33996 : &&
14716 : 33996 : (b = _loop0_99_rule(p)) // lambda_param_with_default*
14717 : 33996 : &&
14718 [ + + ]: 33996 : (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc?
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 : 33989 : _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
14723 [ - + - - ]: 33989 : if (_res == NULL && PyErr_Occurred()) {
14724 : 0 : p->error_indicator = 1;
14725 : 0 : p->level--;
14726 : 0 : return NULL;
14727 : : }
14728 : 33989 : goto done;
14729 : : }
14730 : 3150 : 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 [ + + ]: 3150 : if (p->error_indicator) {
14736 : 7 : p->level--;
14737 : 7 : 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 [ + + ]: 3143 : if (
14743 : 3143 : (a = _loop1_100_rule(p)) // lambda_param_with_default+
14744 : 144 : &&
14745 [ + - ]: 144 : (b = lambda_star_etc_rule(p), !p->error_indicator) // 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 : 144 : _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
14750 [ - + - - ]: 144 : if (_res == NULL && PyErr_Occurred()) {
14751 : 0 : p->error_indicator = 1;
14752 : 0 : p->level--;
14753 : 0 : return NULL;
14754 : : }
14755 : 144 : goto done;
14756 : : }
14757 : 2999 : 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 [ - + ]: 2999 : if (p->error_indicator) {
14763 : 0 : p->level--;
14764 : 0 : 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 [ + + ]: 2999 : if (
14769 : 2999 : (a = lambda_star_etc_rule(p)) // lambda_star_etc
14770 : : )
14771 : : {
14772 : : D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_star_etc"));
14773 : 249 : _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
14774 [ - + - - ]: 249 : if (_res == NULL && PyErr_Occurred()) {
14775 : 0 : p->error_indicator = 1;
14776 : 0 : p->level--;
14777 : 0 : return NULL;
14778 : : }
14779 : 249 : goto done;
14780 : : }
14781 : 2750 : 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 : 2750 : _res = NULL;
14786 : 37266 : done:
14787 : 37266 : p->level--;
14788 : 37266 : 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 : 37349 : lambda_slash_no_default_rule(Parser *p)
14796 : : {
14797 [ - + ]: 37349 : if (p->level++ == MAXSTACK) {
14798 : 0 : p->error_indicator = 1;
14799 : : PyErr_NoMemory();
14800 : : }
14801 [ - + ]: 37349 : if (p->error_indicator) {
14802 : 0 : p->level--;
14803 : 0 : return NULL;
14804 : : }
14805 : 37349 : asdl_arg_seq* _res = NULL;
14806 : 37349 : int _mark = p->mark;
14807 : : { // lambda_param_no_default+ '/' ','
14808 [ - + ]: 37349 : if (p->error_indicator) {
14809 : 0 : p->level--;
14810 : 0 : 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 [ + + ]: 37349 : if (
14817 : 37349 : (a = (asdl_arg_seq*)_loop1_101_rule(p)) // lambda_param_no_default+
14818 [ + + ]: 34114 : &&
14819 : 34114 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
14820 [ + + ]: 89 : &&
14821 : 89 : (_literal_1 = _PyPegen_expect_token(p, 12)) // 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 : 76 : _res = a;
14826 [ - + - - ]: 76 : if (_res == NULL && PyErr_Occurred()) {
14827 : 0 : p->error_indicator = 1;
14828 : 0 : p->level--;
14829 : 0 : return NULL;
14830 : : }
14831 : 76 : goto done;
14832 : : }
14833 : 37273 : 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 [ - + ]: 37273 : if (p->error_indicator) {
14839 : 0 : p->level--;
14840 : 0 : 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 [ + + ]: 37273 : if (
14846 : 37273 : (a = (asdl_arg_seq*)_loop1_102_rule(p)) // lambda_param_no_default+
14847 [ + + ]: 34038 : &&
14848 : 34038 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
14849 [ + - ]: 13 : &&
14850 : 13 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // 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 : 13 : _res = a;
14855 [ - + - - ]: 13 : if (_res == NULL && PyErr_Occurred()) {
14856 : 0 : p->error_indicator = 1;
14857 : 0 : p->level--;
14858 : 0 : return NULL;
14859 : : }
14860 : 13 : goto done;
14861 : : }
14862 : 37260 : 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 : 37260 : _res = NULL;
14867 : 37349 : done:
14868 : 37349 : p->level--;
14869 : 37349 : 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 : 37312 : lambda_slash_with_default_rule(Parser *p)
14877 : : {
14878 [ - + ]: 37312 : if (p->level++ == MAXSTACK) {
14879 : 0 : p->error_indicator = 1;
14880 : : PyErr_NoMemory();
14881 : : }
14882 [ - + ]: 37312 : if (p->error_indicator) {
14883 : 0 : p->level--;
14884 : 0 : return NULL;
14885 : : }
14886 : 37312 : SlashWithDefault* _res = NULL;
14887 : 37312 : int _mark = p->mark;
14888 : : { // lambda_param_no_default* lambda_param_with_default+ '/' ','
14889 [ - + ]: 37312 : if (p->error_indicator) {
14890 : 0 : p->level--;
14891 : 0 : 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 [ + - ]: 37312 : if (
14899 : 37312 : (a = _loop0_103_rule(p)) // lambda_param_no_default*
14900 [ + + ]: 37312 : &&
14901 : 37312 : (b = _loop1_104_rule(p)) // lambda_param_with_default+
14902 [ + + ]: 312 : &&
14903 : 312 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
14904 [ + + ]: 68 : &&
14905 : 68 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
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 : 55 : _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
14910 [ - + - - ]: 55 : if (_res == NULL && PyErr_Occurred()) {
14911 : 0 : p->error_indicator = 1;
14912 : 0 : p->level--;
14913 : 0 : return NULL;
14914 : : }
14915 : 55 : goto done;
14916 : : }
14917 : 37257 : 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 [ + + ]: 37257 : if (p->error_indicator) {
14923 : 2 : p->level--;
14924 : 2 : 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 [ + - ]: 37255 : if (
14931 : 37255 : (a = _loop0_105_rule(p)) // lambda_param_no_default*
14932 [ + + ]: 37255 : &&
14933 : 37255 : (b = _loop1_106_rule(p)) // lambda_param_with_default+
14934 [ + + ]: 257 : &&
14935 : 257 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
14936 [ + + ]: 13 : &&
14937 : 13 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // 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 : 9 : _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
14942 [ - + - - ]: 9 : if (_res == NULL && PyErr_Occurred()) {
14943 : 0 : p->error_indicator = 1;
14944 : 0 : p->level--;
14945 : 0 : return NULL;
14946 : : }
14947 : 9 : goto done;
14948 : : }
14949 : 37246 : 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 : 37246 : _res = NULL;
14954 : 37310 : done:
14955 : 37310 : p->level--;
14956 : 37310 : 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 : 37276 : lambda_star_etc_rule(Parser *p)
14966 : : {
14967 [ - + ]: 37276 : if (p->level++ == MAXSTACK) {
14968 : 0 : p->error_indicator = 1;
14969 : : PyErr_NoMemory();
14970 : : }
14971 [ - + ]: 37276 : if (p->error_indicator) {
14972 : 0 : p->level--;
14973 : 0 : return NULL;
14974 : : }
14975 : 37276 : StarEtc* _res = NULL;
14976 : 37276 : int _mark = p->mark;
14977 [ + + ]: 37276 : if (p->call_invalid_rules) { // invalid_lambda_star_etc
14978 [ - + ]: 25 : if (p->error_indicator) {
14979 : 0 : p->level--;
14980 : 0 : 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 [ - + ]: 25 : if (
14985 : 25 : (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 : 0 : _res = invalid_lambda_star_etc_var;
14990 : 0 : goto done;
14991 : : }
14992 : 25 : 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 [ + + ]: 37276 : if (p->error_indicator) {
14998 : 6 : p->level--;
14999 : 6 : 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 [ + + ]: 37270 : if (
15007 : 37270 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
15008 [ + + ]: 400 : &&
15009 : 400 : (a = lambda_param_no_default_rule(p)) // lambda_param_no_default
15010 [ + - ]: 295 : &&
15011 : 295 : (b = _loop0_107_rule(p)) // lambda_param_maybe_default*
15012 : 295 : &&
15013 [ + + ]: 295 : (c = lambda_kwds_rule(p), !p->error_indicator) // 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 : 291 : _res = _PyPegen_star_etc ( p , a , b , c );
15018 [ - + - - ]: 291 : if (_res == NULL && PyErr_Occurred()) {
15019 : 0 : p->error_indicator = 1;
15020 : 0 : p->level--;
15021 : 0 : return NULL;
15022 : : }
15023 : 291 : goto done;
15024 : : }
15025 : 36979 : 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 [ + + ]: 36979 : if (p->error_indicator) {
15031 : 4 : p->level--;
15032 : 4 : 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 [ + + ]: 36975 : if (
15040 : 36975 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
15041 [ + + ]: 105 : &&
15042 : 105 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
15043 [ + + ]: 103 : &&
15044 : 103 : (b = _loop1_108_rule(p)) // lambda_param_maybe_default+
15045 : 102 : &&
15046 [ + - ]: 102 : (c = lambda_kwds_rule(p), !p->error_indicator) // 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 : 102 : _res = _PyPegen_star_etc ( p , NULL , b , c );
15051 [ - + - - ]: 102 : if (_res == NULL && PyErr_Occurred()) {
15052 : 0 : p->error_indicator = 1;
15053 : 0 : p->level--;
15054 : 0 : return NULL;
15055 : : }
15056 : 102 : goto done;
15057 : : }
15058 : 36873 : 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 [ - + ]: 36873 : if (p->error_indicator) {
15064 : 0 : p->level--;
15065 : 0 : 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 [ + + ]: 36873 : if (
15070 : 36873 : (a = lambda_kwds_rule(p)) // lambda_kwds
15071 : : )
15072 : : {
15073 : : D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_kwds"));
15074 : 19 : _res = _PyPegen_star_etc ( p , NULL , NULL , a );
15075 [ - + - - ]: 19 : if (_res == NULL && PyErr_Occurred()) {
15076 : 0 : p->error_indicator = 1;
15077 : 0 : p->level--;
15078 : 0 : return NULL;
15079 : : }
15080 : 19 : goto done;
15081 : : }
15082 : 36854 : 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 : 36854 : _res = NULL;
15087 : 37266 : done:
15088 : 37266 : p->level--;
15089 : 37266 : return _res;
15090 : : }
15091 : :
15092 : : // lambda_kwds: invalid_lambda_kwds | '**' lambda_param_no_default
15093 : : static arg_ty
15094 : 37270 : lambda_kwds_rule(Parser *p)
15095 : : {
15096 [ - + ]: 37270 : if (p->level++ == MAXSTACK) {
15097 : 0 : p->error_indicator = 1;
15098 : : PyErr_NoMemory();
15099 : : }
15100 [ - + ]: 37270 : if (p->error_indicator) {
15101 : 0 : p->level--;
15102 : 0 : return NULL;
15103 : : }
15104 : 37270 : arg_ty _res = NULL;
15105 : 37270 : int _mark = p->mark;
15106 [ + + ]: 37270 : if (p->call_invalid_rules) { // invalid_lambda_kwds
15107 [ - + ]: 19 : if (p->error_indicator) {
15108 : 0 : p->level--;
15109 : 0 : 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 [ - + ]: 19 : if (
15114 : 19 : (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 : 0 : _res = invalid_lambda_kwds_var;
15119 : 0 : goto done;
15120 : : }
15121 : 19 : 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 [ + + ]: 37270 : if (p->error_indicator) {
15127 : 7 : p->level--;
15128 : 7 : 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 [ + + ]: 37263 : if (
15134 : 37263 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
15135 [ + + ]: 125 : &&
15136 : 125 : (a = lambda_param_no_default_rule(p)) // 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 : 124 : _res = a;
15141 [ - + - - ]: 124 : if (_res == NULL && PyErr_Occurred()) {
15142 : 0 : p->error_indicator = 1;
15143 : 0 : p->level--;
15144 : 0 : return NULL;
15145 : : }
15146 : 124 : goto done;
15147 : : }
15148 : 37139 : 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 : 37139 : _res = NULL;
15153 : 37263 : done:
15154 : 37263 : p->level--;
15155 : 37263 : return _res;
15156 : : }
15157 : :
15158 : : // lambda_param_no_default: lambda_param ',' | lambda_param &':'
15159 : : static arg_ty
15160 : 1024906 : lambda_param_no_default_rule(Parser *p)
15161 : : {
15162 [ - + ]: 1024906 : if (p->level++ == MAXSTACK) {
15163 : 0 : p->error_indicator = 1;
15164 : : PyErr_NoMemory();
15165 : : }
15166 [ - + ]: 1024906 : if (p->error_indicator) {
15167 : 0 : p->level--;
15168 : 0 : return NULL;
15169 : : }
15170 : 1024906 : arg_ty _res = NULL;
15171 : 1024906 : int _mark = p->mark;
15172 : : { // lambda_param ','
15173 [ - + ]: 1024906 : if (p->error_indicator) {
15174 : 0 : p->level--;
15175 : 0 : 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 [ + + ]: 1024906 : if (
15181 : 1024906 : (a = lambda_param_rule(p)) // lambda_param
15182 [ + + ]: 839792 : &&
15183 : 839792 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
15184 : : )
15185 : : {
15186 : : D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param ','"));
15187 : 668916 : _res = a;
15188 [ - + - - ]: 668916 : if (_res == NULL && PyErr_Occurred()) {
15189 : 0 : p->error_indicator = 1;
15190 : 0 : p->level--;
15191 : 0 : return NULL;
15192 : : }
15193 : 668916 : goto done;
15194 : : }
15195 : 355990 : 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 [ - + ]: 355990 : if (p->error_indicator) {
15201 : 0 : p->level--;
15202 : 0 : 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 [ + + ]: 355990 : if (
15207 : 355990 : (a = lambda_param_rule(p)) // lambda_param
15208 [ + + ]: 170876 : &&
15209 : 170876 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':'
15210 : : )
15211 : : {
15212 : : D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param &':'"));
15213 : 169372 : _res = a;
15214 [ - + - - ]: 169372 : if (_res == NULL && PyErr_Occurred()) {
15215 : 0 : p->error_indicator = 1;
15216 : 0 : p->level--;
15217 : 0 : return NULL;
15218 : : }
15219 : 169372 : goto done;
15220 : : }
15221 : 186618 : 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 : 186618 : _res = NULL;
15226 : 1024906 : done:
15227 : 1024906 : p->level--;
15228 : 1024906 : return _res;
15229 : : }
15230 : :
15231 : : // lambda_param_with_default: lambda_param default ',' | lambda_param default &':'
15232 : : static NameDefaultPair*
15233 : 112861 : lambda_param_with_default_rule(Parser *p)
15234 : : {
15235 [ - + ]: 112861 : if (p->level++ == MAXSTACK) {
15236 : 0 : p->error_indicator = 1;
15237 : : PyErr_NoMemory();
15238 : : }
15239 [ - + ]: 112861 : if (p->error_indicator) {
15240 : 0 : p->level--;
15241 : 0 : return NULL;
15242 : : }
15243 : 112861 : NameDefaultPair* _res = NULL;
15244 : 112861 : int _mark = p->mark;
15245 : : { // lambda_param default ','
15246 [ - + ]: 112861 : if (p->error_indicator) {
15247 : 0 : p->level--;
15248 : 0 : 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 [ + + ]: 112861 : if (
15255 : 112861 : (a = lambda_param_rule(p)) // lambda_param
15256 [ + + ]: 1005 : &&
15257 : 1005 : (c = default_rule(p)) // default
15258 [ + + ]: 971 : &&
15259 : 971 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
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 : 353 : _res = _PyPegen_name_default_pair ( p , a , c , NULL );
15264 [ - + - - ]: 353 : if (_res == NULL && PyErr_Occurred()) {
15265 : 0 : p->error_indicator = 1;
15266 : 0 : p->level--;
15267 : 0 : return NULL;
15268 : : }
15269 : 353 : goto done;
15270 : : }
15271 : 112508 : 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 [ + + ]: 112508 : if (p->error_indicator) {
15277 : 2 : p->level--;
15278 : 2 : 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 [ + + ]: 112506 : if (
15284 : 112506 : (a = lambda_param_rule(p)) // lambda_param
15285 [ + + ]: 650 : &&
15286 : 650 : (c = default_rule(p)) // default
15287 [ + - ]: 618 : &&
15288 : 618 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':'
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 : 618 : _res = _PyPegen_name_default_pair ( p , a , c , NULL );
15293 [ - + - - ]: 618 : if (_res == NULL && PyErr_Occurred()) {
15294 : 0 : p->error_indicator = 1;
15295 : 0 : p->level--;
15296 : 0 : return NULL;
15297 : : }
15298 : 618 : goto done;
15299 : : }
15300 : 111888 : 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 : 111888 : _res = NULL;
15305 : 112859 : done:
15306 : 112859 : p->level--;
15307 : 112859 : return _res;
15308 : : }
15309 : :
15310 : : // lambda_param_maybe_default: lambda_param default? ',' | lambda_param default? &':'
15311 : : static NameDefaultPair*
15312 : 768 : lambda_param_maybe_default_rule(Parser *p)
15313 : : {
15314 [ - + ]: 768 : if (p->level++ == MAXSTACK) {
15315 : 0 : p->error_indicator = 1;
15316 : : PyErr_NoMemory();
15317 : : }
15318 [ - + ]: 768 : if (p->error_indicator) {
15319 : 0 : p->level--;
15320 : 0 : return NULL;
15321 : : }
15322 : 768 : NameDefaultPair* _res = NULL;
15323 : 768 : int _mark = p->mark;
15324 : : { // lambda_param default? ','
15325 [ - + ]: 768 : if (p->error_indicator) {
15326 : 0 : p->level--;
15327 : 0 : 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 [ + + ]: 768 : if (
15334 : 768 : (a = lambda_param_rule(p)) // lambda_param
15335 : 280 : &&
15336 [ + - ]: 280 : (c = default_rule(p), !p->error_indicator) // default?
15337 [ + + ]: 280 : &&
15338 : 280 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
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 : 186 : _res = _PyPegen_name_default_pair ( p , a , c , NULL );
15343 [ - + - - ]: 186 : if (_res == NULL && PyErr_Occurred()) {
15344 : 0 : p->error_indicator = 1;
15345 : 0 : p->level--;
15346 : 0 : return NULL;
15347 : : }
15348 : 186 : goto done;
15349 : : }
15350 : 582 : 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 [ - + ]: 582 : if (p->error_indicator) {
15356 : 0 : p->level--;
15357 : 0 : 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 [ + + ]: 582 : if (
15363 : 582 : (a = lambda_param_rule(p)) // lambda_param
15364 : 94 : &&
15365 [ + - ]: 94 : (c = default_rule(p), !p->error_indicator) // default?
15366 [ + + ]: 94 : &&
15367 : 94 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // 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 : 92 : _res = _PyPegen_name_default_pair ( p , a , c , NULL );
15372 [ - + - - ]: 92 : if (_res == NULL && PyErr_Occurred()) {
15373 : 0 : p->error_indicator = 1;
15374 : 0 : p->level--;
15375 : 0 : return NULL;
15376 : : }
15377 : 92 : goto done;
15378 : : }
15379 : 490 : 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 : 490 : _res = NULL;
15384 : 768 : done:
15385 : 768 : p->level--;
15386 : 768 : return _res;
15387 : : }
15388 : :
15389 : : // lambda_param: NAME
15390 : : static arg_ty
15391 : 1607658 : lambda_param_rule(Parser *p)
15392 : : {
15393 [ - + ]: 1607658 : if (p->level++ == MAXSTACK) {
15394 : 0 : p->error_indicator = 1;
15395 : : PyErr_NoMemory();
15396 : : }
15397 [ - + ]: 1607658 : if (p->error_indicator) {
15398 : 0 : p->level--;
15399 : 0 : return NULL;
15400 : : }
15401 : 1607658 : arg_ty _res = NULL;
15402 : 1607658 : int _mark = p->mark;
15403 [ + + - + ]: 1607658 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
15404 : 0 : p->error_indicator = 1;
15405 : 0 : p->level--;
15406 : 0 : return NULL;
15407 : : }
15408 : 1607658 : int _start_lineno = p->tokens[_mark]->lineno;
15409 : : UNUSED(_start_lineno); // Only used by EXTRA macro
15410 : 1607658 : int _start_col_offset = p->tokens[_mark]->col_offset;
15411 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
15412 : : { // NAME
15413 [ - + ]: 1607658 : if (p->error_indicator) {
15414 : 0 : p->level--;
15415 : 0 : 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 [ + + ]: 1607658 : if (
15420 : 1607658 : (a = _PyPegen_name_token(p)) // NAME
15421 : : )
15422 : : {
15423 : : D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
15424 : 1012737 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15425 [ - + ]: 1012737 : if (_token == NULL) {
15426 : 0 : p->level--;
15427 : 0 : return NULL;
15428 : : }
15429 : 1012737 : int _end_lineno = _token->end_lineno;
15430 : : UNUSED(_end_lineno); // Only used by EXTRA macro
15431 : 1012737 : int _end_col_offset = _token->end_col_offset;
15432 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
15433 : 1012737 : _res = _PyAST_arg ( a -> v . Name . id , NULL , NULL , EXTRA );
15434 [ - + - - ]: 1012737 : if (_res == NULL && PyErr_Occurred()) {
15435 : 0 : p->error_indicator = 1;
15436 : 0 : p->level--;
15437 : 0 : return NULL;
15438 : : }
15439 : 1012737 : goto done;
15440 : : }
15441 : 594921 : 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 : 594921 : _res = NULL;
15446 : 1607658 : done:
15447 : 1607658 : p->level--;
15448 : 1607658 : return _res;
15449 : : }
15450 : :
15451 : : // strings: STRING+
15452 : : static expr_ty
15453 : 3411414 : strings_rule(Parser *p)
15454 : : {
15455 [ - + ]: 3411414 : if (p->level++ == MAXSTACK) {
15456 : 0 : p->error_indicator = 1;
15457 : : PyErr_NoMemory();
15458 : : }
15459 [ - + ]: 3411414 : if (p->error_indicator) {
15460 : 0 : p->level--;
15461 : 0 : return NULL;
15462 : : }
15463 : 3411414 : expr_ty _res = NULL;
15464 [ + + ]: 3411414 : if (_PyPegen_is_memoized(p, strings_type, &_res)) {
15465 : 1807252 : p->level--;
15466 : 1807252 : return _res;
15467 : : }
15468 : 1604162 : int _mark = p->mark;
15469 : : { // STRING+
15470 [ - + ]: 1604162 : if (p->error_indicator) {
15471 : 0 : p->level--;
15472 : 0 : return NULL;
15473 : : }
15474 : : D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING+"));
15475 : : asdl_seq * a;
15476 [ + + ]: 1604162 : if (
15477 : 1604162 : (a = _loop1_109_rule(p)) // STRING+
15478 : : )
15479 : : {
15480 : : D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING+"));
15481 : 1600817 : _res = _PyPegen_concatenate_strings ( p , a );
15482 [ + + + - ]: 1600817 : if (_res == NULL && PyErr_Occurred()) {
15483 : 767 : p->error_indicator = 1;
15484 : 767 : p->level--;
15485 : 767 : return NULL;
15486 : : }
15487 : 1600050 : goto done;
15488 : : }
15489 : 3345 : 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 : 3345 : _res = NULL;
15494 : 1603395 : done:
15495 : 1603395 : _PyPegen_insert_memo(p, _mark, strings_type, _res);
15496 : 1603395 : p->level--;
15497 : 1603395 : return _res;
15498 : : }
15499 : :
15500 : : // list: '[' star_named_expressions? ']'
15501 : : static expr_ty
15502 : 263549 : list_rule(Parser *p)
15503 : : {
15504 [ - + ]: 263549 : if (p->level++ == MAXSTACK) {
15505 : 0 : p->error_indicator = 1;
15506 : : PyErr_NoMemory();
15507 : : }
15508 [ - + ]: 263549 : if (p->error_indicator) {
15509 : 0 : p->level--;
15510 : 0 : return NULL;
15511 : : }
15512 : 263549 : expr_ty _res = NULL;
15513 : 263549 : int _mark = p->mark;
15514 [ - + - - ]: 263549 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
15515 : 0 : p->error_indicator = 1;
15516 : 0 : p->level--;
15517 : 0 : return NULL;
15518 : : }
15519 : 263549 : int _start_lineno = p->tokens[_mark]->lineno;
15520 : : UNUSED(_start_lineno); // Only used by EXTRA macro
15521 : 263549 : int _start_col_offset = p->tokens[_mark]->col_offset;
15522 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
15523 : : { // '[' star_named_expressions? ']'
15524 [ - + ]: 263549 : if (p->error_indicator) {
15525 : 0 : p->level--;
15526 : 0 : 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 [ + + ]: 263549 : if (
15533 : 263549 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
15534 : 261422 : &&
15535 [ + + ]: 261422 : (a = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions?
15536 [ + + ]: 261388 : &&
15537 : 261388 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
15538 : : )
15539 : : {
15540 : : D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'"));
15541 : 232152 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15542 [ - + ]: 232152 : if (_token == NULL) {
15543 : 0 : p->level--;
15544 : 0 : return NULL;
15545 : : }
15546 : 232152 : int _end_lineno = _token->end_lineno;
15547 : : UNUSED(_end_lineno); // Only used by EXTRA macro
15548 : 232152 : int _end_col_offset = _token->end_col_offset;
15549 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
15550 : 232152 : _res = _PyAST_List ( a , Load , EXTRA );
15551 [ - + - - ]: 232152 : if (_res == NULL && PyErr_Occurred()) {
15552 : 0 : p->error_indicator = 1;
15553 : 0 : p->level--;
15554 : 0 : return NULL;
15555 : : }
15556 : 232152 : goto done;
15557 : : }
15558 : 31397 : 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 : 31397 : _res = NULL;
15563 : 263549 : done:
15564 : 263549 : p->level--;
15565 : 263549 : return _res;
15566 : : }
15567 : :
15568 : : // tuple: '(' [star_named_expression ',' star_named_expressions?] ')'
15569 : : static expr_ty
15570 : 865839 : tuple_rule(Parser *p)
15571 : : {
15572 [ - + ]: 865839 : if (p->level++ == MAXSTACK) {
15573 : 0 : p->error_indicator = 1;
15574 : : PyErr_NoMemory();
15575 : : }
15576 [ - + ]: 865839 : if (p->error_indicator) {
15577 : 0 : p->level--;
15578 : 0 : return NULL;
15579 : : }
15580 : 865839 : expr_ty _res = NULL;
15581 : 865839 : int _mark = p->mark;
15582 [ - + - - ]: 865839 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
15583 : 0 : p->error_indicator = 1;
15584 : 0 : p->level--;
15585 : 0 : return NULL;
15586 : : }
15587 : 865839 : int _start_lineno = p->tokens[_mark]->lineno;
15588 : : UNUSED(_start_lineno); // Only used by EXTRA macro
15589 : 865839 : 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 [ - + ]: 865839 : if (p->error_indicator) {
15593 : 0 : p->level--;
15594 : 0 : 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 [ + + ]: 865839 : if (
15601 : 865839 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
15602 : 863752 : &&
15603 [ + + ]: 863752 : (a = _tmp_110_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?]
15604 [ + + ]: 863700 : &&
15605 : 863700 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
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 : 569927 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15610 [ - + ]: 569927 : if (_token == NULL) {
15611 : 0 : p->level--;
15612 : 0 : return NULL;
15613 : : }
15614 : 569927 : int _end_lineno = _token->end_lineno;
15615 : : UNUSED(_end_lineno); // Only used by EXTRA macro
15616 : 569927 : int _end_col_offset = _token->end_col_offset;
15617 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
15618 : 569927 : _res = _PyAST_Tuple ( a , Load , EXTRA );
15619 [ - + - - ]: 569927 : if (_res == NULL && PyErr_Occurred()) {
15620 : 0 : p->error_indicator = 1;
15621 : 0 : p->level--;
15622 : 0 : return NULL;
15623 : : }
15624 : 569927 : goto done;
15625 : : }
15626 : 295912 : 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 : 295912 : _res = NULL;
15631 : 865839 : done:
15632 : 865839 : p->level--;
15633 : 865839 : return _res;
15634 : : }
15635 : :
15636 : : // set: '{' star_named_expressions '}'
15637 : : static expr_ty
15638 : 13763 : set_rule(Parser *p)
15639 : : {
15640 [ - + ]: 13763 : if (p->level++ == MAXSTACK) {
15641 : 0 : p->error_indicator = 1;
15642 : : PyErr_NoMemory();
15643 : : }
15644 [ - + ]: 13763 : if (p->error_indicator) {
15645 : 0 : p->level--;
15646 : 0 : return NULL;
15647 : : }
15648 : 13763 : expr_ty _res = NULL;
15649 : 13763 : int _mark = p->mark;
15650 [ - + - - ]: 13763 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
15651 : 0 : p->error_indicator = 1;
15652 : 0 : p->level--;
15653 : 0 : return NULL;
15654 : : }
15655 : 13763 : int _start_lineno = p->tokens[_mark]->lineno;
15656 : : UNUSED(_start_lineno); // Only used by EXTRA macro
15657 : 13763 : int _start_col_offset = p->tokens[_mark]->col_offset;
15658 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
15659 : : { // '{' star_named_expressions '}'
15660 [ - + ]: 13763 : if (p->error_indicator) {
15661 : 0 : p->level--;
15662 : 0 : 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 [ + - ]: 13763 : if (
15669 : 13763 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
15670 [ + + ]: 13763 : &&
15671 : 13763 : (a = star_named_expressions_rule(p)) // star_named_expressions
15672 [ + + ]: 13730 : &&
15673 : 13730 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
15674 : : )
15675 : : {
15676 : : D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'"));
15677 : 8391 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15678 [ - + ]: 8391 : if (_token == NULL) {
15679 : 0 : p->level--;
15680 : 0 : return NULL;
15681 : : }
15682 : 8391 : int _end_lineno = _token->end_lineno;
15683 : : UNUSED(_end_lineno); // Only used by EXTRA macro
15684 : 8391 : int _end_col_offset = _token->end_col_offset;
15685 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
15686 : 8391 : _res = _PyAST_Set ( a , EXTRA );
15687 [ - + - - ]: 8391 : if (_res == NULL && PyErr_Occurred()) {
15688 : 0 : p->error_indicator = 1;
15689 : 0 : p->level--;
15690 : 0 : return NULL;
15691 : : }
15692 : 8391 : goto done;
15693 : : }
15694 : 5372 : 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 : 5372 : _res = NULL;
15699 : 13763 : done:
15700 : 13763 : p->level--;
15701 : 13763 : return _res;
15702 : : }
15703 : :
15704 : : // dict: '{' double_starred_kvpairs? '}' | '{' invalid_double_starred_kvpairs '}'
15705 : : static expr_ty
15706 : 112968 : dict_rule(Parser *p)
15707 : : {
15708 [ - + ]: 112968 : if (p->level++ == MAXSTACK) {
15709 : 0 : p->error_indicator = 1;
15710 : : PyErr_NoMemory();
15711 : : }
15712 [ - + ]: 112968 : if (p->error_indicator) {
15713 : 0 : p->level--;
15714 : 0 : return NULL;
15715 : : }
15716 : 112968 : expr_ty _res = NULL;
15717 : 112968 : int _mark = p->mark;
15718 [ - + - - ]: 112968 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
15719 : 0 : p->error_indicator = 1;
15720 : 0 : p->level--;
15721 : 0 : return NULL;
15722 : : }
15723 : 112968 : int _start_lineno = p->tokens[_mark]->lineno;
15724 : : UNUSED(_start_lineno); // Only used by EXTRA macro
15725 : 112968 : int _start_col_offset = p->tokens[_mark]->col_offset;
15726 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
15727 : : { // '{' double_starred_kvpairs? '}'
15728 [ - + ]: 112968 : if (p->error_indicator) {
15729 : 0 : p->level--;
15730 : 0 : 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 [ + - ]: 112968 : if (
15737 : 112968 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
15738 : 112968 : &&
15739 [ + + ]: 112968 : (a = double_starred_kvpairs_rule(p), !p->error_indicator) // double_starred_kvpairs?
15740 [ + + ]: 112942 : &&
15741 : 112942 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
15742 : : )
15743 : : {
15744 : : D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
15745 : 99173 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15746 [ - + ]: 99173 : if (_token == NULL) {
15747 : 0 : p->level--;
15748 : 0 : return NULL;
15749 : : }
15750 : 99173 : int _end_lineno = _token->end_lineno;
15751 : : UNUSED(_end_lineno); // Only used by EXTRA macro
15752 : 99173 : int _end_col_offset = _token->end_col_offset;
15753 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
15754 : 99173 : _res = _PyAST_Dict ( CHECK ( asdl_expr_seq* , _PyPegen_get_keys ( p , a ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_values ( p , a ) ) , EXTRA );
15755 [ - + - - ]: 99173 : if (_res == NULL && PyErr_Occurred()) {
15756 : 0 : p->error_indicator = 1;
15757 : 0 : p->level--;
15758 : 0 : return NULL;
15759 : : }
15760 : 99173 : goto done;
15761 : : }
15762 : 13795 : 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 [ + + ]: 13795 : if (p->error_indicator) {
15768 : 26 : p->level--;
15769 : 26 : 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 [ + - ]: 13769 : if (
15776 : 13769 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
15777 [ - + ]: 13769 : &&
15778 : 13769 : (invalid_double_starred_kvpairs_var = invalid_double_starred_kvpairs_rule(p)) // invalid_double_starred_kvpairs
15779 [ # # ]: 0 : &&
15780 : 0 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
15781 : : )
15782 : : {
15783 : : D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'"));
15784 : 0 : _res = _PyPegen_dummy_name(p, _literal, invalid_double_starred_kvpairs_var, _literal_1);
15785 : 0 : goto done;
15786 : : }
15787 : 13769 : 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 : 13769 : _res = NULL;
15792 : 112942 : done:
15793 : 112942 : p->level--;
15794 : 112942 : return _res;
15795 : : }
15796 : :
15797 : : // double_starred_kvpairs: ','.double_starred_kvpair+ ','?
15798 : : static asdl_seq*
15799 : 112968 : double_starred_kvpairs_rule(Parser *p)
15800 : : {
15801 [ - + ]: 112968 : if (p->level++ == MAXSTACK) {
15802 : 0 : p->error_indicator = 1;
15803 : : PyErr_NoMemory();
15804 : : }
15805 [ - + ]: 112968 : if (p->error_indicator) {
15806 : 0 : p->level--;
15807 : 0 : return NULL;
15808 : : }
15809 : 112968 : asdl_seq* _res = NULL;
15810 : 112968 : int _mark = p->mark;
15811 : : { // ','.double_starred_kvpair+ ','?
15812 [ - + ]: 112968 : if (p->error_indicator) {
15813 : 0 : p->level--;
15814 : 0 : 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 [ + + ]: 112968 : if (
15821 : 112968 : (a = _gather_111_rule(p)) // ','.double_starred_kvpair+
15822 : 65085 : &&
15823 [ + + ]: 65085 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
15824 : : )
15825 : : {
15826 : : D(fprintf(stderr, "%*c+ double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?"));
15827 : 65072 : _res = a;
15828 [ - + - - ]: 65072 : if (_res == NULL && PyErr_Occurred()) {
15829 : 0 : p->error_indicator = 1;
15830 : 0 : p->level--;
15831 : 0 : return NULL;
15832 : : }
15833 : 65072 : goto done;
15834 : : }
15835 : 47896 : 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 : 47896 : _res = NULL;
15840 : 112968 : done:
15841 : 112968 : p->level--;
15842 : 112968 : return _res;
15843 : : }
15844 : :
15845 : : // double_starred_kvpair: '**' bitwise_or | kvpair
15846 : : static KeyValuePair*
15847 : 1608586 : double_starred_kvpair_rule(Parser *p)
15848 : : {
15849 [ - + ]: 1608586 : if (p->level++ == MAXSTACK) {
15850 : 0 : p->error_indicator = 1;
15851 : : PyErr_NoMemory();
15852 : : }
15853 [ - + ]: 1608586 : if (p->error_indicator) {
15854 : 0 : p->level--;
15855 : 0 : return NULL;
15856 : : }
15857 : 1608586 : KeyValuePair* _res = NULL;
15858 : 1608586 : int _mark = p->mark;
15859 : : { // '**' bitwise_or
15860 [ - + ]: 1608586 : if (p->error_indicator) {
15861 : 0 : p->level--;
15862 : 0 : 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 [ + + ]: 1608586 : if (
15868 : 1608586 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
15869 [ + - ]: 3093 : &&
15870 : 3093 : (a = bitwise_or_rule(p)) // bitwise_or
15871 : : )
15872 : : {
15873 : : D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or"));
15874 : 3093 : _res = _PyPegen_key_value_pair ( p , NULL , a );
15875 [ - + - - ]: 3093 : if (_res == NULL && PyErr_Occurred()) {
15876 : 0 : p->error_indicator = 1;
15877 : 0 : p->level--;
15878 : 0 : return NULL;
15879 : : }
15880 : 3093 : goto done;
15881 : : }
15882 : 1605493 : 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 [ + + ]: 1605493 : if (p->error_indicator) {
15888 : 12 : p->level--;
15889 : 12 : 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 [ + + ]: 1605481 : if (
15894 : 1605481 : (kvpair_var = kvpair_rule(p)) // kvpair
15895 : : )
15896 : : {
15897 : : D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kvpair"));
15898 : 1525156 : _res = kvpair_var;
15899 : 1525156 : goto done;
15900 : : }
15901 : 80325 : 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 : 80325 : _res = NULL;
15906 : 1608574 : done:
15907 : 1608574 : p->level--;
15908 : 1608574 : return _res;
15909 : : }
15910 : :
15911 : : // kvpair: expression ':' expression
15912 : : static KeyValuePair*
15913 : 1610848 : kvpair_rule(Parser *p)
15914 : : {
15915 [ - + ]: 1610848 : if (p->level++ == MAXSTACK) {
15916 : 0 : p->error_indicator = 1;
15917 : : PyErr_NoMemory();
15918 : : }
15919 [ - + ]: 1610848 : if (p->error_indicator) {
15920 : 0 : p->level--;
15921 : 0 : return NULL;
15922 : : }
15923 : 1610848 : KeyValuePair* _res = NULL;
15924 : 1610848 : int _mark = p->mark;
15925 : : { // expression ':' expression
15926 [ - + ]: 1610848 : if (p->error_indicator) {
15927 : 0 : p->level--;
15928 : 0 : 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 [ + + ]: 1610848 : if (
15935 : 1610848 : (a = expression_rule(p)) // expression
15936 [ + + ]: 1550300 : &&
15937 : 1550300 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
15938 [ + + ]: 1528997 : &&
15939 : 1528997 : (b = expression_rule(p)) // expression
15940 : : )
15941 : : {
15942 : : D(fprintf(stderr, "%*c+ kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
15943 : 1528942 : _res = _PyPegen_key_value_pair ( p , a , b );
15944 [ - + - - ]: 1528942 : if (_res == NULL && PyErr_Occurred()) {
15945 : 0 : p->error_indicator = 1;
15946 : 0 : p->level--;
15947 : 0 : return NULL;
15948 : : }
15949 : 1528942 : goto done;
15950 : : }
15951 : 81906 : 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 : 81906 : _res = NULL;
15956 : 1610848 : done:
15957 : 1610848 : p->level--;
15958 : 1610848 : return _res;
15959 : : }
15960 : :
15961 : : // for_if_clauses: for_if_clause+
15962 : : static asdl_comprehension_seq*
15963 : 2124538 : for_if_clauses_rule(Parser *p)
15964 : : {
15965 [ - + ]: 2124538 : if (p->level++ == MAXSTACK) {
15966 : 0 : p->error_indicator = 1;
15967 : : PyErr_NoMemory();
15968 : : }
15969 [ - + ]: 2124538 : if (p->error_indicator) {
15970 : 0 : p->level--;
15971 : 0 : return NULL;
15972 : : }
15973 : 2124538 : asdl_comprehension_seq* _res = NULL;
15974 : 2124538 : int _mark = p->mark;
15975 : : { // for_if_clause+
15976 [ - + ]: 2124538 : if (p->error_indicator) {
15977 : 0 : p->level--;
15978 : 0 : 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 [ + + ]: 2124538 : if (
15983 : 2124538 : (a = (asdl_comprehension_seq*)_loop1_113_rule(p)) // for_if_clause+
15984 : : )
15985 : : {
15986 : : D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "for_if_clause+"));
15987 : 49628 : _res = a;
15988 [ - + - - ]: 49628 : if (_res == NULL && PyErr_Occurred()) {
15989 : 0 : p->error_indicator = 1;
15990 : 0 : p->level--;
15991 : 0 : return NULL;
15992 : : }
15993 : 49628 : goto done;
15994 : : }
15995 : 2074910 : 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 : 2074910 : _res = NULL;
16000 : 2124538 : done:
16001 : 2124538 : p->level--;
16002 : 2124538 : 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 : 2176116 : for_if_clause_rule(Parser *p)
16011 : : {
16012 [ - + ]: 2176116 : if (p->level++ == MAXSTACK) {
16013 : 0 : p->error_indicator = 1;
16014 : : PyErr_NoMemory();
16015 : : }
16016 [ - + ]: 2176116 : if (p->error_indicator) {
16017 : 0 : p->level--;
16018 : 0 : return NULL;
16019 : : }
16020 : 2176116 : comprehension_ty _res = NULL;
16021 : 2176116 : int _mark = p->mark;
16022 : : { // ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
16023 [ - + ]: 2176116 : if (p->error_indicator) {
16024 : 0 : p->level--;
16025 : 0 : 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 : 2176116 : 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 [ + + ]: 2176116 : if (
16036 : 2176116 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
16037 [ + - ]: 508 : &&
16038 : 508 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
16039 [ + - ]: 508 : &&
16040 : 508 : (a = star_targets_rule(p)) // star_targets
16041 [ + - ]: 508 : &&
16042 : 508 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
16043 : : &&
16044 : 508 : (_cut_var = 1)
16045 [ + - ]: 508 : &&
16046 : 508 : (b = disjunction_rule(p)) // disjunction
16047 [ + - ]: 508 : &&
16048 : 508 : (c = (asdl_expr_seq*)_loop0_114_rule(p)) // (('if' disjunction))*
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 : 508 : _res = CHECK_VERSION ( comprehension_ty , 6 , "Async comprehensions are" , _PyAST_comprehension ( a , b , c , 1 , p -> arena ) );
16053 [ + + + - ]: 508 : if (_res == NULL && PyErr_Occurred()) {
16054 : 2 : p->error_indicator = 1;
16055 : 2 : p->level--;
16056 : 2 : return NULL;
16057 : : }
16058 : 506 : goto done;
16059 : : }
16060 : 2175608 : 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 [ - + ]: 2175608 : if (_cut_var) {
16064 : 0 : p->level--;
16065 : 0 : return NULL;
16066 : : }
16067 : : }
16068 : : { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
16069 [ - + ]: 2175608 : if (p->error_indicator) {
16070 : 0 : p->level--;
16071 : 0 : 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 : 2175608 : 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 [ + + ]: 2175608 : if (
16081 : 2175608 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
16082 [ + + ]: 51093 : &&
16083 : 51093 : (a = star_targets_rule(p)) // star_targets
16084 [ + + ]: 51089 : &&
16085 : 51089 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
16086 : : &&
16087 : 51080 : (_cut_var = 1)
16088 [ + + ]: 51080 : &&
16089 : 51080 : (b = disjunction_rule(p)) // disjunction
16090 [ + - ]: 51072 : &&
16091 : 51072 : (c = (asdl_expr_seq*)_loop0_115_rule(p)) // (('if' disjunction))*
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 : 51072 : _res = _PyAST_comprehension ( a , b , c , 0 , p -> arena );
16096 [ - + - - ]: 51072 : if (_res == NULL && PyErr_Occurred()) {
16097 : 0 : p->error_indicator = 1;
16098 : 0 : p->level--;
16099 : 0 : return NULL;
16100 : : }
16101 : 51072 : goto done;
16102 : : }
16103 : 2124536 : 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 [ + + ]: 2124536 : if (_cut_var) {
16107 : 8 : p->level--;
16108 : 8 : return NULL;
16109 : : }
16110 : : }
16111 [ + + ]: 2124528 : if (p->call_invalid_rules) { // invalid_for_target
16112 [ - + ]: 488 : if (p->error_indicator) {
16113 : 0 : p->level--;
16114 : 0 : 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 [ - + ]: 488 : if (
16119 : 488 : (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target
16120 : : )
16121 : : {
16122 : : D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
16123 : 0 : _res = invalid_for_target_var;
16124 : 0 : goto done;
16125 : : }
16126 : 488 : 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 : 2124528 : _res = NULL;
16131 : 2176106 : done:
16132 : 2176106 : p->level--;
16133 : 2176106 : return _res;
16134 : : }
16135 : :
16136 : : // listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension
16137 : : static expr_ty
16138 : 29223 : listcomp_rule(Parser *p)
16139 : : {
16140 [ - + ]: 29223 : if (p->level++ == MAXSTACK) {
16141 : 0 : p->error_indicator = 1;
16142 : : PyErr_NoMemory();
16143 : : }
16144 [ - + ]: 29223 : if (p->error_indicator) {
16145 : 0 : p->level--;
16146 : 0 : return NULL;
16147 : : }
16148 : 29223 : expr_ty _res = NULL;
16149 : 29223 : int _mark = p->mark;
16150 [ - + - - ]: 29223 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16151 : 0 : p->error_indicator = 1;
16152 : 0 : p->level--;
16153 : 0 : return NULL;
16154 : : }
16155 : 29223 : int _start_lineno = p->tokens[_mark]->lineno;
16156 : : UNUSED(_start_lineno); // Only used by EXTRA macro
16157 : 29223 : 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 [ - + ]: 29223 : if (p->error_indicator) {
16161 : 0 : p->level--;
16162 : 0 : 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 [ + - ]: 29223 : if (
16170 : 29223 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
16171 [ + + ]: 29223 : &&
16172 : 29223 : (a = named_expression_rule(p)) // named_expression
16173 [ + + ]: 29180 : &&
16174 : 29180 : (b = for_if_clauses_rule(p)) // for_if_clauses
16175 [ + + ]: 29138 : &&
16176 : 29138 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
16177 : : )
16178 : : {
16179 : : D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' named_expression for_if_clauses ']'"));
16180 : 29134 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16181 [ - + ]: 29134 : if (_token == NULL) {
16182 : 0 : p->level--;
16183 : 0 : return NULL;
16184 : : }
16185 : 29134 : int _end_lineno = _token->end_lineno;
16186 : : UNUSED(_end_lineno); // Only used by EXTRA macro
16187 : 29134 : int _end_col_offset = _token->end_col_offset;
16188 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
16189 : 29134 : _res = _PyAST_ListComp ( a , b , EXTRA );
16190 [ - + - - ]: 29134 : if (_res == NULL && PyErr_Occurred()) {
16191 : 0 : p->error_indicator = 1;
16192 : 0 : p->level--;
16193 : 0 : return NULL;
16194 : : }
16195 : 29134 : goto done;
16196 : : }
16197 : 89 : 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 [ + + ]: 89 : if (p->call_invalid_rules) { // invalid_comprehension
16202 [ + + ]: 17 : if (p->error_indicator) {
16203 : 3 : p->level--;
16204 : 3 : 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 [ - + ]: 14 : if (
16209 : 14 : (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 : 0 : _res = invalid_comprehension_var;
16214 : 0 : goto done;
16215 : : }
16216 : 14 : 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 : 86 : _res = NULL;
16221 : 29220 : done:
16222 : 29220 : p->level--;
16223 : 29220 : return _res;
16224 : : }
16225 : :
16226 : : // setcomp: '{' named_expression for_if_clauses '}' | invalid_comprehension
16227 : : static expr_ty
16228 : 1586 : setcomp_rule(Parser *p)
16229 : : {
16230 [ - + ]: 1586 : if (p->level++ == MAXSTACK) {
16231 : 0 : p->error_indicator = 1;
16232 : : PyErr_NoMemory();
16233 : : }
16234 [ - + ]: 1586 : if (p->error_indicator) {
16235 : 0 : p->level--;
16236 : 0 : return NULL;
16237 : : }
16238 : 1586 : expr_ty _res = NULL;
16239 : 1586 : int _mark = p->mark;
16240 [ - + - - ]: 1586 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16241 : 0 : p->error_indicator = 1;
16242 : 0 : p->level--;
16243 : 0 : return NULL;
16244 : : }
16245 : 1586 : int _start_lineno = p->tokens[_mark]->lineno;
16246 : : UNUSED(_start_lineno); // Only used by EXTRA macro
16247 : 1586 : 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 [ - + ]: 1586 : if (p->error_indicator) {
16251 : 0 : p->level--;
16252 : 0 : 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 [ + - ]: 1586 : if (
16260 : 1586 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
16261 [ + + ]: 1586 : &&
16262 : 1586 : (a = named_expression_rule(p)) // named_expression
16263 [ + + ]: 1559 : &&
16264 : 1559 : (b = for_if_clauses_rule(p)) // for_if_clauses
16265 [ + - ]: 1528 : &&
16266 : 1528 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
16267 : : )
16268 : : {
16269 : : D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' named_expression for_if_clauses '}'"));
16270 : 1528 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16271 [ - + ]: 1528 : if (_token == NULL) {
16272 : 0 : p->level--;
16273 : 0 : return NULL;
16274 : : }
16275 : 1528 : int _end_lineno = _token->end_lineno;
16276 : : UNUSED(_end_lineno); // Only used by EXTRA macro
16277 : 1528 : int _end_col_offset = _token->end_col_offset;
16278 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
16279 : 1528 : _res = _PyAST_SetComp ( a , b , EXTRA );
16280 [ - + - - ]: 1528 : if (_res == NULL && PyErr_Occurred()) {
16281 : 0 : p->error_indicator = 1;
16282 : 0 : p->level--;
16283 : 0 : return NULL;
16284 : : }
16285 : 1528 : goto done;
16286 : : }
16287 : 58 : 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 [ + + ]: 58 : if (p->call_invalid_rules) { // invalid_comprehension
16292 [ - + ]: 30 : if (p->error_indicator) {
16293 : 0 : p->level--;
16294 : 0 : 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 [ - + ]: 30 : if (
16299 : 30 : (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 : 0 : _res = invalid_comprehension_var;
16304 : 0 : goto done;
16305 : : }
16306 : 30 : 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 : 58 : _res = NULL;
16311 : 1586 : done:
16312 : 1586 : p->level--;
16313 : 1586 : return _res;
16314 : : }
16315 : :
16316 : : // genexp:
16317 : : // | '(' (assignment_expression | expression !':=') for_if_clauses ')'
16318 : : // | invalid_comprehension
16319 : : static expr_ty
16320 : 14494473 : genexp_rule(Parser *p)
16321 : : {
16322 [ - + ]: 14494473 : if (p->level++ == MAXSTACK) {
16323 : 0 : p->error_indicator = 1;
16324 : : PyErr_NoMemory();
16325 : : }
16326 [ - + ]: 14494473 : if (p->error_indicator) {
16327 : 0 : p->level--;
16328 : 0 : return NULL;
16329 : : }
16330 : 14494473 : expr_ty _res = NULL;
16331 : 14494473 : int _mark = p->mark;
16332 [ - + - - ]: 14494473 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16333 : 0 : p->error_indicator = 1;
16334 : 0 : p->level--;
16335 : 0 : return NULL;
16336 : : }
16337 : 14494473 : int _start_lineno = p->tokens[_mark]->lineno;
16338 : : UNUSED(_start_lineno); // Only used by EXTRA macro
16339 : 14494473 : 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 [ - + ]: 14494473 : if (p->error_indicator) {
16343 : 0 : p->level--;
16344 : 0 : 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 [ + + ]: 14494473 : if (
16352 : 14494473 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
16353 [ + + ]: 3090425 : &&
16354 : 3090425 : (a = _tmp_116_rule(p)) // assignment_expression | expression !':='
16355 [ + + ]: 2089737 : &&
16356 : 2089737 : (b = for_if_clauses_rule(p)) // for_if_clauses
16357 [ + + ]: 15148 : &&
16358 : 15148 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
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 : 15114 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16363 [ - + ]: 15114 : if (_token == NULL) {
16364 : 0 : p->level--;
16365 : 0 : return NULL;
16366 : : }
16367 : 15114 : int _end_lineno = _token->end_lineno;
16368 : : UNUSED(_end_lineno); // Only used by EXTRA macro
16369 : 15114 : int _end_col_offset = _token->end_col_offset;
16370 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
16371 : 15114 : _res = _PyAST_GeneratorExp ( a , b , EXTRA );
16372 [ - + - - ]: 15114 : if (_res == NULL && PyErr_Occurred()) {
16373 : 0 : p->error_indicator = 1;
16374 : 0 : p->level--;
16375 : 0 : return NULL;
16376 : : }
16377 : 15114 : goto done;
16378 : : }
16379 : 14479359 : 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 [ + + ]: 14479359 : if (p->call_invalid_rules) { // invalid_comprehension
16384 [ - + ]: 2862 : if (p->error_indicator) {
16385 : 0 : p->level--;
16386 : 0 : 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 [ - + ]: 2862 : if (
16391 : 2862 : (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension
16392 : : )
16393 : : {
16394 : : D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
16395 : 0 : _res = invalid_comprehension_var;
16396 : 0 : goto done;
16397 : : }
16398 : 2862 : 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 : 14479359 : _res = NULL;
16403 : 14494473 : done:
16404 : 14494473 : p->level--;
16405 : 14494473 : return _res;
16406 : : }
16407 : :
16408 : : // dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension
16409 : : static expr_ty
16410 : 5367 : dictcomp_rule(Parser *p)
16411 : : {
16412 [ - + ]: 5367 : if (p->level++ == MAXSTACK) {
16413 : 0 : p->error_indicator = 1;
16414 : : PyErr_NoMemory();
16415 : : }
16416 [ - + ]: 5367 : if (p->error_indicator) {
16417 : 0 : p->level--;
16418 : 0 : return NULL;
16419 : : }
16420 : 5367 : expr_ty _res = NULL;
16421 : 5367 : int _mark = p->mark;
16422 [ - + - - ]: 5367 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16423 : 0 : p->error_indicator = 1;
16424 : 0 : p->level--;
16425 : 0 : return NULL;
16426 : : }
16427 : 5367 : int _start_lineno = p->tokens[_mark]->lineno;
16428 : : UNUSED(_start_lineno); // Only used by EXTRA macro
16429 : 5367 : 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 [ - + ]: 5367 : if (p->error_indicator) {
16433 : 0 : p->level--;
16434 : 0 : 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 [ + - ]: 5367 : if (
16442 : 5367 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
16443 [ + + ]: 5367 : &&
16444 : 5367 : (a = kvpair_rule(p)) // kvpair
16445 [ + + ]: 3786 : &&
16446 : 3786 : (b = for_if_clauses_rule(p)) // for_if_clauses
16447 [ + - ]: 3780 : &&
16448 : 3780 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
16449 : : )
16450 : : {
16451 : : D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
16452 : 3780 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16453 [ - + ]: 3780 : if (_token == NULL) {
16454 : 0 : p->level--;
16455 : 0 : return NULL;
16456 : : }
16457 : 3780 : int _end_lineno = _token->end_lineno;
16458 : : UNUSED(_end_lineno); // Only used by EXTRA macro
16459 : 3780 : int _end_col_offset = _token->end_col_offset;
16460 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
16461 : 3780 : _res = _PyAST_DictComp ( a -> key , a -> value , b , EXTRA );
16462 [ - + - - ]: 3780 : if (_res == NULL && PyErr_Occurred()) {
16463 : 0 : p->error_indicator = 1;
16464 : 0 : p->level--;
16465 : 0 : return NULL;
16466 : : }
16467 : 3780 : goto done;
16468 : : }
16469 : 1587 : 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 [ + + ]: 1587 : if (p->call_invalid_rules) { // invalid_dict_comprehension
16474 [ - + ]: 37 : if (p->error_indicator) {
16475 : 0 : p->level--;
16476 : 0 : 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 [ - + ]: 37 : if (
16481 : 37 : (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 : 0 : _res = invalid_dict_comprehension_var;
16486 : 0 : goto done;
16487 : : }
16488 : 37 : 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 : 1587 : _res = NULL;
16493 : 5367 : done:
16494 : 5367 : p->level--;
16495 : 5367 : return _res;
16496 : : }
16497 : :
16498 : : // arguments: args ','? &')' | invalid_arguments
16499 : : static expr_ty
16500 : 3120727 : arguments_rule(Parser *p)
16501 : : {
16502 [ - + ]: 3120727 : if (p->level++ == MAXSTACK) {
16503 : 0 : p->error_indicator = 1;
16504 : : PyErr_NoMemory();
16505 : : }
16506 [ - + ]: 3120727 : if (p->error_indicator) {
16507 : 0 : p->level--;
16508 : 0 : return NULL;
16509 : : }
16510 : 3120727 : expr_ty _res = NULL;
16511 [ + + ]: 3120727 : if (_PyPegen_is_memoized(p, arguments_type, &_res)) {
16512 : 1192529 : p->level--;
16513 : 1192529 : return _res;
16514 : : }
16515 : 1928198 : int _mark = p->mark;
16516 : : { // args ','? &')'
16517 [ - + ]: 1928198 : if (p->error_indicator) {
16518 : 0 : p->level--;
16519 : 0 : 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 [ + + ]: 1928198 : if (
16526 : 1928198 : (a = args_rule(p)) // args
16527 : 1382856 : &&
16528 [ + - ]: 1382856 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
16529 [ + + ]: 1382856 : &&
16530 : 1382856 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
16531 : : )
16532 : : {
16533 : : D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','? &')'"));
16534 : 1379852 : _res = a;
16535 [ - + - - ]: 1379852 : if (_res == NULL && PyErr_Occurred()) {
16536 : 0 : p->error_indicator = 1;
16537 : 0 : p->level--;
16538 : 0 : return NULL;
16539 : : }
16540 : 1379852 : goto done;
16541 : : }
16542 : 548346 : 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 [ + + ]: 548346 : if (p->call_invalid_rules) { // invalid_arguments
16547 [ + + ]: 109 : if (p->error_indicator) {
16548 : 15 : p->level--;
16549 : 15 : 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 [ - + ]: 94 : if (
16554 : 94 : (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 : 0 : _res = invalid_arguments_var;
16559 : 0 : goto done;
16560 : : }
16561 : 94 : 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 : 548331 : _res = NULL;
16566 : 1928183 : done:
16567 : 1928183 : _PyPegen_insert_memo(p, _mark, arguments_type, _res);
16568 : 1928183 : p->level--;
16569 : 1928183 : return _res;
16570 : : }
16571 : :
16572 : : // args:
16573 : : // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]
16574 : : // | kwargs
16575 : : static expr_ty
16576 : 1928539 : args_rule(Parser *p)
16577 : : {
16578 [ - + ]: 1928539 : if (p->level++ == MAXSTACK) {
16579 : 0 : p->error_indicator = 1;
16580 : : PyErr_NoMemory();
16581 : : }
16582 [ - + ]: 1928539 : if (p->error_indicator) {
16583 : 0 : p->level--;
16584 : 0 : return NULL;
16585 : : }
16586 : 1928539 : expr_ty _res = NULL;
16587 : 1928539 : int _mark = p->mark;
16588 [ + + + + ]: 1928539 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16589 : 1 : p->error_indicator = 1;
16590 : 1 : p->level--;
16591 : 1 : return NULL;
16592 : : }
16593 : 1928538 : int _start_lineno = p->tokens[_mark]->lineno;
16594 : : UNUSED(_start_lineno); // Only used by EXTRA macro
16595 : 1928538 : 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 [ - + ]: 1928538 : if (p->error_indicator) {
16599 : 0 : p->level--;
16600 : 0 : 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 [ + + ]: 1928538 : if (
16606 : 1928538 : (a = (asdl_expr_seq*)_gather_117_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+
16607 : 1344264 : &&
16608 [ + + ]: 1344264 : (b = _tmp_119_rule(p), !p->error_indicator) // [',' kwargs]
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 : 1344250 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16613 [ - + ]: 1344250 : if (_token == NULL) {
16614 : 0 : p->level--;
16615 : 0 : return NULL;
16616 : : }
16617 : 1344250 : int _end_lineno = _token->end_lineno;
16618 : : UNUSED(_end_lineno); // Only used by EXTRA macro
16619 : 1344250 : int _end_col_offset = _token->end_col_offset;
16620 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
16621 : 1344250 : _res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA );
16622 [ - + - - ]: 1344250 : if (_res == NULL && PyErr_Occurred()) {
16623 : 0 : p->error_indicator = 1;
16624 : 0 : p->level--;
16625 : 0 : return NULL;
16626 : : }
16627 : 1344250 : goto done;
16628 : : }
16629 : 584288 : 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 [ + + ]: 584288 : if (p->error_indicator) {
16635 : 16 : p->level--;
16636 : 16 : return NULL;
16637 : : }
16638 : : D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs"));
16639 : : asdl_seq* a;
16640 [ + + ]: 584272 : if (
16641 : 584272 : (a = kwargs_rule(p)) // kwargs
16642 : : )
16643 : : {
16644 : : D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs"));
16645 : 38744 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16646 [ - + ]: 38744 : if (_token == NULL) {
16647 : 0 : p->level--;
16648 : 0 : return NULL;
16649 : : }
16650 : 38744 : int _end_lineno = _token->end_lineno;
16651 : : UNUSED(_end_lineno); // Only used by EXTRA macro
16652 : 38744 : int _end_col_offset = _token->end_col_offset;
16653 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
16654 : 38744 : _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 [ - + - - ]: 38744 : if (_res == NULL && PyErr_Occurred()) {
16656 : 0 : p->error_indicator = 1;
16657 : 0 : p->level--;
16658 : 0 : return NULL;
16659 : : }
16660 : 38744 : goto done;
16661 : : }
16662 : 545528 : 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 : 545528 : _res = NULL;
16667 : 1928522 : done:
16668 : 1928522 : p->level--;
16669 : 1928522 : 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 : 656767 : kwargs_rule(Parser *p)
16678 : : {
16679 [ - + ]: 656767 : if (p->level++ == MAXSTACK) {
16680 : 0 : p->error_indicator = 1;
16681 : : PyErr_NoMemory();
16682 : : }
16683 [ - + ]: 656767 : if (p->error_indicator) {
16684 : 0 : p->level--;
16685 : 0 : return NULL;
16686 : : }
16687 : 656767 : asdl_seq* _res = NULL;
16688 : 656767 : int _mark = p->mark;
16689 : : { // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
16690 [ - + ]: 656767 : if (p->error_indicator) {
16691 : 0 : p->level--;
16692 : 0 : 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 [ + + ]: 656767 : if (
16699 : 656767 : (a = _gather_120_rule(p)) // ','.kwarg_or_starred+
16700 [ + + ]: 98713 : &&
16701 : 98713 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
16702 [ + + ]: 8567 : &&
16703 : 8567 : (b = _gather_122_rule(p)) // ','.kwarg_or_double_starred+
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 : 1044 : _res = _PyPegen_join_sequences ( p , a , b );
16708 [ - + - - ]: 1044 : if (_res == NULL && PyErr_Occurred()) {
16709 : 0 : p->error_indicator = 1;
16710 : 0 : p->level--;
16711 : 0 : return NULL;
16712 : : }
16713 : 1044 : goto done;
16714 : : }
16715 : 655723 : 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 [ + + ]: 655723 : if (p->error_indicator) {
16721 : 14 : p->level--;
16722 : 14 : 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 [ + + ]: 655709 : if (
16727 : 655709 : (_gather_124_var = _gather_124_rule(p)) // ','.kwarg_or_starred+
16728 : : )
16729 : : {
16730 : : D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+"));
16731 : 97669 : _res = _gather_124_var;
16732 : 97669 : goto done;
16733 : : }
16734 : 558040 : 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 [ - + ]: 558040 : if (p->error_indicator) {
16740 : 0 : p->level--;
16741 : 0 : 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 [ + + ]: 558040 : if (
16746 : 558040 : (_gather_126_var = _gather_126_rule(p)) // ','.kwarg_or_double_starred+
16747 : : )
16748 : : {
16749 : : D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+"));
16750 : 7424 : _res = _gather_126_var;
16751 : 7424 : goto done;
16752 : : }
16753 : 550616 : 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 : 550616 : _res = NULL;
16758 : 656753 : done:
16759 : 656753 : p->level--;
16760 : 656753 : return _res;
16761 : : }
16762 : :
16763 : : // starred_expression: '*' expression
16764 : : static expr_ty
16765 : 3886840 : starred_expression_rule(Parser *p)
16766 : : {
16767 [ - + ]: 3886840 : if (p->level++ == MAXSTACK) {
16768 : 0 : p->error_indicator = 1;
16769 : : PyErr_NoMemory();
16770 : : }
16771 [ - + ]: 3886840 : if (p->error_indicator) {
16772 : 0 : p->level--;
16773 : 0 : return NULL;
16774 : : }
16775 : 3886840 : expr_ty _res = NULL;
16776 : 3886840 : int _mark = p->mark;
16777 [ + + + + ]: 3886840 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16778 : 10 : p->error_indicator = 1;
16779 : 10 : p->level--;
16780 : 10 : return NULL;
16781 : : }
16782 : 3886830 : int _start_lineno = p->tokens[_mark]->lineno;
16783 : : UNUSED(_start_lineno); // Only used by EXTRA macro
16784 : 3886830 : int _start_col_offset = p->tokens[_mark]->col_offset;
16785 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
16786 : : { // '*' expression
16787 [ - + ]: 3886830 : if (p->error_indicator) {
16788 : 0 : p->level--;
16789 : 0 : 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 [ + + ]: 3886830 : if (
16795 : 3886830 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
16796 [ + + ]: 12656 : &&
16797 : 12656 : (a = expression_rule(p)) // expression
16798 : : )
16799 : : {
16800 : : D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression"));
16801 : 12600 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16802 [ - + ]: 12600 : if (_token == NULL) {
16803 : 0 : p->level--;
16804 : 0 : return NULL;
16805 : : }
16806 : 12600 : int _end_lineno = _token->end_lineno;
16807 : : UNUSED(_end_lineno); // Only used by EXTRA macro
16808 : 12600 : int _end_col_offset = _token->end_col_offset;
16809 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
16810 : 12600 : _res = _PyAST_Starred ( a , Load , EXTRA );
16811 [ - + - - ]: 12600 : if (_res == NULL && PyErr_Occurred()) {
16812 : 0 : p->error_indicator = 1;
16813 : 0 : p->level--;
16814 : 0 : return NULL;
16815 : : }
16816 : 12600 : goto done;
16817 : : }
16818 : 3874230 : 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 : 3874230 : _res = NULL;
16823 : 3886830 : done:
16824 : 3886830 : p->level--;
16825 : 3886830 : return _res;
16826 : : }
16827 : :
16828 : : // kwarg_or_starred: invalid_kwarg | NAME '=' expression | starred_expression
16829 : : static KeywordOrStarred*
16830 : 1480219 : kwarg_or_starred_rule(Parser *p)
16831 : : {
16832 [ - + ]: 1480219 : if (p->level++ == MAXSTACK) {
16833 : 0 : p->error_indicator = 1;
16834 : : PyErr_NoMemory();
16835 : : }
16836 [ - + ]: 1480219 : if (p->error_indicator) {
16837 : 0 : p->level--;
16838 : 0 : return NULL;
16839 : : }
16840 : 1480219 : KeywordOrStarred* _res = NULL;
16841 : 1480219 : int _mark = p->mark;
16842 [ + + - + ]: 1480219 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16843 : 0 : p->error_indicator = 1;
16844 : 0 : p->level--;
16845 : 0 : return NULL;
16846 : : }
16847 : 1480219 : int _start_lineno = p->tokens[_mark]->lineno;
16848 : : UNUSED(_start_lineno); // Only used by EXTRA macro
16849 : 1480219 : int _start_col_offset = p->tokens[_mark]->col_offset;
16850 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
16851 [ + + ]: 1480219 : if (p->call_invalid_rules) { // invalid_kwarg
16852 [ - + ]: 804 : if (p->error_indicator) {
16853 : 0 : p->level--;
16854 : 0 : 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 [ - + ]: 804 : if (
16859 : 804 : (invalid_kwarg_var = invalid_kwarg_rule(p)) // invalid_kwarg
16860 : : )
16861 : : {
16862 : : D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
16863 : 0 : _res = invalid_kwarg_var;
16864 : 0 : goto done;
16865 : : }
16866 : 804 : 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 [ + + ]: 1480219 : if (p->error_indicator) {
16872 : 14 : p->level--;
16873 : 14 : 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 [ + + ]: 1480205 : if (
16880 : 1480205 : (a = _PyPegen_name_token(p)) // NAME
16881 [ + + ]: 347940 : &&
16882 : 347940 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
16883 [ + + ]: 347848 : &&
16884 : 347848 : (b = expression_rule(p)) // expression
16885 : : )
16886 : : {
16887 : : D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
16888 : 347836 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16889 [ - + ]: 347836 : if (_token == NULL) {
16890 : 0 : p->level--;
16891 : 0 : return NULL;
16892 : : }
16893 : 347836 : int _end_lineno = _token->end_lineno;
16894 : : UNUSED(_end_lineno); // Only used by EXTRA macro
16895 : 347836 : int _end_col_offset = _token->end_col_offset;
16896 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
16897 : 347836 : _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
16898 [ - + - - ]: 347836 : if (_res == NULL && PyErr_Occurred()) {
16899 : 0 : p->error_indicator = 1;
16900 : 0 : p->level--;
16901 : 0 : return NULL;
16902 : : }
16903 : 347836 : goto done;
16904 : : }
16905 : 1132369 : 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 [ - + ]: 1132369 : if (p->error_indicator) {
16911 : 0 : p->level--;
16912 : 0 : 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 [ + + ]: 1132369 : if (
16917 : 1132369 : (a = starred_expression_rule(p)) // starred_expression
16918 : : )
16919 : : {
16920 : : D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
16921 : 199 : _res = _PyPegen_keyword_or_starred ( p , a , 0 );
16922 [ - + - - ]: 199 : if (_res == NULL && PyErr_Occurred()) {
16923 : 0 : p->error_indicator = 1;
16924 : 0 : p->level--;
16925 : 0 : return NULL;
16926 : : }
16927 : 199 : goto done;
16928 : : }
16929 : 1132170 : 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 : 1132170 : _res = NULL;
16934 : 1480205 : done:
16935 : 1480205 : p->level--;
16936 : 1480205 : return _res;
16937 : : }
16938 : :
16939 : : // kwarg_or_double_starred: invalid_kwarg | NAME '=' expression | '**' expression
16940 : : static KeywordOrStarred*
16941 : 566698 : kwarg_or_double_starred_rule(Parser *p)
16942 : : {
16943 [ - + ]: 566698 : if (p->level++ == MAXSTACK) {
16944 : 0 : p->error_indicator = 1;
16945 : : PyErr_NoMemory();
16946 : : }
16947 [ - + ]: 566698 : if (p->error_indicator) {
16948 : 0 : p->level--;
16949 : 0 : return NULL;
16950 : : }
16951 : 566698 : KeywordOrStarred* _res = NULL;
16952 : 566698 : int _mark = p->mark;
16953 [ + + - + ]: 566698 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16954 : 0 : p->error_indicator = 1;
16955 : 0 : p->level--;
16956 : 0 : return NULL;
16957 : : }
16958 : 566698 : int _start_lineno = p->tokens[_mark]->lineno;
16959 : : UNUSED(_start_lineno); // Only used by EXTRA macro
16960 : 566698 : int _start_col_offset = p->tokens[_mark]->col_offset;
16961 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
16962 [ + + ]: 566698 : if (p->call_invalid_rules) { // invalid_kwarg
16963 [ - + ]: 326 : if (p->error_indicator) {
16964 : 0 : p->level--;
16965 : 0 : 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 [ - + ]: 326 : if (
16970 : 326 : (invalid_kwarg_var = invalid_kwarg_rule(p)) // invalid_kwarg
16971 : : )
16972 : : {
16973 : : D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
16974 : 0 : _res = invalid_kwarg_var;
16975 : 0 : goto done;
16976 : : }
16977 : 326 : 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 [ - + ]: 566698 : if (p->error_indicator) {
16983 : 0 : p->level--;
16984 : 0 : 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 [ + + ]: 566698 : if (
16991 : 566698 : (a = _PyPegen_name_token(p)) // NAME
16992 [ + + ]: 93 : &&
16993 : 93 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
16994 [ + + ]: 47 : &&
16995 : 47 : (b = expression_rule(p)) // 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 : 41 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17000 [ - + ]: 41 : if (_token == NULL) {
17001 : 0 : p->level--;
17002 : 0 : return NULL;
17003 : : }
17004 : 41 : int _end_lineno = _token->end_lineno;
17005 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17006 : 41 : int _end_col_offset = _token->end_col_offset;
17007 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17008 : 41 : _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
17009 [ - + - - ]: 41 : if (_res == NULL && PyErr_Occurred()) {
17010 : 0 : p->error_indicator = 1;
17011 : 0 : p->level--;
17012 : 0 : return NULL;
17013 : : }
17014 : 41 : goto done;
17015 : : }
17016 : 566657 : 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 [ - + ]: 566657 : if (p->error_indicator) {
17022 : 0 : p->level--;
17023 : 0 : 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 [ + + ]: 566657 : if (
17029 : 566657 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
17030 [ + + ]: 8492 : &&
17031 : 8492 : (a = expression_rule(p)) // expression
17032 : : )
17033 : : {
17034 : : D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression"));
17035 : 8491 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17036 [ - + ]: 8491 : if (_token == NULL) {
17037 : 0 : p->level--;
17038 : 0 : return NULL;
17039 : : }
17040 : 8491 : int _end_lineno = _token->end_lineno;
17041 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17042 : 8491 : int _end_col_offset = _token->end_col_offset;
17043 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17044 : 8491 : _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( NULL , a , EXTRA ) ) , 1 );
17045 [ - + - - ]: 8491 : if (_res == NULL && PyErr_Occurred()) {
17046 : 0 : p->error_indicator = 1;
17047 : 0 : p->level--;
17048 : 0 : return NULL;
17049 : : }
17050 : 8491 : goto done;
17051 : : }
17052 : 558166 : 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 : 558166 : _res = NULL;
17057 : 566698 : done:
17058 : 566698 : p->level--;
17059 : 566698 : return _res;
17060 : : }
17061 : :
17062 : : // star_targets: star_target !',' | star_target ((',' star_target))* ','?
17063 : : static expr_ty
17064 : 4125968 : star_targets_rule(Parser *p)
17065 : : {
17066 [ - + ]: 4125968 : if (p->level++ == MAXSTACK) {
17067 : 0 : p->error_indicator = 1;
17068 : : PyErr_NoMemory();
17069 : : }
17070 [ - + ]: 4125968 : if (p->error_indicator) {
17071 : 0 : p->level--;
17072 : 0 : return NULL;
17073 : : }
17074 : 4125968 : expr_ty _res = NULL;
17075 : 4125968 : int _mark = p->mark;
17076 [ + + + + ]: 4125968 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17077 : 20 : p->error_indicator = 1;
17078 : 20 : p->level--;
17079 : 20 : return NULL;
17080 : : }
17081 : 4125948 : int _start_lineno = p->tokens[_mark]->lineno;
17082 : : UNUSED(_start_lineno); // Only used by EXTRA macro
17083 : 4125948 : int _start_col_offset = p->tokens[_mark]->col_offset;
17084 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
17085 : : { // star_target !','
17086 [ - + ]: 4125948 : if (p->error_indicator) {
17087 : 0 : p->level--;
17088 : 0 : 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 [ + + ]: 4125948 : if (
17093 : 4125948 : (a = star_target_rule(p)) // star_target
17094 [ + + ]: 2271732 : &&
17095 : 2271732 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
17096 : : )
17097 : : {
17098 : : D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target !','"));
17099 : 2214980 : _res = a;
17100 [ - + - - ]: 2214980 : if (_res == NULL && PyErr_Occurred()) {
17101 : 0 : p->error_indicator = 1;
17102 : 0 : p->level--;
17103 : 0 : return NULL;
17104 : : }
17105 : 2214980 : goto done;
17106 : : }
17107 : 1910968 : 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 [ + + ]: 1910968 : if (p->error_indicator) {
17113 : 18 : p->level--;
17114 : 18 : 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 [ + + ]: 1910950 : if (
17122 : 1910950 : (a = star_target_rule(p)) // star_target
17123 [ + - ]: 56752 : &&
17124 : 56752 : (b = _loop0_128_rule(p)) // ((',' star_target))*
17125 : 56752 : &&
17126 [ + + ]: 56752 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
17127 : : )
17128 : : {
17129 : : D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?"));
17130 : 56750 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17131 [ - + ]: 56750 : if (_token == NULL) {
17132 : 0 : p->level--;
17133 : 0 : return NULL;
17134 : : }
17135 : 56750 : int _end_lineno = _token->end_lineno;
17136 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17137 : 56750 : int _end_col_offset = _token->end_col_offset;
17138 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17139 : 56750 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA );
17140 [ - + - - ]: 56750 : if (_res == NULL && PyErr_Occurred()) {
17141 : 0 : p->error_indicator = 1;
17142 : 0 : p->level--;
17143 : 0 : return NULL;
17144 : : }
17145 : 56750 : goto done;
17146 : : }
17147 : 1854200 : 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 : 1854200 : _res = NULL;
17152 : 4125930 : done:
17153 : 4125930 : p->level--;
17154 : 4125930 : return _res;
17155 : : }
17156 : :
17157 : : // star_targets_list_seq: ','.star_target+ ','?
17158 : : static asdl_expr_seq*
17159 : 42591 : star_targets_list_seq_rule(Parser *p)
17160 : : {
17161 [ - + ]: 42591 : if (p->level++ == MAXSTACK) {
17162 : 0 : p->error_indicator = 1;
17163 : : PyErr_NoMemory();
17164 : : }
17165 [ - + ]: 42591 : if (p->error_indicator) {
17166 : 0 : p->level--;
17167 : 0 : return NULL;
17168 : : }
17169 : 42591 : asdl_expr_seq* _res = NULL;
17170 : 42591 : int _mark = p->mark;
17171 : : { // ','.star_target+ ','?
17172 [ - + ]: 42591 : if (p->error_indicator) {
17173 : 0 : p->level--;
17174 : 0 : 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 [ + + ]: 42591 : if (
17181 : 42591 : (a = (asdl_expr_seq*)_gather_129_rule(p)) // ','.star_target+
17182 : 12099 : &&
17183 [ + - ]: 12099 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
17184 : : )
17185 : : {
17186 : : D(fprintf(stderr, "%*c+ star_targets_list_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?"));
17187 : 12099 : _res = a;
17188 [ - + - - ]: 12099 : if (_res == NULL && PyErr_Occurred()) {
17189 : 0 : p->error_indicator = 1;
17190 : 0 : p->level--;
17191 : 0 : return NULL;
17192 : : }
17193 : 12099 : goto done;
17194 : : }
17195 : 30492 : 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 : 30492 : _res = NULL;
17200 : 42591 : done:
17201 : 42591 : p->level--;
17202 : 42591 : return _res;
17203 : : }
17204 : :
17205 : : // star_targets_tuple_seq: star_target ((',' star_target))+ ','? | star_target ','
17206 : : static asdl_expr_seq*
17207 : 31442 : star_targets_tuple_seq_rule(Parser *p)
17208 : : {
17209 [ - + ]: 31442 : if (p->level++ == MAXSTACK) {
17210 : 0 : p->error_indicator = 1;
17211 : : PyErr_NoMemory();
17212 : : }
17213 [ - + ]: 31442 : if (p->error_indicator) {
17214 : 0 : p->level--;
17215 : 0 : return NULL;
17216 : : }
17217 : 31442 : asdl_expr_seq* _res = NULL;
17218 : 31442 : int _mark = p->mark;
17219 : : { // star_target ((',' star_target))+ ','?
17220 [ - + ]: 31442 : if (p->error_indicator) {
17221 : 0 : p->level--;
17222 : 0 : 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 [ + + ]: 31442 : if (
17230 : 31442 : (a = star_target_rule(p)) // star_target
17231 [ + + ]: 16500 : &&
17232 : 16500 : (b = _loop1_131_rule(p)) // ((',' star_target))+
17233 : 7591 : &&
17234 [ + - ]: 7591 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
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 : 7591 : _res = ( asdl_expr_seq* ) _PyPegen_seq_insert_in_front ( p , a , b );
17239 [ - + - - ]: 7591 : if (_res == NULL && PyErr_Occurred()) {
17240 : 0 : p->error_indicator = 1;
17241 : 0 : p->level--;
17242 : 0 : return NULL;
17243 : : }
17244 : 7591 : goto done;
17245 : : }
17246 : 23851 : 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 [ - + ]: 23851 : if (p->error_indicator) {
17252 : 0 : p->level--;
17253 : 0 : 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 [ + + ]: 23851 : if (
17259 : 23851 : (a = star_target_rule(p)) // star_target
17260 [ + + ]: 8909 : &&
17261 : 8909 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
17262 : : )
17263 : : {
17264 : : D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ','"));
17265 : 1851 : _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a );
17266 [ - + - - ]: 1851 : if (_res == NULL && PyErr_Occurred()) {
17267 : 0 : p->error_indicator = 1;
17268 : 0 : p->level--;
17269 : 0 : return NULL;
17270 : : }
17271 : 1851 : goto done;
17272 : : }
17273 : 22000 : 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 : 22000 : _res = NULL;
17278 : 31442 : done:
17279 : 31442 : p->level--;
17280 : 31442 : return _res;
17281 : : }
17282 : :
17283 : : // star_target: '*' (!'*' star_target) | target_with_star_atom
17284 : : static expr_ty
17285 : 6255532 : star_target_rule(Parser *p)
17286 : : {
17287 [ - + ]: 6255532 : if (p->level++ == MAXSTACK) {
17288 : 0 : p->error_indicator = 1;
17289 : : PyErr_NoMemory();
17290 : : }
17291 [ - + ]: 6255532 : if (p->error_indicator) {
17292 : 0 : p->level--;
17293 : 0 : return NULL;
17294 : : }
17295 : 6255532 : expr_ty _res = NULL;
17296 [ + + ]: 6255532 : if (_PyPegen_is_memoized(p, star_target_type, &_res)) {
17297 : 1969843 : p->level--;
17298 : 1969843 : return _res;
17299 : : }
17300 : 4285689 : int _mark = p->mark;
17301 [ - + - - ]: 4285689 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17302 : 0 : p->error_indicator = 1;
17303 : 0 : p->level--;
17304 : 0 : return NULL;
17305 : : }
17306 : 4285689 : int _start_lineno = p->tokens[_mark]->lineno;
17307 : : UNUSED(_start_lineno); // Only used by EXTRA macro
17308 : 4285689 : int _start_col_offset = p->tokens[_mark]->col_offset;
17309 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
17310 : : { // '*' (!'*' star_target)
17311 [ - + ]: 4285689 : if (p->error_indicator) {
17312 : 0 : p->level--;
17313 : 0 : 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 [ + + ]: 4285689 : if (
17319 : 4285689 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
17320 [ + + ]: 733 : &&
17321 : 733 : (a = _tmp_132_rule(p)) // !'*' star_target
17322 : : )
17323 : : {
17324 : : D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
17325 : 697 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17326 [ - + ]: 697 : if (_token == NULL) {
17327 : 0 : p->level--;
17328 : 0 : return NULL;
17329 : : }
17330 : 697 : int _end_lineno = _token->end_lineno;
17331 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17332 : 697 : int _end_col_offset = _token->end_col_offset;
17333 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17334 : 697 : _res = _PyAST_Starred ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA );
17335 [ - + - - ]: 697 : if (_res == NULL && PyErr_Occurred()) {
17336 : 0 : p->error_indicator = 1;
17337 : 0 : p->level--;
17338 : 0 : return NULL;
17339 : : }
17340 : 697 : goto done;
17341 : : }
17342 : 4284992 : 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 [ - + ]: 4284992 : if (p->error_indicator) {
17348 : 0 : p->level--;
17349 : 0 : 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 [ + + ]: 4284992 : if (
17354 : 4284992 : (target_with_star_atom_var = target_with_star_atom_rule(p)) // target_with_star_atom
17355 : : )
17356 : : {
17357 : : D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "target_with_star_atom"));
17358 : 2382732 : _res = target_with_star_atom_var;
17359 : 2382732 : goto done;
17360 : : }
17361 : 1902260 : 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 : 1902260 : _res = NULL;
17366 : 4285689 : done:
17367 : 4285689 : _PyPegen_insert_memo(p, _mark, star_target_type, _res);
17368 : 4285689 : p->level--;
17369 : 4285689 : 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 : 4316540 : target_with_star_atom_rule(Parser *p)
17378 : : {
17379 [ - + ]: 4316540 : if (p->level++ == MAXSTACK) {
17380 : 0 : p->error_indicator = 1;
17381 : : PyErr_NoMemory();
17382 : : }
17383 [ - + ]: 4316540 : if (p->error_indicator) {
17384 : 0 : p->level--;
17385 : 0 : return NULL;
17386 : : }
17387 : 4316540 : expr_ty _res = NULL;
17388 [ + + ]: 4316540 : if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) {
17389 : 31307 : p->level--;
17390 : 31307 : return _res;
17391 : : }
17392 : 4285233 : int _mark = p->mark;
17393 [ - + - - ]: 4285233 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17394 : 0 : p->error_indicator = 1;
17395 : 0 : p->level--;
17396 : 0 : return NULL;
17397 : : }
17398 : 4285233 : int _start_lineno = p->tokens[_mark]->lineno;
17399 : : UNUSED(_start_lineno); // Only used by EXTRA macro
17400 : 4285233 : 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 [ - + ]: 4285233 : if (p->error_indicator) {
17404 : 0 : p->level--;
17405 : 0 : 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 [ + + ]: 4285233 : if (
17412 : 4285233 : (a = t_primary_rule(p)) // t_primary
17413 [ + + ]: 1158391 : &&
17414 : 1158391 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
17415 [ + + ]: 216734 : &&
17416 : 216734 : (b = _PyPegen_name_token(p)) // NAME
17417 [ + - ]: 216726 : &&
17418 : 216726 : _PyPegen_lookahead(0, t_lookahead_rule, p)
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 : 216726 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17423 [ - + ]: 216726 : if (_token == NULL) {
17424 : 0 : p->level--;
17425 : 0 : return NULL;
17426 : : }
17427 : 216726 : int _end_lineno = _token->end_lineno;
17428 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17429 : 216726 : int _end_col_offset = _token->end_col_offset;
17430 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17431 : 216726 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA );
17432 [ - + - - ]: 216726 : if (_res == NULL && PyErr_Occurred()) {
17433 : 0 : p->error_indicator = 1;
17434 : 0 : p->level--;
17435 : 0 : return NULL;
17436 : : }
17437 : 216726 : goto done;
17438 : : }
17439 : 4068507 : 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 [ + + ]: 4068507 : if (p->error_indicator) {
17445 : 20 : p->level--;
17446 : 20 : 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 [ + + ]: 4068487 : if (
17454 : 4068487 : (a = t_primary_rule(p)) // t_primary
17455 [ + + ]: 941665 : &&
17456 : 941665 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
17457 [ + + ]: 75542 : &&
17458 : 75542 : (b = slices_rule(p)) // slices
17459 [ + + ]: 75525 : &&
17460 : 75525 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
17461 [ + - ]: 75510 : &&
17462 : 75510 : _PyPegen_lookahead(0, t_lookahead_rule, p)
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 : 75510 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17467 [ - + ]: 75510 : if (_token == NULL) {
17468 : 0 : p->level--;
17469 : 0 : return NULL;
17470 : : }
17471 : 75510 : int _end_lineno = _token->end_lineno;
17472 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17473 : 75510 : int _end_col_offset = _token->end_col_offset;
17474 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17475 : 75510 : _res = _PyAST_Subscript ( a , b , Store , EXTRA );
17476 [ - + - - ]: 75510 : if (_res == NULL && PyErr_Occurred()) {
17477 : 0 : p->error_indicator = 1;
17478 : 0 : p->level--;
17479 : 0 : return NULL;
17480 : : }
17481 : 75510 : goto done;
17482 : : }
17483 : 3992977 : 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 [ - + ]: 3992977 : if (p->error_indicator) {
17489 : 0 : p->level--;
17490 : 0 : 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 [ + + ]: 3992977 : if (
17495 : 3992977 : (star_atom_var = star_atom_rule(p)) // star_atom
17496 : : )
17497 : : {
17498 : : D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_atom"));
17499 : 2090602 : _res = star_atom_var;
17500 : 2090602 : goto done;
17501 : : }
17502 : 1902375 : 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 : 1902375 : _res = NULL;
17507 : 4285213 : done:
17508 : 4285213 : _PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res);
17509 : 4285213 : p->level--;
17510 : 4285213 : 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 : 3992977 : star_atom_rule(Parser *p)
17520 : : {
17521 [ - + ]: 3992977 : if (p->level++ == MAXSTACK) {
17522 : 0 : p->error_indicator = 1;
17523 : : PyErr_NoMemory();
17524 : : }
17525 [ - + ]: 3992977 : if (p->error_indicator) {
17526 : 0 : p->level--;
17527 : 0 : return NULL;
17528 : : }
17529 : 3992977 : expr_ty _res = NULL;
17530 : 3992977 : int _mark = p->mark;
17531 [ - + - - ]: 3992977 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17532 : 0 : p->error_indicator = 1;
17533 : 0 : p->level--;
17534 : 0 : return NULL;
17535 : : }
17536 : 3992977 : int _start_lineno = p->tokens[_mark]->lineno;
17537 : : UNUSED(_start_lineno); // Only used by EXTRA macro
17538 : 3992977 : int _start_col_offset = p->tokens[_mark]->col_offset;
17539 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
17540 : : { // NAME
17541 [ - + ]: 3992977 : if (p->error_indicator) {
17542 : 0 : p->level--;
17543 : 0 : 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 [ + + ]: 3992977 : if (
17548 : 3992977 : (a = _PyPegen_name_token(p)) // NAME
17549 : : )
17550 : : {
17551 : : D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
17552 : 2060146 : _res = _PyPegen_set_expr_context ( p , a , Store );
17553 [ - + - - ]: 2060146 : if (_res == NULL && PyErr_Occurred()) {
17554 : 0 : p->error_indicator = 1;
17555 : 0 : p->level--;
17556 : 0 : return NULL;
17557 : : }
17558 : 2060146 : goto done;
17559 : : }
17560 : 1932831 : 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 [ - + ]: 1932831 : if (p->error_indicator) {
17566 : 0 : p->level--;
17567 : 0 : 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 [ + + ]: 1932831 : if (
17574 : 1932831 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
17575 [ + + ]: 31548 : &&
17576 : 31548 : (a = target_with_star_atom_rule(p)) // target_with_star_atom
17577 [ + + ]: 16471 : &&
17578 : 16471 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
17579 : : )
17580 : : {
17581 : : D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'"));
17582 : 106 : _res = _PyPegen_set_expr_context ( p , a , Store );
17583 [ - + - - ]: 106 : if (_res == NULL && PyErr_Occurred()) {
17584 : 0 : p->error_indicator = 1;
17585 : 0 : p->level--;
17586 : 0 : return NULL;
17587 : : }
17588 : 106 : goto done;
17589 : : }
17590 : 1932725 : 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 [ - + ]: 1932725 : if (p->error_indicator) {
17596 : 0 : p->level--;
17597 : 0 : 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 [ + + ]: 1932725 : if (
17604 : 1932725 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
17605 : 31442 : &&
17606 [ + - ]: 31442 : (a = star_targets_tuple_seq_rule(p), !p->error_indicator) // star_targets_tuple_seq?
17607 [ + + ]: 31442 : &&
17608 : 31442 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
17609 : : )
17610 : : {
17611 : : D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
17612 : 10171 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17613 [ - + ]: 10171 : if (_token == NULL) {
17614 : 0 : p->level--;
17615 : 0 : return NULL;
17616 : : }
17617 : 10171 : int _end_lineno = _token->end_lineno;
17618 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17619 : 10171 : int _end_col_offset = _token->end_col_offset;
17620 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17621 : 10171 : _res = _PyAST_Tuple ( a , Store , EXTRA );
17622 [ - + - - ]: 10171 : if (_res == NULL && PyErr_Occurred()) {
17623 : 0 : p->error_indicator = 1;
17624 : 0 : p->level--;
17625 : 0 : return NULL;
17626 : : }
17627 : 10171 : goto done;
17628 : : }
17629 : 1922554 : 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 [ - + ]: 1922554 : if (p->error_indicator) {
17635 : 0 : p->level--;
17636 : 0 : 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 [ + + ]: 1922554 : if (
17643 : 1922554 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
17644 : 42591 : &&
17645 [ + - ]: 42591 : (a = star_targets_list_seq_rule(p), !p->error_indicator) // star_targets_list_seq?
17646 [ + + ]: 42591 : &&
17647 : 42591 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
17648 : : )
17649 : : {
17650 : : D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'"));
17651 : 20179 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17652 [ - + ]: 20179 : if (_token == NULL) {
17653 : 0 : p->level--;
17654 : 0 : return NULL;
17655 : : }
17656 : 20179 : int _end_lineno = _token->end_lineno;
17657 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17658 : 20179 : int _end_col_offset = _token->end_col_offset;
17659 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17660 : 20179 : _res = _PyAST_List ( a , Store , EXTRA );
17661 [ - + - - ]: 20179 : if (_res == NULL && PyErr_Occurred()) {
17662 : 0 : p->error_indicator = 1;
17663 : 0 : p->level--;
17664 : 0 : return NULL;
17665 : : }
17666 : 20179 : goto done;
17667 : : }
17668 : 1902375 : 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 : 1902375 : _res = NULL;
17673 : 3992977 : done:
17674 : 3992977 : p->level--;
17675 : 3992977 : return _res;
17676 : : }
17677 : :
17678 : : // single_target: single_subscript_attribute_target | NAME | '(' single_target ')'
17679 : : static expr_ty
17680 : 2398543 : single_target_rule(Parser *p)
17681 : : {
17682 [ - + ]: 2398543 : if (p->level++ == MAXSTACK) {
17683 : 0 : p->error_indicator = 1;
17684 : : PyErr_NoMemory();
17685 : : }
17686 [ - + ]: 2398543 : if (p->error_indicator) {
17687 : 0 : p->level--;
17688 : 0 : return NULL;
17689 : : }
17690 : 2398543 : expr_ty _res = NULL;
17691 : 2398543 : int _mark = p->mark;
17692 : : { // single_subscript_attribute_target
17693 [ - + ]: 2398543 : if (p->error_indicator) {
17694 : 0 : p->level--;
17695 : 0 : 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 [ + + ]: 2398543 : if (
17700 : 2398543 : (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target
17701 : : )
17702 : : {
17703 : : D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
17704 : 8853 : _res = single_subscript_attribute_target_var;
17705 : 8853 : goto done;
17706 : : }
17707 : 2389690 : 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 [ + + ]: 2389690 : if (p->error_indicator) {
17713 : 8 : p->level--;
17714 : 8 : 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 [ + + ]: 2389682 : if (
17719 : 2389682 : (a = _PyPegen_name_token(p)) // NAME
17720 : : )
17721 : : {
17722 : : D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
17723 : 755164 : _res = _PyPegen_set_expr_context ( p , a , Store );
17724 [ - + - - ]: 755164 : if (_res == NULL && PyErr_Occurred()) {
17725 : 0 : p->error_indicator = 1;
17726 : 0 : p->level--;
17727 : 0 : return NULL;
17728 : : }
17729 : 755164 : goto done;
17730 : : }
17731 : 1634518 : 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 [ - + ]: 1634518 : if (p->error_indicator) {
17737 : 0 : p->level--;
17738 : 0 : 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 [ + + ]: 1634518 : if (
17745 : 1634518 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
17746 [ + + ]: 491 : &&
17747 : 491 : (a = single_target_rule(p)) // single_target
17748 [ + + ]: 358 : &&
17749 : 358 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
17750 : : )
17751 : : {
17752 : : D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
17753 : 24 : _res = a;
17754 [ - + - - ]: 24 : if (_res == NULL && PyErr_Occurred()) {
17755 : 0 : p->error_indicator = 1;
17756 : 0 : p->level--;
17757 : 0 : return NULL;
17758 : : }
17759 : 24 : goto done;
17760 : : }
17761 : 1634494 : 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 : 1634494 : _res = NULL;
17766 : 2398535 : done:
17767 : 2398535 : p->level--;
17768 : 2398535 : 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 : 5599881 : single_subscript_attribute_target_rule(Parser *p)
17776 : : {
17777 [ - + ]: 5599881 : if (p->level++ == MAXSTACK) {
17778 : 0 : p->error_indicator = 1;
17779 : : PyErr_NoMemory();
17780 : : }
17781 [ - + ]: 5599881 : if (p->error_indicator) {
17782 : 0 : p->level--;
17783 : 0 : return NULL;
17784 : : }
17785 : 5599881 : expr_ty _res = NULL;
17786 : 5599881 : int _mark = p->mark;
17787 [ + + + + ]: 5599881 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17788 : 4 : p->error_indicator = 1;
17789 : 4 : p->level--;
17790 : 4 : return NULL;
17791 : : }
17792 : 5599877 : int _start_lineno = p->tokens[_mark]->lineno;
17793 : : UNUSED(_start_lineno); // Only used by EXTRA macro
17794 : 5599877 : 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 [ - + ]: 5599877 : if (p->error_indicator) {
17798 : 0 : p->level--;
17799 : 0 : 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 [ + + ]: 5599877 : if (
17806 : 5599877 : (a = t_primary_rule(p)) // t_primary
17807 [ + + ]: 1247348 : &&
17808 : 1247348 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
17809 [ + + ]: 148823 : &&
17810 : 148823 : (b = _PyPegen_name_token(p)) // NAME
17811 [ + - ]: 148807 : &&
17812 : 148807 : _PyPegen_lookahead(0, t_lookahead_rule, p)
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 : 148807 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17817 [ - + ]: 148807 : if (_token == NULL) {
17818 : 0 : p->level--;
17819 : 0 : return NULL;
17820 : : }
17821 : 148807 : int _end_lineno = _token->end_lineno;
17822 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17823 : 148807 : int _end_col_offset = _token->end_col_offset;
17824 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17825 : 148807 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA );
17826 [ - + - - ]: 148807 : if (_res == NULL && PyErr_Occurred()) {
17827 : 0 : p->error_indicator = 1;
17828 : 0 : p->level--;
17829 : 0 : return NULL;
17830 : : }
17831 : 148807 : goto done;
17832 : : }
17833 : 5451070 : 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 [ + + ]: 5451070 : if (p->error_indicator) {
17839 : 220 : p->level--;
17840 : 220 : 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 [ + + ]: 5450850 : if (
17848 : 5450850 : (a = t_primary_rule(p)) // t_primary
17849 [ + + ]: 1098541 : &&
17850 : 1098541 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
17851 [ + + ]: 38313 : &&
17852 : 38313 : (b = slices_rule(p)) // slices
17853 [ + + ]: 38279 : &&
17854 : 38279 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
17855 [ + - ]: 38249 : &&
17856 : 38249 : _PyPegen_lookahead(0, t_lookahead_rule, p)
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 : 38249 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17861 [ - + ]: 38249 : if (_token == NULL) {
17862 : 0 : p->level--;
17863 : 0 : return NULL;
17864 : : }
17865 : 38249 : int _end_lineno = _token->end_lineno;
17866 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17867 : 38249 : int _end_col_offset = _token->end_col_offset;
17868 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17869 : 38249 : _res = _PyAST_Subscript ( a , b , Store , EXTRA );
17870 [ - + - - ]: 38249 : if (_res == NULL && PyErr_Occurred()) {
17871 : 0 : p->error_indicator = 1;
17872 : 0 : p->level--;
17873 : 0 : return NULL;
17874 : : }
17875 : 38249 : goto done;
17876 : : }
17877 : 5412601 : 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 : 5412601 : _res = NULL;
17882 : 5599657 : done:
17883 : 5599657 : p->level--;
17884 : 5599657 : 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 : 44297395 : t_primary_rule(Parser *p)
17897 : : {
17898 [ - + ]: 44297395 : if (p->level++ == MAXSTACK) {
17899 : 0 : p->error_indicator = 1;
17900 : : PyErr_NoMemory();
17901 : : }
17902 : 44297395 : expr_ty _res = NULL;
17903 [ + + ]: 44297395 : if (_PyPegen_is_memoized(p, t_primary_type, &_res)) {
17904 : 39999183 : p->level--;
17905 : 39999183 : return _res;
17906 : : }
17907 : 4298212 : int _mark = p->mark;
17908 : 4298212 : int _resmark = p->mark;
17909 : 2877270 : while (1) {
17910 : 7175482 : int tmpvar_9 = _PyPegen_update_memo(p, _mark, t_primary_type, _res);
17911 [ - + ]: 7175482 : if (tmpvar_9) {
17912 : 0 : p->level--;
17913 : 0 : return _res;
17914 : : }
17915 : 7175482 : p->mark = _mark;
17916 : 7175482 : void *_raw = t_primary_raw(p);
17917 [ + + ]: 7175482 : if (p->error_indicator) {
17918 : 241 : p->level--;
17919 : 241 : return NULL;
17920 : : }
17921 [ + + + + ]: 7175241 : if (_raw == NULL || p->mark <= _resmark)
17922 : : break;
17923 : 2877270 : _resmark = p->mark;
17924 : 2877270 : _res = _raw;
17925 : : }
17926 : 4297971 : p->mark = _resmark;
17927 : 4297971 : p->level--;
17928 : 4297971 : return _res;
17929 : : }
17930 : : static expr_ty
17931 : 7175482 : t_primary_raw(Parser *p)
17932 : : {
17933 [ - + ]: 7175482 : if (p->level++ == MAXSTACK) {
17934 : 0 : p->error_indicator = 1;
17935 : : PyErr_NoMemory();
17936 : : }
17937 [ - + ]: 7175482 : if (p->error_indicator) {
17938 : 0 : p->level--;
17939 : 0 : return NULL;
17940 : : }
17941 : 7175482 : expr_ty _res = NULL;
17942 : 7175482 : int _mark = p->mark;
17943 [ - + - - ]: 7175482 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17944 : 0 : p->error_indicator = 1;
17945 : 0 : p->level--;
17946 : 0 : return NULL;
17947 : : }
17948 : 7175482 : int _start_lineno = p->tokens[_mark]->lineno;
17949 : : UNUSED(_start_lineno); // Only used by EXTRA macro
17950 : 7175482 : 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 [ - + ]: 7175482 : if (p->error_indicator) {
17954 : 0 : p->level--;
17955 : 0 : 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 [ + + ]: 7175482 : if (
17962 : 7175482 : (a = t_primary_rule(p)) // t_primary
17963 [ + + ]: 2877270 : &&
17964 : 2877270 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
17965 [ + + ]: 1287461 : &&
17966 : 1287461 : (b = _PyPegen_name_token(p)) // NAME
17967 [ + + ]: 1287453 : &&
17968 : 1287453 : _PyPegen_lookahead(1, t_lookahead_rule, p)
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 : 1067357 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17973 [ - + ]: 1067357 : if (_token == NULL) {
17974 : 0 : p->level--;
17975 : 0 : return NULL;
17976 : : }
17977 : 1067357 : int _end_lineno = _token->end_lineno;
17978 : : UNUSED(_end_lineno); // Only used by EXTRA macro
17979 : 1067357 : int _end_col_offset = _token->end_col_offset;
17980 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
17981 : 1067357 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA );
17982 [ - + - - ]: 1067357 : if (_res == NULL && PyErr_Occurred()) {
17983 : 0 : p->error_indicator = 1;
17984 : 0 : p->level--;
17985 : 0 : return NULL;
17986 : : }
17987 : 1067357 : goto done;
17988 : : }
17989 : 6108125 : 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 [ + + ]: 6108125 : if (p->error_indicator) {
17995 : 2 : p->level--;
17996 : 2 : 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 [ + + ]: 6108123 : if (
18004 : 6108123 : (a = t_primary_rule(p)) // t_primary
18005 [ + + ]: 1809911 : &&
18006 : 1809911 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
18007 [ + + ]: 393719 : &&
18008 : 393719 : (b = slices_rule(p)) // slices
18009 [ + + ]: 393682 : &&
18010 : 393682 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
18011 [ + + ]: 393661 : &&
18012 : 393661 : _PyPegen_lookahead(1, t_lookahead_rule, p)
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 : 313396 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18017 [ - + ]: 313396 : if (_token == NULL) {
18018 : 0 : p->level--;
18019 : 0 : return NULL;
18020 : : }
18021 : 313396 : int _end_lineno = _token->end_lineno;
18022 : : UNUSED(_end_lineno); // Only used by EXTRA macro
18023 : 313396 : int _end_col_offset = _token->end_col_offset;
18024 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
18025 : 313396 : _res = _PyAST_Subscript ( a , b , Load , EXTRA );
18026 [ - + - - ]: 313396 : if (_res == NULL && PyErr_Occurred()) {
18027 : 0 : p->error_indicator = 1;
18028 : 0 : p->level--;
18029 : 0 : return NULL;
18030 : : }
18031 : 313396 : goto done;
18032 : : }
18033 : 5794727 : 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 [ + + ]: 5794727 : if (p->error_indicator) {
18039 : 16 : p->level--;
18040 : 16 : 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 [ + + ]: 5794711 : if (
18046 : 5794711 : (a = t_primary_rule(p)) // t_primary
18047 [ + + ]: 1496499 : &&
18048 : 1496499 : (b = genexp_rule(p)) // genexp
18049 [ + + ]: 2941 : &&
18050 : 2941 : _PyPegen_lookahead(1, t_lookahead_rule, p)
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 : 28 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18055 [ - + ]: 28 : if (_token == NULL) {
18056 : 0 : p->level--;
18057 : 0 : return NULL;
18058 : : }
18059 : 28 : int _end_lineno = _token->end_lineno;
18060 : : UNUSED(_end_lineno); // Only used by EXTRA macro
18061 : 28 : int _end_col_offset = _token->end_col_offset;
18062 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
18063 : 28 : _res = _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
18064 [ - + - - ]: 28 : if (_res == NULL && PyErr_Occurred()) {
18065 : 0 : p->error_indicator = 1;
18066 : 0 : p->level--;
18067 : 0 : return NULL;
18068 : : }
18069 : 28 : goto done;
18070 : : }
18071 : 5794683 : 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 [ + + ]: 5794683 : if (p->error_indicator) {
18077 : 33 : p->level--;
18078 : 33 : 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 [ + + ]: 5794650 : if (
18086 : 5794650 : (a = t_primary_rule(p)) // t_primary
18087 [ + + ]: 1496438 : &&
18088 : 1496438 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
18089 : 1196029 : &&
18090 [ + + ]: 1196029 : (b = arguments_rule(p), !p->error_indicator) // arguments?
18091 [ + + ]: 1195984 : &&
18092 : 1195984 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
18093 [ + + ]: 1192997 : &&
18094 : 1192997 : _PyPegen_lookahead(1, t_lookahead_rule, p)
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 : 329853 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18099 [ - + ]: 329853 : if (_token == NULL) {
18100 : 0 : p->level--;
18101 : 0 : return NULL;
18102 : : }
18103 : 329853 : int _end_lineno = _token->end_lineno;
18104 : : UNUSED(_end_lineno); // Only used by EXTRA macro
18105 : 329853 : int _end_col_offset = _token->end_col_offset;
18106 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
18107 [ + + + + ]: 329853 : _res = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
18108 [ - + - - ]: 329853 : if (_res == NULL && PyErr_Occurred()) {
18109 : 0 : p->error_indicator = 1;
18110 : 0 : p->level--;
18111 : 0 : return NULL;
18112 : : }
18113 : 329853 : goto done;
18114 : : }
18115 : 5464797 : 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 [ + + ]: 5464797 : if (p->error_indicator) {
18121 : 45 : p->level--;
18122 : 45 : 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 [ + + ]: 5464752 : if (
18127 : 5464752 : (a = atom_rule(p)) // atom
18128 [ + + ]: 3925123 : &&
18129 : 3925123 : _PyPegen_lookahead(1, t_lookahead_rule, p)
18130 : : )
18131 : : {
18132 : : D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead"));
18133 : 2333176 : _res = a;
18134 [ - + - - ]: 2333176 : if (_res == NULL && PyErr_Occurred()) {
18135 : 0 : p->error_indicator = 1;
18136 : 0 : p->level--;
18137 : 0 : return NULL;
18138 : : }
18139 : 2333176 : goto done;
18140 : : }
18141 : 3131576 : 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 : 3131576 : _res = NULL;
18146 : 7175386 : done:
18147 : 7175386 : p->level--;
18148 : 7175386 : return _res;
18149 : : }
18150 : :
18151 : : // t_lookahead: '(' | '[' | '.'
18152 : : static void *
18153 : 7287630 : t_lookahead_rule(Parser *p)
18154 : : {
18155 [ - + ]: 7287630 : if (p->level++ == MAXSTACK) {
18156 : 0 : p->error_indicator = 1;
18157 : : PyErr_NoMemory();
18158 : : }
18159 [ - + ]: 7287630 : if (p->error_indicator) {
18160 : 0 : p->level--;
18161 : 0 : return NULL;
18162 : : }
18163 : 7287630 : void * _res = NULL;
18164 : 7287630 : int _mark = p->mark;
18165 : : { // '('
18166 [ - + ]: 7287630 : if (p->error_indicator) {
18167 : 0 : p->level--;
18168 : 0 : return NULL;
18169 : : }
18170 : : D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
18171 : : Token * _literal;
18172 [ + + ]: 7287630 : if (
18173 : 7287630 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
18174 : : )
18175 : : {
18176 : : D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
18177 : 1437066 : _res = _literal;
18178 : 1437066 : goto done;
18179 : : }
18180 : 5850564 : 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 [ + + ]: 5850564 : if (p->error_indicator) {
18186 : 7 : p->level--;
18187 : 7 : return NULL;
18188 : : }
18189 : : D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
18190 : : Token * _literal;
18191 [ + + ]: 5850557 : if (
18192 : 5850557 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
18193 : : )
18194 : : {
18195 : : D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
18196 : 454207 : _res = _literal;
18197 : 454207 : goto done;
18198 : : }
18199 : 5396350 : 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 [ - + ]: 5396350 : if (p->error_indicator) {
18205 : 0 : p->level--;
18206 : 0 : return NULL;
18207 : : }
18208 : : D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
18209 : : Token * _literal;
18210 [ + + ]: 5396350 : if (
18211 : 5396350 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
18212 : : )
18213 : : {
18214 : : D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
18215 : 2152537 : _res = _literal;
18216 : 2152537 : goto done;
18217 : : }
18218 : 3243813 : 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 : 3243813 : _res = NULL;
18223 : 7287623 : done:
18224 : 7287623 : p->level--;
18225 : 7287623 : return _res;
18226 : : }
18227 : :
18228 : : // del_targets: ','.del_target+ ','?
18229 : : static asdl_expr_seq*
18230 : 8930 : del_targets_rule(Parser *p)
18231 : : {
18232 [ - + ]: 8930 : if (p->level++ == MAXSTACK) {
18233 : 0 : p->error_indicator = 1;
18234 : : PyErr_NoMemory();
18235 : : }
18236 [ - + ]: 8930 : if (p->error_indicator) {
18237 : 0 : p->level--;
18238 : 0 : return NULL;
18239 : : }
18240 : 8930 : asdl_expr_seq* _res = NULL;
18241 : 8930 : int _mark = p->mark;
18242 : : { // ','.del_target+ ','?
18243 [ - + ]: 8930 : if (p->error_indicator) {
18244 : 0 : p->level--;
18245 : 0 : 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 [ + + ]: 8930 : if (
18252 : 8930 : (a = (asdl_expr_seq*)_gather_133_rule(p)) // ','.del_target+
18253 : 8864 : &&
18254 [ + - ]: 8864 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
18255 : : )
18256 : : {
18257 : : D(fprintf(stderr, "%*c+ del_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?"));
18258 : 8864 : _res = a;
18259 [ - + - - ]: 8864 : if (_res == NULL && PyErr_Occurred()) {
18260 : 0 : p->error_indicator = 1;
18261 : 0 : p->level--;
18262 : 0 : return NULL;
18263 : : }
18264 : 8864 : goto done;
18265 : : }
18266 : 66 : 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 : 66 : _res = NULL;
18271 : 8930 : done:
18272 : 8930 : p->level--;
18273 : 8930 : 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 : 10773 : del_target_rule(Parser *p)
18282 : : {
18283 [ - + ]: 10773 : if (p->level++ == MAXSTACK) {
18284 : 0 : p->error_indicator = 1;
18285 : : PyErr_NoMemory();
18286 : : }
18287 [ - + ]: 10773 : if (p->error_indicator) {
18288 : 0 : p->level--;
18289 : 0 : return NULL;
18290 : : }
18291 : 10773 : expr_ty _res = NULL;
18292 [ + + ]: 10773 : if (_PyPegen_is_memoized(p, del_target_type, &_res)) {
18293 : 68 : p->level--;
18294 : 68 : return _res;
18295 : : }
18296 : 10705 : int _mark = p->mark;
18297 [ - + - - ]: 10705 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18298 : 0 : p->error_indicator = 1;
18299 : 0 : p->level--;
18300 : 0 : return NULL;
18301 : : }
18302 : 10705 : int _start_lineno = p->tokens[_mark]->lineno;
18303 : : UNUSED(_start_lineno); // Only used by EXTRA macro
18304 : 10705 : 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 [ - + ]: 10705 : if (p->error_indicator) {
18308 : 0 : p->level--;
18309 : 0 : 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 [ + + ]: 10705 : if (
18316 : 10705 : (a = t_primary_rule(p)) // t_primary
18317 [ + + ]: 6189 : &&
18318 : 6189 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
18319 [ + - ]: 1427 : &&
18320 : 1427 : (b = _PyPegen_name_token(p)) // NAME
18321 [ + - ]: 1427 : &&
18322 : 1427 : _PyPegen_lookahead(0, t_lookahead_rule, p)
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 : 1427 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18327 [ - + ]: 1427 : if (_token == NULL) {
18328 : 0 : p->level--;
18329 : 0 : return NULL;
18330 : : }
18331 : 1427 : int _end_lineno = _token->end_lineno;
18332 : : UNUSED(_end_lineno); // Only used by EXTRA macro
18333 : 1427 : int _end_col_offset = _token->end_col_offset;
18334 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
18335 : 1427 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Del , EXTRA );
18336 [ - + - - ]: 1427 : if (_res == NULL && PyErr_Occurred()) {
18337 : 0 : p->error_indicator = 1;
18338 : 0 : p->level--;
18339 : 0 : return NULL;
18340 : : }
18341 : 1427 : goto done;
18342 : : }
18343 : 9278 : 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 [ + + ]: 9278 : if (p->error_indicator) {
18349 : 1 : p->level--;
18350 : 1 : 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 [ + + ]: 9277 : if (
18358 : 9277 : (a = t_primary_rule(p)) // t_primary
18359 [ + + ]: 4762 : &&
18360 : 4762 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
18361 [ + + ]: 4746 : &&
18362 : 4746 : (b = slices_rule(p)) // slices
18363 [ + + ]: 4742 : &&
18364 : 4742 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
18365 [ + - ]: 4736 : &&
18366 : 4736 : _PyPegen_lookahead(0, t_lookahead_rule, p)
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 : 4736 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18371 [ - + ]: 4736 : if (_token == NULL) {
18372 : 0 : p->level--;
18373 : 0 : return NULL;
18374 : : }
18375 : 4736 : int _end_lineno = _token->end_lineno;
18376 : : UNUSED(_end_lineno); // Only used by EXTRA macro
18377 : 4736 : int _end_col_offset = _token->end_col_offset;
18378 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
18379 : 4736 : _res = _PyAST_Subscript ( a , b , Del , EXTRA );
18380 [ - + - - ]: 4736 : if (_res == NULL && PyErr_Occurred()) {
18381 : 0 : p->error_indicator = 1;
18382 : 0 : p->level--;
18383 : 0 : return NULL;
18384 : : }
18385 : 4736 : goto done;
18386 : : }
18387 : 4541 : 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 [ - + ]: 4541 : if (p->error_indicator) {
18393 : 0 : p->level--;
18394 : 0 : 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 [ + + ]: 4541 : if (
18399 : 4541 : (del_t_atom_var = del_t_atom_rule(p)) // del_t_atom
18400 : : )
18401 : : {
18402 : : D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_t_atom"));
18403 : 4463 : _res = del_t_atom_var;
18404 : 4463 : goto done;
18405 : : }
18406 : 78 : 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 : 78 : _res = NULL;
18411 : 10704 : done:
18412 : 10704 : _PyPegen_insert_memo(p, _mark, del_target_type, _res);
18413 : 10704 : p->level--;
18414 : 10704 : return _res;
18415 : : }
18416 : :
18417 : : // del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']'
18418 : : static expr_ty
18419 : 4541 : del_t_atom_rule(Parser *p)
18420 : : {
18421 [ - + ]: 4541 : if (p->level++ == MAXSTACK) {
18422 : 0 : p->error_indicator = 1;
18423 : : PyErr_NoMemory();
18424 : : }
18425 [ - + ]: 4541 : if (p->error_indicator) {
18426 : 0 : p->level--;
18427 : 0 : return NULL;
18428 : : }
18429 : 4541 : expr_ty _res = NULL;
18430 : 4541 : int _mark = p->mark;
18431 [ - + - - ]: 4541 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18432 : 0 : p->error_indicator = 1;
18433 : 0 : p->level--;
18434 : 0 : return NULL;
18435 : : }
18436 : 4541 : int _start_lineno = p->tokens[_mark]->lineno;
18437 : : UNUSED(_start_lineno); // Only used by EXTRA macro
18438 : 4541 : int _start_col_offset = p->tokens[_mark]->col_offset;
18439 : : UNUSED(_start_col_offset); // Only used by EXTRA macro
18440 : : { // NAME
18441 [ - + ]: 4541 : if (p->error_indicator) {
18442 : 0 : p->level--;
18443 : 0 : 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 [ + + ]: 4541 : if (
18448 : 4541 : (a = _PyPegen_name_token(p)) // NAME
18449 : : )
18450 : : {
18451 : : D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
18452 : 4402 : _res = _PyPegen_set_expr_context ( p , a , Del );
18453 [ - + - - ]: 4402 : if (_res == NULL && PyErr_Occurred()) {
18454 : 0 : p->error_indicator = 1;
18455 : 0 : p->level--;
18456 : 0 : return NULL;
18457 : : }
18458 : 4402 : goto done;
18459 : : }
18460 : 139 : 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 [ - + ]: 139 : if (p->error_indicator) {
18466 : 0 : p->level--;
18467 : 0 : 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 [ + + ]: 139 : if (
18474 : 139 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
18475 [ + + ]: 78 : &&
18476 : 78 : (a = del_target_rule(p)) // del_target
18477 [ + + ]: 63 : &&
18478 : 63 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
18479 : : )
18480 : : {
18481 : : D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'"));
18482 : 10 : _res = _PyPegen_set_expr_context ( p , a , Del );
18483 [ - + - - ]: 10 : if (_res == NULL && PyErr_Occurred()) {
18484 : 0 : p->error_indicator = 1;
18485 : 0 : p->level--;
18486 : 0 : return NULL;
18487 : : }
18488 : 10 : goto done;
18489 : : }
18490 : 129 : 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 [ - + ]: 129 : if (p->error_indicator) {
18496 : 0 : p->level--;
18497 : 0 : 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 [ + + ]: 129 : if (
18504 : 129 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
18505 : 68 : &&
18506 [ + - ]: 68 : (a = del_targets_rule(p), !p->error_indicator) // del_targets?
18507 [ + + ]: 68 : &&
18508 : 68 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
18509 : : )
18510 : : {
18511 : : D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'"));
18512 : 42 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18513 [ - + ]: 42 : if (_token == NULL) {
18514 : 0 : p->level--;
18515 : 0 : return NULL;
18516 : : }
18517 : 42 : int _end_lineno = _token->end_lineno;
18518 : : UNUSED(_end_lineno); // Only used by EXTRA macro
18519 : 42 : int _end_col_offset = _token->end_col_offset;
18520 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
18521 : 42 : _res = _PyAST_Tuple ( a , Del , EXTRA );
18522 [ - + - - ]: 42 : if (_res == NULL && PyErr_Occurred()) {
18523 : 0 : p->error_indicator = 1;
18524 : 0 : p->level--;
18525 : 0 : return NULL;
18526 : : }
18527 : 42 : goto done;
18528 : : }
18529 : 87 : 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 [ - + ]: 87 : if (p->error_indicator) {
18535 : 0 : p->level--;
18536 : 0 : 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 [ + + ]: 87 : if (
18543 : 87 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
18544 : 18 : &&
18545 [ + - ]: 18 : (a = del_targets_rule(p), !p->error_indicator) // del_targets?
18546 [ + + ]: 18 : &&
18547 : 18 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
18548 : : )
18549 : : {
18550 : : D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'"));
18551 : 9 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18552 [ - + ]: 9 : if (_token == NULL) {
18553 : 0 : p->level--;
18554 : 0 : return NULL;
18555 : : }
18556 : 9 : int _end_lineno = _token->end_lineno;
18557 : : UNUSED(_end_lineno); // Only used by EXTRA macro
18558 : 9 : int _end_col_offset = _token->end_col_offset;
18559 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
18560 : 9 : _res = _PyAST_List ( a , Del , EXTRA );
18561 [ - + - - ]: 9 : if (_res == NULL && PyErr_Occurred()) {
18562 : 0 : p->error_indicator = 1;
18563 : 0 : p->level--;
18564 : 0 : return NULL;
18565 : : }
18566 : 9 : goto done;
18567 : : }
18568 : 78 : 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 : 78 : _res = NULL;
18573 : 4541 : done:
18574 : 4541 : p->level--;
18575 : 4541 : 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 : 18 : type_expressions_rule(Parser *p)
18588 : : {
18589 [ - + ]: 18 : if (p->level++ == MAXSTACK) {
18590 : 0 : p->error_indicator = 1;
18591 : : PyErr_NoMemory();
18592 : : }
18593 [ - + ]: 18 : if (p->error_indicator) {
18594 : 0 : p->level--;
18595 : 0 : return NULL;
18596 : : }
18597 : 18 : asdl_expr_seq* _res = NULL;
18598 : 18 : int _mark = p->mark;
18599 : : { // ','.expression+ ',' '*' expression ',' '**' expression
18600 [ - + ]: 18 : if (p->error_indicator) {
18601 : 0 : p->level--;
18602 : 0 : 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 [ + + ]: 18 : if (
18613 : 18 : (a = _gather_135_rule(p)) // ','.expression+
18614 [ + + ]: 10 : &&
18615 : 10 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
18616 [ + + ]: 5 : &&
18617 : 5 : (_literal_1 = _PyPegen_expect_token(p, 16)) // token='*'
18618 [ + - ]: 3 : &&
18619 : 3 : (b = expression_rule(p)) // expression
18620 [ + - ]: 3 : &&
18621 : 3 : (_literal_2 = _PyPegen_expect_token(p, 12)) // token=','
18622 [ + + ]: 3 : &&
18623 : 3 : (_literal_3 = _PyPegen_expect_token(p, 35)) // token='**'
18624 [ + - ]: 1 : &&
18625 : 1 : (c = expression_rule(p)) // expression
18626 : : )
18627 : : {
18628 : : D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
18629 : 1 : _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_seq_append_to_end ( p , a , b ) ) , c );
18630 [ - + - - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
18631 : 0 : p->error_indicator = 1;
18632 : 0 : p->level--;
18633 : 0 : return NULL;
18634 : : }
18635 : 1 : goto done;
18636 : : }
18637 : 17 : 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 [ - + ]: 17 : if (p->error_indicator) {
18643 : 0 : p->level--;
18644 : 0 : 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 [ + + ]: 17 : if (
18652 : 17 : (a = _gather_137_rule(p)) // ','.expression+
18653 [ + + ]: 9 : &&
18654 : 9 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
18655 [ + + ]: 4 : &&
18656 : 4 : (_literal_1 = _PyPegen_expect_token(p, 16)) // token='*'
18657 [ + - ]: 2 : &&
18658 : 2 : (b = expression_rule(p)) // expression
18659 : : )
18660 : : {
18661 : : D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression"));
18662 : 2 : _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b );
18663 [ - + - - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
18664 : 0 : p->error_indicator = 1;
18665 : 0 : p->level--;
18666 : 0 : return NULL;
18667 : : }
18668 : 2 : goto done;
18669 : : }
18670 : 15 : 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 [ - + ]: 15 : if (p->error_indicator) {
18676 : 0 : p->level--;
18677 : 0 : 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 [ + + ]: 15 : if (
18685 : 15 : (a = _gather_139_rule(p)) // ','.expression+
18686 [ + + ]: 7 : &&
18687 : 7 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
18688 [ + - ]: 2 : &&
18689 : 2 : (_literal_1 = _PyPegen_expect_token(p, 35)) // token='**'
18690 [ + - ]: 2 : &&
18691 : 2 : (b = expression_rule(p)) // expression
18692 : : )
18693 : : {
18694 : : D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression"));
18695 : 2 : _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b );
18696 [ - + - - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
18697 : 0 : p->error_indicator = 1;
18698 : 0 : p->level--;
18699 : 0 : return NULL;
18700 : : }
18701 : 2 : goto done;
18702 : : }
18703 : 13 : 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 [ - + ]: 13 : if (p->error_indicator) {
18709 : 0 : p->level--;
18710 : 0 : 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 [ + + ]: 13 : if (
18719 : 13 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
18720 [ + - ]: 2 : &&
18721 : 2 : (a = expression_rule(p)) // expression
18722 [ + + ]: 2 : &&
18723 : 2 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
18724 [ + - ]: 1 : &&
18725 : 1 : (_literal_2 = _PyPegen_expect_token(p, 35)) // token='**'
18726 [ + - ]: 1 : &&
18727 : 1 : (b = expression_rule(p)) // expression
18728 : : )
18729 : : {
18730 : : D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression"));
18731 : 1 : _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_singleton_seq ( p , a ) ) , b );
18732 [ - + - - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
18733 : 0 : p->error_indicator = 1;
18734 : 0 : p->level--;
18735 : 0 : return NULL;
18736 : : }
18737 : 1 : goto done;
18738 : : }
18739 : 12 : 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 [ - + ]: 12 : if (p->error_indicator) {
18745 : 0 : p->level--;
18746 : 0 : 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 [ + + ]: 12 : if (
18752 : 12 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
18753 [ + - ]: 1 : &&
18754 : 1 : (a = expression_rule(p)) // expression
18755 : : )
18756 : : {
18757 : : D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression"));
18758 : 1 : _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a );
18759 [ - + - - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
18760 : 0 : p->error_indicator = 1;
18761 : 0 : p->level--;
18762 : 0 : return NULL;
18763 : : }
18764 : 1 : goto done;
18765 : : }
18766 : 11 : 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 [ - + ]: 11 : if (p->error_indicator) {
18772 : 0 : p->level--;
18773 : 0 : 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 [ + + ]: 11 : if (
18779 : 11 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
18780 [ + - ]: 3 : &&
18781 : 3 : (a = expression_rule(p)) // expression
18782 : : )
18783 : : {
18784 : : D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression"));
18785 : 3 : _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a );
18786 [ - + - - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
18787 : 0 : p->error_indicator = 1;
18788 : 0 : p->level--;
18789 : 0 : return NULL;
18790 : : }
18791 : 3 : goto done;
18792 : : }
18793 : 8 : 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 [ - + ]: 8 : if (p->error_indicator) {
18799 : 0 : p->level--;
18800 : 0 : 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 [ + + ]: 8 : if (
18805 : 8 : (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 : 5 : _res = a;
18810 [ - + - - ]: 5 : if (_res == NULL && PyErr_Occurred()) {
18811 : 0 : p->error_indicator = 1;
18812 : 0 : p->level--;
18813 : 0 : return NULL;
18814 : : }
18815 : 5 : goto done;
18816 : : }
18817 : 3 : 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 : 3 : _res = NULL;
18822 : 18 : done:
18823 : 18 : p->level--;
18824 : 18 : 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 : 340280 : func_type_comment_rule(Parser *p)
18833 : : {
18834 [ - + ]: 340280 : if (p->level++ == MAXSTACK) {
18835 : 0 : p->error_indicator = 1;
18836 : : PyErr_NoMemory();
18837 : : }
18838 [ - + ]: 340280 : if (p->error_indicator) {
18839 : 0 : p->level--;
18840 : 0 : return NULL;
18841 : : }
18842 : 340280 : Token* _res = NULL;
18843 : 340280 : int _mark = p->mark;
18844 : : { // NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
18845 [ - + ]: 340280 : if (p->error_indicator) {
18846 : 0 : p->level--;
18847 : 0 : 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 [ + + ]: 340280 : if (
18853 : 340280 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
18854 [ + + ]: 334238 : &&
18855 : 334238 : (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
18856 [ + - ]: 27 : &&
18857 : 27 : _PyPegen_lookahead(1, _tmp_143_rule, p)
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 : 27 : _res = t;
18862 [ - + - - ]: 27 : if (_res == NULL && PyErr_Occurred()) {
18863 : 0 : p->error_indicator = 1;
18864 : 0 : p->level--;
18865 : 0 : return NULL;
18866 : : }
18867 : 27 : goto done;
18868 : : }
18869 : 340253 : 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 [ + + ]: 340253 : if (p->call_invalid_rules) { // invalid_double_type_comments
18874 [ - + ]: 63 : if (p->error_indicator) {
18875 : 0 : p->level--;
18876 : 0 : 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 [ - + ]: 63 : if (
18881 : 63 : (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 : 0 : _res = invalid_double_type_comments_var;
18886 : 0 : goto done;
18887 : : }
18888 : 63 : 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 [ + + ]: 340253 : if (p->error_indicator) {
18894 : 9 : p->level--;
18895 : 9 : 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 [ + + ]: 340244 : if (
18900 : 340244 : (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
18901 : : )
18902 : : {
18903 : : D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT"));
18904 : 34 : _res = type_comment_var;
18905 : 34 : goto done;
18906 : : }
18907 : 340210 : 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 : 340210 : _res = NULL;
18912 : 340271 : done:
18913 : 340271 : p->level--;
18914 : 340271 : 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 : 94 : invalid_arguments_rule(Parser *p)
18926 : : {
18927 [ - + ]: 94 : if (p->level++ == MAXSTACK) {
18928 : 0 : p->error_indicator = 1;
18929 : : PyErr_NoMemory();
18930 : : }
18931 [ - + ]: 94 : if (p->error_indicator) {
18932 : 0 : p->level--;
18933 : 0 : return NULL;
18934 : : }
18935 : 94 : void * _res = NULL;
18936 : 94 : int _mark = p->mark;
18937 : : { // args ',' '*'
18938 [ - + ]: 94 : if (p->error_indicator) {
18939 : 0 : p->level--;
18940 : 0 : 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 [ + + ]: 94 : if (
18947 : 94 : (a = args_rule(p)) // args
18948 [ + + ]: 44 : &&
18949 : 44 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
18950 [ + + ]: 13 : &&
18951 : 13 : (_literal_1 = _PyPegen_expect_token(p, 16)) // token='*'
18952 : : )
18953 : : {
18954 : : D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' '*'"));
18955 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable argument unpacking follows keyword argument unpacking" );
18956 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
18957 : 1 : p->error_indicator = 1;
18958 : 1 : p->level--;
18959 : 1 : return NULL;
18960 : : }
18961 : 0 : goto done;
18962 : : }
18963 : 93 : 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 [ - + ]: 93 : if (p->error_indicator) {
18969 : 0 : p->level--;
18970 : 0 : 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 [ + + ]: 93 : if (
18979 : 93 : (a = expression_rule(p)) // expression
18980 [ + + ]: 42 : &&
18981 : 42 : (b = for_if_clauses_rule(p)) // for_if_clauses
18982 [ + + ]: 12 : &&
18983 : 12 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
18984 : 11 : &&
18985 [ + + ]: 11 : (_opt_var = _tmp_144_rule(p), !p->error_indicator) // [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 : 10 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" );
18990 [ + - + - ]: 10 : if (_res == NULL && PyErr_Occurred()) {
18991 : 10 : p->error_indicator = 1;
18992 : 10 : p->level--;
18993 : 10 : return NULL;
18994 : : }
18995 : 0 : goto done;
18996 : : }
18997 : 83 : 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 [ + + ]: 83 : if (p->error_indicator) {
19003 : 1 : p->level--;
19004 : 1 : 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 [ + + ]: 82 : if (
19012 : 82 : (a = _PyPegen_name_token(p)) // NAME
19013 [ + + ]: 28 : &&
19014 : 28 : (b = _PyPegen_expect_token(p, 22)) // token='='
19015 [ + + ]: 13 : &&
19016 : 13 : (expression_var = expression_rule(p)) // expression
19017 [ - + ]: 12 : &&
19018 : 12 : (for_if_clauses_var = for_if_clauses_rule(p)) // 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 : 0 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" );
19023 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
19024 : 0 : p->error_indicator = 1;
19025 : 0 : p->level--;
19026 : 0 : return NULL;
19027 : : }
19028 : 0 : goto done;
19029 : : }
19030 : 82 : 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 [ - + ]: 82 : if (p->error_indicator) {
19036 : 0 : p->level--;
19037 : 0 : 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 [ + + ]: 82 : if (
19043 : 82 : (a = args_rule(p)) // args
19044 [ + + ]: 32 : &&
19045 : 32 : (b = for_if_clauses_rule(p)) // for_if_clauses
19046 : : )
19047 : : {
19048 : : D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args for_if_clauses"));
19049 : 11 : _res = _PyPegen_nonparen_genexp_in_call ( p , a , b );
19050 [ + - + + ]: 11 : if (_res == NULL && PyErr_Occurred()) {
19051 : 9 : p->error_indicator = 1;
19052 : 9 : p->level--;
19053 : 9 : return NULL;
19054 : : }
19055 : 2 : goto done;
19056 : : }
19057 : 71 : 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 [ - + ]: 71 : if (p->error_indicator) {
19063 : 0 : p->level--;
19064 : 0 : 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 [ + + ]: 71 : if (
19072 : 71 : (args_var = args_rule(p)) // args
19073 [ + + ]: 21 : &&
19074 : 21 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
19075 [ + + ]: 12 : &&
19076 : 12 : (a = expression_rule(p)) // expression
19077 [ - + ]: 11 : &&
19078 : 11 : (b = for_if_clauses_rule(p)) // 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 : 0 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" );
19083 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
19084 : 0 : p->error_indicator = 1;
19085 : 0 : p->level--;
19086 : 0 : return NULL;
19087 : : }
19088 : 0 : goto done;
19089 : : }
19090 : 71 : 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 [ - + ]: 71 : if (p->error_indicator) {
19096 : 0 : p->level--;
19097 : 0 : 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 [ + + ]: 71 : if (
19104 : 71 : (a = args_rule(p)) // args
19105 [ + + ]: 21 : &&
19106 : 21 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
19107 [ + + ]: 12 : &&
19108 : 12 : (args_var = args_rule(p)) // args
19109 : : )
19110 : : {
19111 : : D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' args"));
19112 : 11 : _res = _PyPegen_arguments_parsing_error ( p , a );
19113 [ + - + - ]: 11 : if (_res == NULL && PyErr_Occurred()) {
19114 : 11 : p->error_indicator = 1;
19115 : 11 : p->level--;
19116 : 11 : return NULL;
19117 : : }
19118 : 0 : goto done;
19119 : : }
19120 : 60 : 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 : 60 : _res = NULL;
19125 : 62 : done:
19126 : 62 : p->level--;
19127 : 62 : return _res;
19128 : : }
19129 : :
19130 : : // invalid_kwarg:
19131 : : // | ('True' | 'False' | 'None') '='
19132 : : // | NAME '=' expression for_if_clauses
19133 : : // | !(NAME '=') expression '='
19134 : : static void *
19135 : 1130 : invalid_kwarg_rule(Parser *p)
19136 : : {
19137 [ - + ]: 1130 : if (p->level++ == MAXSTACK) {
19138 : 0 : p->error_indicator = 1;
19139 : : PyErr_NoMemory();
19140 : : }
19141 [ - + ]: 1130 : if (p->error_indicator) {
19142 : 0 : p->level--;
19143 : 0 : return NULL;
19144 : : }
19145 : 1130 : void * _res = NULL;
19146 : 1130 : int _mark = p->mark;
19147 : : { // ('True' | 'False' | 'None') '='
19148 [ - + ]: 1130 : if (p->error_indicator) {
19149 : 0 : p->level--;
19150 : 0 : 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 [ + + ]: 1130 : if (
19156 : 1130 : (a = (Token*)_tmp_145_rule(p)) // 'True' | 'False' | 'None'
19157 [ + - ]: 4 : &&
19158 : 4 : (b = _PyPegen_expect_token(p, 22)) // token='='
19159 : : )
19160 : : {
19161 : : D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('True' | 'False' | 'None') '='"));
19162 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to %s" , PyBytes_AS_STRING ( a -> bytes ) );
19163 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
19164 : 4 : p->error_indicator = 1;
19165 : 4 : p->level--;
19166 : 4 : return NULL;
19167 : : }
19168 : 0 : goto done;
19169 : : }
19170 : 1126 : 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 [ - + ]: 1126 : if (p->error_indicator) {
19176 : 0 : p->level--;
19177 : 0 : 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 [ + + ]: 1126 : if (
19185 : 1126 : (a = _PyPegen_name_token(p)) // NAME
19186 [ + + ]: 277 : &&
19187 : 277 : (b = _PyPegen_expect_token(p, 22)) // token='='
19188 [ + + ]: 168 : &&
19189 : 168 : (expression_var = expression_rule(p)) // expression
19190 [ + + ]: 153 : &&
19191 : 153 : (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
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 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" );
19196 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
19197 : 1 : p->error_indicator = 1;
19198 : 1 : p->level--;
19199 : 1 : return NULL;
19200 : : }
19201 : 0 : goto done;
19202 : : }
19203 : 1125 : 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 [ - + ]: 1125 : if (p->error_indicator) {
19209 : 0 : p->level--;
19210 : 0 : 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 [ + + ]: 1125 : if (
19216 : 1125 : _PyPegen_lookahead(0, _tmp_146_rule, p)
19217 [ + + ]: 958 : &&
19218 : 958 : (a = expression_rule(p)) // expression
19219 [ + + ]: 164 : &&
19220 : 164 : (b = _PyPegen_expect_token(p, 22)) // token='='
19221 : : )
19222 : : {
19223 : : D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='"));
19224 : 9 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expression cannot contain assignment, perhaps you meant \"==\"?" );
19225 [ + - + - ]: 9 : if (_res == NULL && PyErr_Occurred()) {
19226 : 9 : p->error_indicator = 1;
19227 : 9 : p->level--;
19228 : 9 : return NULL;
19229 : : }
19230 : 0 : goto done;
19231 : : }
19232 : 1116 : 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 : 1116 : _res = NULL;
19237 : 1116 : done:
19238 : 1116 : p->level--;
19239 : 1116 : return _res;
19240 : : }
19241 : :
19242 : : // expression_without_invalid:
19243 : : // | disjunction 'if' disjunction 'else' expression
19244 : : // | disjunction
19245 : : // | lambdef
19246 : : static expr_ty
19247 : 1161 : expression_without_invalid_rule(Parser *p)
19248 : : {
19249 : 1161 : int _prev_call_invalid = p->call_invalid_rules;
19250 : 1161 : p->call_invalid_rules = 0;
19251 [ - + ]: 1161 : if (p->level++ == MAXSTACK) {
19252 : 0 : p->error_indicator = 1;
19253 : : PyErr_NoMemory();
19254 : : }
19255 [ - + ]: 1161 : if (p->error_indicator) {
19256 : 0 : p->call_invalid_rules = _prev_call_invalid;
19257 : 0 : p->level--;
19258 : 0 : return NULL;
19259 : : }
19260 : 1161 : expr_ty _res = NULL;
19261 : 1161 : int _mark = p->mark;
19262 [ - + - - ]: 1161 : if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
19263 : 0 : p->error_indicator = 1;
19264 : 0 : p->call_invalid_rules = _prev_call_invalid;
19265 : 0 : p->level--;
19266 : 0 : return NULL;
19267 : : }
19268 : 1161 : int _start_lineno = p->tokens[_mark]->lineno;
19269 : : UNUSED(_start_lineno); // Only used by EXTRA macro
19270 : 1161 : 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 [ - + ]: 1161 : if (p->error_indicator) {
19274 : 0 : p->call_invalid_rules = _prev_call_invalid;
19275 : 0 : p->level--;
19276 : 0 : 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 [ + + ]: 1161 : if (
19285 : 1161 : (a = disjunction_rule(p)) // disjunction
19286 [ - + ]: 53 : &&
19287 : 53 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
19288 [ # # ]: 0 : &&
19289 : 0 : (b = disjunction_rule(p)) // disjunction
19290 [ # # ]: 0 : &&
19291 : 0 : (_keyword_1 = _PyPegen_expect_token(p, 637)) // token='else'
19292 [ # # ]: 0 : &&
19293 : 0 : (c = expression_rule(p)) // 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 : 0 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19298 [ # # ]: 0 : if (_token == NULL) {
19299 : 0 : p->call_invalid_rules = _prev_call_invalid;
19300 : 0 : p->level--;
19301 : 0 : return NULL;
19302 : : }
19303 : 0 : int _end_lineno = _token->end_lineno;
19304 : : UNUSED(_end_lineno); // Only used by EXTRA macro
19305 : 0 : int _end_col_offset = _token->end_col_offset;
19306 : : UNUSED(_end_col_offset); // Only used by EXTRA macro
19307 : 0 : _res = _PyAST_IfExp ( b , a , c , EXTRA );
19308 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
19309 : 0 : p->error_indicator = 1;
19310 : 0 : p->call_invalid_rules = _prev_call_invalid;
19311 : 0 : p->level--;
19312 : 0 : return NULL;
19313 : : }
19314 : 0 : goto done;
19315 : : }
19316 : 1161 : 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 [ + + ]: 1161 : if (p->error_indicator) {
19322 : 2 : p->call_invalid_rules = _prev_call_invalid;
19323 : 2 : p->level--;
19324 : 2 : 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 [ + + ]: 1159 : if (
19329 : 1159 : (disjunction_var = disjunction_rule(p)) // disjunction
19330 : : )
19331 : : {
19332 : : D(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction"));
19333 : 53 : _res = disjunction_var;
19334 : 53 : goto done;
19335 : : }
19336 : 1106 : 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 [ - + ]: 1106 : if (p->error_indicator) {
19342 : 0 : p->call_invalid_rules = _prev_call_invalid;
19343 : 0 : p->level--;
19344 : 0 : 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 [ - + ]: 1106 : if (
19349 : 1106 : (lambdef_var = lambdef_rule(p)) // lambdef
19350 : : )
19351 : : {
19352 : : D(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef"));
19353 : 0 : _res = lambdef_var;
19354 : 0 : goto done;
19355 : : }
19356 : 1106 : 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 : 1106 : _res = NULL;
19361 : 1159 : done:
19362 : 1159 : p->call_invalid_rules = _prev_call_invalid;
19363 : 1159 : p->level--;
19364 : 1159 : return _res;
19365 : : }
19366 : :
19367 : : // invalid_legacy_expression: NAME !'(' star_expressions
19368 : : static void *
19369 : 2674 : invalid_legacy_expression_rule(Parser *p)
19370 : : {
19371 [ - + ]: 2674 : if (p->level++ == MAXSTACK) {
19372 : 0 : p->error_indicator = 1;
19373 : : PyErr_NoMemory();
19374 : : }
19375 [ - + ]: 2674 : if (p->error_indicator) {
19376 : 0 : p->level--;
19377 : 0 : return NULL;
19378 : : }
19379 : 2674 : void * _res = NULL;
19380 : 2674 : int _mark = p->mark;
19381 : : { // NAME !'(' star_expressions
19382 [ - + ]: 2674 : if (p->error_indicator) {
19383 : 0 : p->level--;
19384 : 0 : 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 [ + + ]: 2674 : if (
19390 : 2674 : (a = _PyPegen_name_token(p)) // NAME
19391 [ + + ]: 693 : &&
19392 : 693 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 7) // token='('
19393 [ + + ]: 598 : &&
19394 : 598 : (b = star_expressions_rule(p)) // star_expressions
19395 : : )
19396 : : {
19397 : : D(fprintf(stderr, "%*c+ invalid_legacy_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME !'(' star_expressions"));
19398 [ + + ]: 126 : _res = _PyPegen_check_legacy_stmt ( p , a ) ? RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Missing parentheses in call to '%U'. Did you mean %U(...)?" , a -> v . Name . id , a -> v . Name . id ) : NULL;
19399 [ + - + + ]: 126 : if (_res == NULL && PyErr_Occurred()) {
19400 : 27 : p->error_indicator = 1;
19401 : 27 : p->level--;
19402 : 27 : return NULL;
19403 : : }
19404 : 99 : goto done;
19405 : : }
19406 : 2548 : 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 : 2548 : _res = NULL;
19411 : 2647 : done:
19412 : 2647 : p->level--;
19413 : 2647 : 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 : 2706 : invalid_expression_rule(Parser *p)
19421 : : {
19422 [ - + ]: 2706 : if (p->level++ == MAXSTACK) {
19423 : 0 : p->error_indicator = 1;
19424 : : PyErr_NoMemory();
19425 : : }
19426 [ - + ]: 2706 : if (p->error_indicator) {
19427 : 0 : p->level--;
19428 : 0 : return NULL;
19429 : : }
19430 : 2706 : void * _res = NULL;
19431 : 2706 : int _mark = p->mark;
19432 : : { // !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid
19433 [ - + ]: 2706 : if (p->error_indicator) {
19434 : 0 : p->level--;
19435 : 0 : 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 [ + + ]: 2706 : if (
19441 : 2706 : _PyPegen_lookahead(0, _tmp_147_rule, p)
19442 [ + + ]: 2612 : &&
19443 : 2612 : (a = disjunction_rule(p)) // disjunction
19444 [ + + ]: 1161 : &&
19445 : 1161 : (b = expression_without_invalid_rule(p)) // expression_without_invalid
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 [ + + + + ]: 53 : _res = _PyPegen_check_legacy_stmt ( p , a ) ? NULL : p -> tokens [p -> mark - 1] -> level == 0 ? NULL : RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Perhaps you forgot a comma?" );
19450 [ + - + + ]: 53 : if (_res == NULL && PyErr_Occurred()) {
19451 : 10 : p->error_indicator = 1;
19452 : 10 : p->level--;
19453 : 10 : return NULL;
19454 : : }
19455 : 43 : goto done;
19456 : : }
19457 : 2653 : 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 [ + + ]: 2653 : if (p->error_indicator) {
19463 : 18 : p->level--;
19464 : 18 : 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 [ + + ]: 2635 : if (
19471 : 2635 : (a = disjunction_rule(p)) // disjunction
19472 [ + + ]: 1200 : &&
19473 : 1200 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
19474 [ + - ]: 7 : &&
19475 : 7 : (b = disjunction_rule(p)) // disjunction
19476 [ + + ]: 7 : &&
19477 : 7 : _PyPegen_lookahead(0, _tmp_148_rule, p)
19478 : : )
19479 : : {
19480 : : D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')"));
19481 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expected 'else' after 'if' expression" );
19482 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
19483 : 4 : p->error_indicator = 1;
19484 : 4 : p->level--;
19485 : 4 : return NULL;
19486 : : }
19487 : 0 : goto done;
19488 : : }
19489 : 2631 : 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 : 2631 : _res = NULL;
19494 : 2674 : done:
19495 : 2674 : p->level--;
19496 : 2674 : 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 : 2435 : invalid_named_expression_rule(Parser *p)
19505 : : {
19506 [ - + ]: 2435 : if (p->level++ == MAXSTACK) {
19507 : 0 : p->error_indicator = 1;
19508 : : PyErr_NoMemory();
19509 : : }
19510 [ - + ]: 2435 : if (p->error_indicator) {
19511 : 0 : p->level--;
19512 : 0 : return NULL;
19513 : : }
19514 : 2435 : void * _res = NULL;
19515 [ + + ]: 2435 : if (_PyPegen_is_memoized(p, invalid_named_expression_type, &_res)) {
19516 : 1102 : p->level--;
19517 : 1102 : return _res;
19518 : : }
19519 : 1333 : int _mark = p->mark;
19520 : : { // expression ':=' expression
19521 [ - + ]: 1333 : if (p->error_indicator) {
19522 : 0 : p->level--;
19523 : 0 : 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 [ + + ]: 1333 : if (
19530 : 1333 : (a = expression_rule(p)) // expression
19531 [ + + ]: 502 : &&
19532 : 502 : (_literal = _PyPegen_expect_token(p, 53)) // token=':='
19533 [ + - ]: 3 : &&
19534 : 3 : (expression_var = expression_rule(p)) // expression
19535 : : )
19536 : : {
19537 : : D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':=' expression"));
19538 : 3 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) );
19539 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
19540 : 3 : p->error_indicator = 1;
19541 : 3 : p->level--;
19542 : 3 : return NULL;
19543 : : }
19544 : 0 : goto done;
19545 : : }
19546 : 1330 : 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 [ + + ]: 1330 : if (p->error_indicator) {
19552 : 83 : p->level--;
19553 : 83 : 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 [ + + ]: 1247 : if (
19560 : 1247 : (a = _PyPegen_name_token(p)) // NAME
19561 [ + + ]: 258 : &&
19562 : 258 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
19563 [ + + ]: 12 : &&
19564 : 12 : (b = bitwise_or_rule(p)) // bitwise_or
19565 [ + + ]: 11 : &&
19566 : 11 : _PyPegen_lookahead(0, _tmp_149_rule, p)
19567 : : )
19568 : : {
19569 : : D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')"));
19570 : 8 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" );
19571 [ + - + - ]: 8 : if (_res == NULL && PyErr_Occurred()) {
19572 : 8 : p->error_indicator = 1;
19573 : 8 : p->level--;
19574 : 8 : return NULL;
19575 : : }
19576 : 0 : goto done;
19577 : : }
19578 : 1239 : 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 [ - + ]: 1239 : if (p->error_indicator) {
19584 : 0 : p->level--;
19585 : 0 : 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 [ + + ]: 1239 : if (
19592 : 1239 : _PyPegen_lookahead(0, _tmp_150_rule, p)
19593 [ + + ]: 1173 : &&
19594 : 1173 : (a = bitwise_or_rule(p)) // bitwise_or
19595 [ + + ]: 423 : &&
19596 : 423 : (b = _PyPegen_expect_token(p, 22)) // token='='
19597 [ + + ]: 35 : &&
19598 : 35 : (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
19599 [ + + ]: 34 : &&
19600 : 34 : _PyPegen_lookahead(0, _tmp_151_rule, p)
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 : 31 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot assign to %s here. Maybe you meant '==' instead of '='?" , _PyPegen_get_expr_name ( a ) );
19605 [ + - + - ]: 31 : if (_res == NULL && PyErr_Occurred()) {
19606 : 31 : p->error_indicator = 1;
19607 : 31 : p->level--;
19608 : 31 : return NULL;
19609 : : }
19610 : 0 : goto done;
19611 : : }
19612 : 1208 : 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 : 1208 : _res = NULL;
19617 : 1208 : done:
19618 : 1208 : _PyPegen_insert_memo(p, _mark, invalid_named_expression_type, _res);
19619 : 1208 : p->level--;
19620 : 1208 : 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 : 901 : invalid_assignment_rule(Parser *p)
19632 : : {
19633 [ - + ]: 901 : if (p->level++ == MAXSTACK) {
19634 : 0 : p->error_indicator = 1;
19635 : : PyErr_NoMemory();
19636 : : }
19637 [ - + ]: 901 : if (p->error_indicator) {
19638 : 0 : p->level--;
19639 : 0 : return NULL;
19640 : : }
19641 : 901 : void * _res = NULL;
19642 : 901 : int _mark = p->mark;
19643 : : { // invalid_ann_assign_target ':' expression
19644 [ - + ]: 901 : if (p->error_indicator) {
19645 : 0 : p->level--;
19646 : 0 : 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 [ + + ]: 901 : if (
19653 : 901 : (a = invalid_ann_assign_target_rule(p)) // invalid_ann_assign_target
19654 [ + + ]: 17 : &&
19655 : 17 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
19656 [ + - ]: 7 : &&
19657 : 7 : (expression_var = expression_rule(p)) // 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 : 7 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not %s) can be annotated" , _PyPegen_get_expr_name ( a ) );
19662 [ + - + - ]: 7 : if (_res == NULL && PyErr_Occurred()) {
19663 : 7 : p->error_indicator = 1;
19664 : 7 : p->level--;
19665 : 7 : return NULL;
19666 : : }
19667 : 0 : goto done;
19668 : : }
19669 : 894 : 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 [ - + ]: 894 : if (p->error_indicator) {
19675 : 0 : p->level--;
19676 : 0 : 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 [ + + ]: 894 : if (
19685 : 894 : (a = star_named_expression_rule(p)) // star_named_expression
19686 [ + + ]: 156 : &&
19687 : 156 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
19688 [ + - ]: 5 : &&
19689 : 5 : (_loop0_152_var = _loop0_152_rule(p)) // star_named_expressions*
19690 [ + + ]: 5 : &&
19691 : 5 : (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
19692 [ + - ]: 1 : &&
19693 : 1 : (expression_var = expression_rule(p)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not tuple) can be annotated" );
19698 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
19699 : 1 : p->error_indicator = 1;
19700 : 1 : p->level--;
19701 : 1 : return NULL;
19702 : : }
19703 : 0 : goto done;
19704 : : }
19705 : 893 : 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 [ + + ]: 893 : if (p->error_indicator) {
19711 : 96 : p->level--;
19712 : 96 : 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 [ + + ]: 797 : if (
19719 : 797 : (a = expression_rule(p)) // expression
19720 [ + + ]: 155 : &&
19721 : 155 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
19722 [ + + ]: 3 : &&
19723 : 3 : (expression_var = expression_rule(p)) // expression
19724 : : )
19725 : : {
19726 : : D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
19727 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "illegal target for annotation" );
19728 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
19729 : 1 : p->error_indicator = 1;
19730 : 1 : p->level--;
19731 : 1 : return NULL;
19732 : : }
19733 : 0 : goto done;
19734 : : }
19735 : 796 : 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 [ - + ]: 796 : if (p->error_indicator) {
19741 : 0 : p->level--;
19742 : 0 : 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 [ + - ]: 796 : if (
19749 : 796 : (_loop0_153_var = _loop0_153_rule(p)) // ((star_targets '='))*
19750 [ + + ]: 796 : &&
19751 : 796 : (a = star_expressions_rule(p)) // star_expressions
19752 [ + + ]: 151 : &&
19753 : 151 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
19754 : : )
19755 : : {
19756 : : D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='"));
19757 : 22 : _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a );
19758 [ + - + - ]: 22 : if (_res == NULL && PyErr_Occurred()) {
19759 : 22 : p->error_indicator = 1;
19760 : 22 : p->level--;
19761 : 22 : return NULL;
19762 : : }
19763 : 0 : goto done;
19764 : : }
19765 : 774 : 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 [ - + ]: 774 : if (p->error_indicator) {
19771 : 0 : p->level--;
19772 : 0 : 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 [ + - ]: 774 : if (
19779 : 774 : (_loop0_154_var = _loop0_154_rule(p)) // ((star_targets '='))*
19780 [ + + ]: 774 : &&
19781 : 774 : (a = yield_expr_rule(p)) // yield_expr
19782 [ + + ]: 5 : &&
19783 : 5 : (_literal = _PyPegen_expect_token(p, 22)) // 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 : 3 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "assignment to yield expression not possible" );
19788 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
19789 : 3 : p->error_indicator = 1;
19790 : 3 : p->level--;
19791 : 3 : return NULL;
19792 : : }
19793 : 0 : goto done;
19794 : : }
19795 : 771 : 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 [ - + ]: 771 : if (p->error_indicator) {
19801 : 0 : p->level--;
19802 : 0 : 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 [ + + ]: 771 : if (
19809 : 771 : (a = star_expressions_rule(p)) // star_expressions
19810 [ + + ]: 131 : &&
19811 : 131 : (augassign_var = augassign_rule(p)) // augassign
19812 [ + - ]: 14 : &&
19813 : 14 : (_tmp_155_var = _tmp_155_rule(p)) // 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 : 14 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "'%s' is an illegal expression for augmented assignment" , _PyPegen_get_expr_name ( a ) );
19818 [ + - + - ]: 14 : if (_res == NULL && PyErr_Occurred()) {
19819 : 14 : p->error_indicator = 1;
19820 : 14 : p->level--;
19821 : 14 : return NULL;
19822 : : }
19823 : 0 : goto done;
19824 : : }
19825 : 757 : 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 : 757 : _res = NULL;
19830 : 757 : done:
19831 : 757 : p->level--;
19832 : 757 : return _res;
19833 : : }
19834 : :
19835 : : // invalid_ann_assign_target: list | tuple | '(' invalid_ann_assign_target ')'
19836 : : static expr_ty
19837 : 913 : invalid_ann_assign_target_rule(Parser *p)
19838 : : {
19839 [ - + ]: 913 : if (p->level++ == MAXSTACK) {
19840 : 0 : p->error_indicator = 1;
19841 : : PyErr_NoMemory();
19842 : : }
19843 [ - + ]: 913 : if (p->error_indicator) {
19844 : 0 : p->level--;
19845 : 0 : return NULL;
19846 : : }
19847 : 913 : expr_ty _res = NULL;
19848 : 913 : int _mark = p->mark;
19849 : : { // list
19850 [ - + ]: 913 : if (p->error_indicator) {
19851 : 0 : p->level--;
19852 : 0 : 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 [ + + ]: 913 : if (
19857 : 913 : (list_var = list_rule(p)) // list
19858 : : )
19859 : : {
19860 : : D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
19861 : 7 : _res = list_var;
19862 : 7 : goto done;
19863 : : }
19864 : 906 : 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 [ - + ]: 906 : if (p->error_indicator) {
19870 : 0 : p->level--;
19871 : 0 : 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 [ + + ]: 906 : if (
19876 : 906 : (tuple_var = tuple_rule(p)) // tuple
19877 : : )
19878 : : {
19879 : : D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
19880 : 10 : _res = tuple_var;
19881 : 10 : goto done;
19882 : : }
19883 : 896 : 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 [ - + ]: 896 : if (p->error_indicator) {
19889 : 0 : p->level--;
19890 : 0 : 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 [ + + ]: 896 : if (
19897 : 896 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
19898 [ + + ]: 12 : &&
19899 : 12 : (a = invalid_ann_assign_target_rule(p)) // invalid_ann_assign_target
19900 [ + - ]: 2 : &&
19901 : 2 : (_literal_1 = _PyPegen_expect_token(p, 8)) // 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 : 2 : _res = a;
19906 [ - + - - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
19907 : 0 : p->error_indicator = 1;
19908 : 0 : p->level--;
19909 : 0 : return NULL;
19910 : : }
19911 : 2 : goto done;
19912 : : }
19913 : 894 : 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 : 894 : _res = NULL;
19918 : 913 : done:
19919 : 913 : p->level--;
19920 : 913 : return _res;
19921 : : }
19922 : :
19923 : : // invalid_del_stmt: 'del' star_expressions
19924 : : static void *
19925 : 37 : invalid_del_stmt_rule(Parser *p)
19926 : : {
19927 [ - + ]: 37 : if (p->level++ == MAXSTACK) {
19928 : 0 : p->error_indicator = 1;
19929 : : PyErr_NoMemory();
19930 : : }
19931 [ - + ]: 37 : if (p->error_indicator) {
19932 : 0 : p->level--;
19933 : 0 : return NULL;
19934 : : }
19935 : 37 : void * _res = NULL;
19936 : 37 : int _mark = p->mark;
19937 : : { // 'del' star_expressions
19938 [ - + ]: 37 : if (p->error_indicator) {
19939 : 0 : p->level--;
19940 : 0 : 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 [ + - ]: 37 : if (
19946 : 37 : (_keyword = _PyPegen_expect_token(p, 603)) // token='del'
19947 [ + + ]: 37 : &&
19948 : 37 : (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 : 35 : _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( DEL_TARGETS , a );
19953 [ + - + + ]: 35 : if (_res == NULL && PyErr_Occurred()) {
19954 : 29 : p->error_indicator = 1;
19955 : 29 : p->level--;
19956 : 29 : return NULL;
19957 : : }
19958 : 6 : goto done;
19959 : : }
19960 : 2 : 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 : 2 : _res = NULL;
19965 : 8 : done:
19966 : 8 : p->level--;
19967 : 8 : return _res;
19968 : : }
19969 : :
19970 : : // invalid_block: NEWLINE !INDENT
19971 : : static void *
19972 : 136 : invalid_block_rule(Parser *p)
19973 : : {
19974 [ - + ]: 136 : if (p->level++ == MAXSTACK) {
19975 : 0 : p->error_indicator = 1;
19976 : : PyErr_NoMemory();
19977 : : }
19978 [ - + ]: 136 : if (p->error_indicator) {
19979 : 0 : p->level--;
19980 : 0 : return NULL;
19981 : : }
19982 : 136 : void * _res = NULL;
19983 : 136 : int _mark = p->mark;
19984 : : { // NEWLINE !INDENT
19985 [ - + ]: 136 : if (p->error_indicator) {
19986 : 0 : p->level--;
19987 : 0 : 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 [ + + ]: 136 : if (
19992 : 136 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
19993 [ + + ]: 50 : &&
19994 : 50 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
19995 : : )
19996 : : {
19997 : : D(fprintf(stderr, "%*c+ invalid_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT"));
19998 : 4 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block" );
19999 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
20000 : 4 : p->error_indicator = 1;
20001 : 4 : p->level--;
20002 : 4 : return NULL;
20003 : : }
20004 : 0 : goto done;
20005 : : }
20006 : 132 : 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 : 132 : _res = NULL;
20011 : 132 : done:
20012 : 132 : p->level--;
20013 : 132 : 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 : 2906 : invalid_comprehension_rule(Parser *p)
20022 : : {
20023 [ - + ]: 2906 : if (p->level++ == MAXSTACK) {
20024 : 0 : p->error_indicator = 1;
20025 : : PyErr_NoMemory();
20026 : : }
20027 [ - + ]: 2906 : if (p->error_indicator) {
20028 : 0 : p->level--;
20029 : 0 : return NULL;
20030 : : }
20031 : 2906 : void * _res = NULL;
20032 : 2906 : int _mark = p->mark;
20033 : : { // ('[' | '(' | '{') starred_expression for_if_clauses
20034 [ - + ]: 2906 : if (p->error_indicator) {
20035 : 0 : p->level--;
20036 : 0 : 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 [ + + ]: 2906 : if (
20043 : 2906 : (_tmp_156_var = _tmp_156_rule(p)) // '[' | '(' | '{'
20044 [ + + ]: 422 : &&
20045 : 422 : (a = starred_expression_rule(p)) // starred_expression
20046 [ + + ]: 19 : &&
20047 : 19 : (for_if_clauses_var = for_if_clauses_rule(p)) // 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 : 5 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable unpacking cannot be used in comprehension" );
20052 [ + - + - ]: 5 : if (_res == NULL && PyErr_Occurred()) {
20053 : 5 : p->error_indicator = 1;
20054 : 5 : p->level--;
20055 : 5 : return NULL;
20056 : : }
20057 : 0 : goto done;
20058 : : }
20059 : 2901 : 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 [ + + ]: 2901 : if (p->error_indicator) {
20065 : 1 : p->level--;
20066 : 1 : 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 [ + + ]: 2900 : if (
20075 : 2900 : (_tmp_157_var = _tmp_157_rule(p)) // '[' | '{'
20076 [ + + ]: 145 : &&
20077 : 145 : (a = star_named_expression_rule(p)) // star_named_expression
20078 [ + + ]: 61 : &&
20079 : 61 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
20080 [ + - ]: 5 : &&
20081 : 5 : (b = star_named_expressions_rule(p)) // star_named_expressions
20082 [ + + ]: 5 : &&
20083 : 5 : (for_if_clauses_var = for_if_clauses_rule(p)) // 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 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , PyPegen_last_item ( b , expr_ty ) , "did you forget parentheses around the comprehension target?" );
20088 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
20089 : 4 : p->error_indicator = 1;
20090 : 4 : p->level--;
20091 : 4 : return NULL;
20092 : : }
20093 : 0 : goto done;
20094 : : }
20095 : 2896 : 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 [ - + ]: 2896 : if (p->error_indicator) {
20101 : 0 : p->level--;
20102 : 0 : 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 [ + + ]: 2896 : if (
20110 : 2896 : (_tmp_158_var = _tmp_158_rule(p)) // '[' | '{'
20111 [ + + ]: 141 : &&
20112 : 141 : (a = star_named_expression_rule(p)) // star_named_expression
20113 [ + + ]: 57 : &&
20114 : 57 : (b = _PyPegen_expect_token(p, 12)) // token=','
20115 [ - + ]: 1 : &&
20116 : 1 : (for_if_clauses_var = for_if_clauses_rule(p)) // 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 : 0 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "did you forget parentheses around the comprehension target?" );
20121 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
20122 : 0 : p->error_indicator = 1;
20123 : 0 : p->level--;
20124 : 0 : return NULL;
20125 : : }
20126 : 0 : goto done;
20127 : : }
20128 : 2896 : 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 : 2896 : _res = NULL;
20133 : 2896 : done:
20134 : 2896 : p->level--;
20135 : 2896 : return _res;
20136 : : }
20137 : :
20138 : : // invalid_dict_comprehension: '{' '**' bitwise_or for_if_clauses '}'
20139 : : static void *
20140 : 37 : invalid_dict_comprehension_rule(Parser *p)
20141 : : {
20142 [ - + ]: 37 : if (p->level++ == MAXSTACK) {
20143 : 0 : p->error_indicator = 1;
20144 : : PyErr_NoMemory();
20145 : : }
20146 [ - + ]: 37 : if (p->error_indicator) {
20147 : 0 : p->level--;
20148 : 0 : return NULL;
20149 : : }
20150 : 37 : void * _res = NULL;
20151 : 37 : int _mark = p->mark;
20152 : : { // '{' '**' bitwise_or for_if_clauses '}'
20153 [ - + ]: 37 : if (p->error_indicator) {
20154 : 0 : p->level--;
20155 : 0 : 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 [ + - ]: 37 : if (
20164 : 37 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
20165 [ + + ]: 37 : &&
20166 : 37 : (a = _PyPegen_expect_token(p, 35)) // token='**'
20167 [ + - ]: 1 : &&
20168 : 1 : (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
20169 [ + - ]: 1 : &&
20170 : 1 : (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
20171 [ + - ]: 1 : &&
20172 : 1 : (_literal_1 = _PyPegen_expect_token(p, 26)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "dict unpacking cannot be used in dict comprehension" );
20177 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
20178 : 1 : p->error_indicator = 1;
20179 : 1 : p->level--;
20180 : 1 : return NULL;
20181 : : }
20182 : 0 : goto done;
20183 : : }
20184 : 36 : 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 : 36 : _res = NULL;
20189 : 36 : done:
20190 : 36 : p->level--;
20191 : 36 : 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 : 302 : invalid_parameters_rule(Parser *p)
20203 : : {
20204 [ - + ]: 302 : if (p->level++ == MAXSTACK) {
20205 : 0 : p->error_indicator = 1;
20206 : : PyErr_NoMemory();
20207 : : }
20208 [ - + ]: 302 : if (p->error_indicator) {
20209 : 0 : p->level--;
20210 : 0 : return NULL;
20211 : : }
20212 : 302 : void * _res = NULL;
20213 : 302 : int _mark = p->mark;
20214 : : { // param_no_default* invalid_parameters_helper param_no_default
20215 [ - + ]: 302 : if (p->error_indicator) {
20216 : 0 : p->level--;
20217 : 0 : 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 [ + - ]: 302 : if (
20224 : 302 : (_loop0_159_var = _loop0_159_rule(p)) // param_no_default*
20225 [ + + ]: 302 : &&
20226 : 302 : (invalid_parameters_helper_var = invalid_parameters_helper_rule(p)) // invalid_parameters_helper
20227 [ + + ]: 14 : &&
20228 : 14 : (a = param_no_default_rule(p)) // 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 : 10 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "non-default argument follows default argument" );
20233 [ + - + - ]: 10 : if (_res == NULL && PyErr_Occurred()) {
20234 : 10 : p->error_indicator = 1;
20235 : 10 : p->level--;
20236 : 10 : return NULL;
20237 : : }
20238 : 0 : goto done;
20239 : : }
20240 : 292 : 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 [ + + ]: 292 : if (p->error_indicator) {
20246 : 8 : p->level--;
20247 : 8 : 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 [ + - ]: 284 : if (
20257 : 284 : (_loop0_160_var = _loop0_160_rule(p)) // param_no_default*
20258 [ + + ]: 284 : &&
20259 : 284 : (a = _PyPegen_expect_token(p, 7)) // token='('
20260 [ + - ]: 4 : &&
20261 : 4 : (_loop1_161_var = _loop1_161_rule(p)) // param_no_default+
20262 : 4 : &&
20263 [ + - ]: 4 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
20264 [ + - ]: 4 : &&
20265 : 4 : (b = _PyPegen_expect_token(p, 8)) // 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 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Function parameters cannot be parenthesized" );
20270 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
20271 : 4 : p->error_indicator = 1;
20272 : 4 : p->level--;
20273 : 4 : return NULL;
20274 : : }
20275 : 0 : goto done;
20276 : : }
20277 : 280 : 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 [ - + ]: 280 : if (p->error_indicator) {
20283 : 0 : p->level--;
20284 : 0 : 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 [ + + ]: 280 : if (
20290 : 280 : (a = _PyPegen_expect_token(p, 17)) // token='/'
20291 [ + + ]: 9 : &&
20292 : 9 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
20293 : : )
20294 : : {
20295 : : D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"/\" ','"));
20296 : 5 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "at least one argument must precede /" );
20297 [ + - + - ]: 5 : if (_res == NULL && PyErr_Occurred()) {
20298 : 5 : p->error_indicator = 1;
20299 : 5 : p->level--;
20300 : 5 : return NULL;
20301 : : }
20302 : 0 : goto done;
20303 : : }
20304 : 275 : 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 [ - + ]: 275 : if (p->error_indicator) {
20310 : 0 : p->level--;
20311 : 0 : 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 [ + + ]: 275 : if (
20318 : 275 : (_tmp_162_var = _tmp_162_rule(p)) // slash_no_default | slash_with_default
20319 [ + - ]: 14 : &&
20320 : 14 : (_loop0_163_var = _loop0_163_rule(p)) // param_maybe_default*
20321 [ + + ]: 14 : &&
20322 : 14 : (a = _PyPegen_expect_token(p, 17)) // 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 : 10 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ may appear only once" );
20327 [ + - + - ]: 10 : if (_res == NULL && PyErr_Occurred()) {
20328 : 10 : p->error_indicator = 1;
20329 : 10 : p->level--;
20330 : 10 : return NULL;
20331 : : }
20332 : 0 : goto done;
20333 : : }
20334 : 265 : 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 [ - + ]: 265 : if (p->error_indicator) {
20340 : 0 : p->level--;
20341 : 0 : 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 : 265 : if (
20352 [ + - ]: 265 : (_opt_var = _tmp_164_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)]
20353 [ + - ]: 265 : &&
20354 : 265 : (_loop0_165_var = _loop0_165_rule(p)) // param_maybe_default*
20355 [ + + ]: 265 : &&
20356 : 265 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
20357 [ + + ]: 41 : &&
20358 : 41 : (_tmp_166_var = _tmp_166_rule(p)) // ',' | param_no_default
20359 [ + - ]: 33 : &&
20360 : 33 : (_loop0_167_var = _loop0_167_rule(p)) // param_maybe_default*
20361 [ + + ]: 33 : &&
20362 : 33 : (a = _PyPegen_expect_token(p, 17)) // token='/'
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 : 12 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ must be ahead of *" );
20367 [ + - + - ]: 12 : if (_res == NULL && PyErr_Occurred()) {
20368 : 12 : p->error_indicator = 1;
20369 : 12 : p->level--;
20370 : 12 : return NULL;
20371 : : }
20372 : 0 : goto done;
20373 : : }
20374 : 253 : 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 [ - + ]: 253 : if (p->error_indicator) {
20380 : 0 : p->level--;
20381 : 0 : 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 [ + + ]: 253 : if (
20388 : 253 : (_loop1_168_var = _loop1_168_rule(p)) // param_maybe_default+
20389 [ + + ]: 42 : &&
20390 : 42 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
20391 [ + + ]: 5 : &&
20392 : 5 : (a = _PyPegen_expect_token(p, 16)) // token='*'
20393 : : )
20394 : : {
20395 : : D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_maybe_default+ '/' '*'"));
20396 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected comma between / and *" );
20397 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
20398 : 1 : p->error_indicator = 1;
20399 : 1 : p->level--;
20400 : 1 : return NULL;
20401 : : }
20402 : 0 : goto done;
20403 : : }
20404 : 252 : 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 : 252 : _res = NULL;
20409 : 252 : done:
20410 : 252 : p->level--;
20411 : 252 : return _res;
20412 : : }
20413 : :
20414 : : // invalid_default: '=' &(')' | ',')
20415 : : static void *
20416 : 1775 : invalid_default_rule(Parser *p)
20417 : : {
20418 [ - + ]: 1775 : if (p->level++ == MAXSTACK) {
20419 : 0 : p->error_indicator = 1;
20420 : : PyErr_NoMemory();
20421 : : }
20422 [ - + ]: 1775 : if (p->error_indicator) {
20423 : 0 : p->level--;
20424 : 0 : return NULL;
20425 : : }
20426 : 1775 : void * _res = NULL;
20427 : 1775 : int _mark = p->mark;
20428 : : { // '=' &(')' | ',')
20429 [ - + ]: 1775 : if (p->error_indicator) {
20430 : 0 : p->level--;
20431 : 0 : return NULL;
20432 : : }
20433 : : D(fprintf(stderr, "%*c> invalid_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')"));
20434 : : Token * a;
20435 [ + + ]: 1775 : if (
20436 : 1775 : (a = _PyPegen_expect_token(p, 22)) // token='='
20437 [ + + ]: 245 : &&
20438 : 245 : _PyPegen_lookahead(1, _tmp_169_rule, p)
20439 : : )
20440 : : {
20441 : : D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')"));
20442 : 5 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected default value expression" );
20443 [ + - + - ]: 5 : if (_res == NULL && PyErr_Occurred()) {
20444 : 5 : p->error_indicator = 1;
20445 : 5 : p->level--;
20446 : 5 : return NULL;
20447 : : }
20448 : 0 : goto done;
20449 : : }
20450 : 1770 : 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 : 1770 : _res = NULL;
20455 : 1770 : done:
20456 : 1770 : p->level--;
20457 : 1770 : 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 : 252 : invalid_star_etc_rule(Parser *p)
20467 : : {
20468 [ - + ]: 252 : if (p->level++ == MAXSTACK) {
20469 : 0 : p->error_indicator = 1;
20470 : : PyErr_NoMemory();
20471 : : }
20472 [ - + ]: 252 : if (p->error_indicator) {
20473 : 0 : p->level--;
20474 : 0 : return NULL;
20475 : : }
20476 : 252 : void * _res = NULL;
20477 : 252 : int _mark = p->mark;
20478 : : { // '*' (')' | ',' (')' | '**'))
20479 [ - + ]: 252 : if (p->error_indicator) {
20480 : 0 : p->level--;
20481 : 0 : 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 [ + + ]: 252 : if (
20487 : 252 : (a = _PyPegen_expect_token(p, 16)) // token='*'
20488 [ + + ]: 29 : &&
20489 : 29 : (_tmp_170_var = _tmp_170_rule(p)) // ')' | ',' (')' | '**')
20490 : : )
20491 : : {
20492 : : D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));
20493 : 3 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "named arguments must follow bare *" );
20494 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
20495 : 3 : p->error_indicator = 1;
20496 : 3 : p->level--;
20497 : 3 : return NULL;
20498 : : }
20499 : 0 : goto done;
20500 : : }
20501 : 249 : 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 [ - + ]: 249 : if (p->error_indicator) {
20507 : 0 : p->level--;
20508 : 0 : 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 [ + + ]: 249 : if (
20515 : 249 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
20516 [ + + ]: 26 : &&
20517 : 26 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
20518 [ + + ]: 8 : &&
20519 : 8 : (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR ( "bare * has associated type comment" );
20524 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
20525 : 1 : p->error_indicator = 1;
20526 : 1 : p->level--;
20527 : 1 : return NULL;
20528 : : }
20529 : 0 : goto done;
20530 : : }
20531 : 248 : 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 [ - + ]: 248 : if (p->error_indicator) {
20537 : 0 : p->level--;
20538 : 0 : 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 [ + + ]: 248 : if (
20545 : 248 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
20546 [ + + ]: 25 : &&
20547 : 25 : (param_var = param_rule(p)) // param
20548 [ + + ]: 16 : &&
20549 : 16 : (a = _PyPegen_expect_token(p, 22)) // token='='
20550 : : )
20551 : : {
20552 : : D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param '='"));
20553 : 2 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-positional argument cannot have default value" );
20554 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
20555 : 2 : p->error_indicator = 1;
20556 : 2 : p->level--;
20557 : 2 : return NULL;
20558 : : }
20559 : 0 : goto done;
20560 : : }
20561 : 246 : 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 [ - + ]: 246 : if (p->error_indicator) {
20567 : 0 : p->level--;
20568 : 0 : 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 [ + + ]: 246 : if (
20577 : 246 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
20578 [ + + ]: 23 : &&
20579 : 23 : (_tmp_171_var = _tmp_171_rule(p)) // param_no_default | ','
20580 [ + - ]: 19 : &&
20581 : 19 : (_loop0_172_var = _loop0_172_rule(p)) // param_maybe_default*
20582 [ + + ]: 19 : &&
20583 : 19 : (a = _PyPegen_expect_token(p, 16)) // token='*'
20584 [ + - ]: 4 : &&
20585 : 4 : (_tmp_173_var = _tmp_173_rule(p)) // 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 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "* argument may appear only once" );
20590 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
20591 : 4 : p->error_indicator = 1;
20592 : 4 : p->level--;
20593 : 4 : return NULL;
20594 : : }
20595 : 0 : goto done;
20596 : : }
20597 : 242 : 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 : 242 : _res = NULL;
20602 : 242 : done:
20603 : 242 : p->level--;
20604 : 242 : return _res;
20605 : : }
20606 : :
20607 : : // invalid_kwds: '**' param '=' | '**' param ',' param | '**' param ',' ('*' | '**' | '/')
20608 : : static void *
20609 : 242 : invalid_kwds_rule(Parser *p)
20610 : : {
20611 [ - + ]: 242 : if (p->level++ == MAXSTACK) {
20612 : 0 : p->error_indicator = 1;
20613 : : PyErr_NoMemory();
20614 : : }
20615 [ - + ]: 242 : if (p->error_indicator) {
20616 : 0 : p->level--;
20617 : 0 : return NULL;
20618 : : }
20619 : 242 : void * _res = NULL;
20620 : 242 : int _mark = p->mark;
20621 : : { // '**' param '='
20622 [ - + ]: 242 : if (p->error_indicator) {
20623 : 0 : p->level--;
20624 : 0 : 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 [ + + ]: 242 : if (
20631 : 242 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
20632 [ + + ]: 17 : &&
20633 : 17 : (param_var = param_rule(p)) // param
20634 [ + + ]: 15 : &&
20635 : 15 : (a = _PyPegen_expect_token(p, 22)) // token='='
20636 : : )
20637 : : {
20638 : : D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param '='"));
20639 : 2 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-keyword argument cannot have default value" );
20640 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
20641 : 2 : p->error_indicator = 1;
20642 : 2 : p->level--;
20643 : 2 : return NULL;
20644 : : }
20645 : 0 : goto done;
20646 : : }
20647 : 240 : 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 [ - + ]: 240 : if (p->error_indicator) {
20653 : 0 : p->level--;
20654 : 0 : 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 [ + + ]: 240 : if (
20662 : 240 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
20663 [ + + ]: 15 : &&
20664 : 15 : (param_var = param_rule(p)) // param
20665 [ + + ]: 13 : &&
20666 : 13 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
20667 [ + + ]: 7 : &&
20668 : 7 : (a = param_rule(p)) // param
20669 : : )
20670 : : {
20671 : : D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' param"));
20672 : 2 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" );
20673 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
20674 : 2 : p->error_indicator = 1;
20675 : 2 : p->level--;
20676 : 2 : return NULL;
20677 : : }
20678 : 0 : goto done;
20679 : : }
20680 : 238 : 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 [ - + ]: 238 : if (p->error_indicator) {
20686 : 0 : p->level--;
20687 : 0 : 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 [ + + ]: 238 : if (
20695 : 238 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
20696 [ + + ]: 13 : &&
20697 : 13 : (param_var = param_rule(p)) // param
20698 [ + + ]: 11 : &&
20699 : 11 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
20700 [ + - ]: 5 : &&
20701 : 5 : (a = (Token*)_tmp_174_rule(p)) // '*' | '**' | '/'
20702 : : )
20703 : : {
20704 : : D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')"));
20705 : 5 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" );
20706 [ + - + - ]: 5 : if (_res == NULL && PyErr_Occurred()) {
20707 : 5 : p->error_indicator = 1;
20708 : 5 : p->level--;
20709 : 5 : return NULL;
20710 : : }
20711 : 0 : goto done;
20712 : : }
20713 : 233 : 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 : 233 : _res = NULL;
20718 : 233 : done:
20719 : 233 : p->level--;
20720 : 233 : return _res;
20721 : : }
20722 : :
20723 : : // invalid_parameters_helper: slash_with_default | param_with_default+
20724 : : static void *
20725 : 302 : invalid_parameters_helper_rule(Parser *p)
20726 : : {
20727 [ - + ]: 302 : if (p->level++ == MAXSTACK) {
20728 : 0 : p->error_indicator = 1;
20729 : : PyErr_NoMemory();
20730 : : }
20731 [ + + ]: 302 : if (p->error_indicator) {
20732 : 5 : p->level--;
20733 : 5 : return NULL;
20734 : : }
20735 : 297 : void * _res = NULL;
20736 : 297 : int _mark = p->mark;
20737 : : { // slash_with_default
20738 [ - + ]: 297 : if (p->error_indicator) {
20739 : 0 : p->level--;
20740 : 0 : 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 [ + + ]: 297 : if (
20745 : 297 : (a = slash_with_default_rule(p)) // slash_with_default
20746 : : )
20747 : : {
20748 : : D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
20749 : 6 : _res = _PyPegen_singleton_seq ( p , a );
20750 [ - + - - ]: 6 : if (_res == NULL && PyErr_Occurred()) {
20751 : 0 : p->error_indicator = 1;
20752 : 0 : p->level--;
20753 : 0 : return NULL;
20754 : : }
20755 : 6 : goto done;
20756 : : }
20757 : 291 : 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 [ + + ]: 291 : if (p->error_indicator) {
20763 : 3 : p->level--;
20764 : 3 : 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 [ + + ]: 288 : if (
20769 : 288 : (_loop1_175_var = _loop1_175_rule(p)) // param_with_default+
20770 : : )
20771 : : {
20772 : : D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+"));
20773 : 8 : _res = _loop1_175_var;
20774 : 8 : goto done;
20775 : : }
20776 : 280 : 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 : 280 : _res = NULL;
20781 : 294 : done:
20782 : 294 : p->level--;
20783 : 294 : 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 : 52 : invalid_lambda_parameters_rule(Parser *p)
20795 : : {
20796 [ - + ]: 52 : if (p->level++ == MAXSTACK) {
20797 : 0 : p->error_indicator = 1;
20798 : : PyErr_NoMemory();
20799 : : }
20800 [ - + ]: 52 : if (p->error_indicator) {
20801 : 0 : p->level--;
20802 : 0 : return NULL;
20803 : : }
20804 : 52 : void * _res = NULL;
20805 : 52 : int _mark = p->mark;
20806 : : { // lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default
20807 [ - + ]: 52 : if (p->error_indicator) {
20808 : 0 : p->level--;
20809 : 0 : 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 [ + - ]: 52 : if (
20816 : 52 : (_loop0_176_var = _loop0_176_rule(p)) // lambda_param_no_default*
20817 [ + + ]: 52 : &&
20818 : 52 : (invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lambda_parameters_helper
20819 [ + + ]: 7 : &&
20820 : 7 : (a = lambda_param_no_default_rule(p)) // 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 : 3 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "non-default argument follows default argument" );
20825 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
20826 : 3 : p->error_indicator = 1;
20827 : 3 : p->level--;
20828 : 3 : return NULL;
20829 : : }
20830 : 0 : goto done;
20831 : : }
20832 : 49 : 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 [ + + ]: 49 : if (p->error_indicator) {
20838 : 2 : p->level--;
20839 : 2 : 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 [ + - ]: 47 : if (
20849 : 47 : (_loop0_177_var = _loop0_177_rule(p)) // lambda_param_no_default*
20850 [ + + ]: 47 : &&
20851 : 47 : (a = _PyPegen_expect_token(p, 7)) // token='('
20852 [ + + ]: 5 : &&
20853 : 5 : (_gather_178_var = _gather_178_rule(p)) // ','.lambda_param+
20854 : 4 : &&
20855 [ + - ]: 4 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
20856 [ + - ]: 4 : &&
20857 : 4 : (b = _PyPegen_expect_token(p, 8)) // 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 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Lambda expression parameters cannot be parenthesized" );
20862 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
20863 : 4 : p->error_indicator = 1;
20864 : 4 : p->level--;
20865 : 4 : return NULL;
20866 : : }
20867 : 0 : goto done;
20868 : : }
20869 : 43 : 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 [ - + ]: 43 : if (p->error_indicator) {
20875 : 0 : p->level--;
20876 : 0 : 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 [ + + ]: 43 : if (
20882 : 43 : (a = _PyPegen_expect_token(p, 17)) // token='/'
20883 [ + + ]: 4 : &&
20884 : 4 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
20885 : : )
20886 : : {
20887 : : D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"/\" ','"));
20888 : 3 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "at least one argument must precede /" );
20889 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
20890 : 3 : p->error_indicator = 1;
20891 : 3 : p->level--;
20892 : 3 : return NULL;
20893 : : }
20894 : 0 : goto done;
20895 : : }
20896 : 40 : 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 [ - + ]: 40 : if (p->error_indicator) {
20902 : 0 : p->level--;
20903 : 0 : 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 [ + + ]: 40 : if (
20910 : 40 : (_tmp_180_var = _tmp_180_rule(p)) // lambda_slash_no_default | lambda_slash_with_default
20911 [ + - ]: 10 : &&
20912 : 10 : (_loop0_181_var = _loop0_181_rule(p)) // lambda_param_maybe_default*
20913 [ + + ]: 10 : &&
20914 : 10 : (a = _PyPegen_expect_token(p, 17)) // 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 : 7 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ may appear only once" );
20919 [ + - + - ]: 7 : if (_res == NULL && PyErr_Occurred()) {
20920 : 7 : p->error_indicator = 1;
20921 : 7 : p->level--;
20922 : 7 : return NULL;
20923 : : }
20924 : 0 : goto done;
20925 : : }
20926 : 33 : 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 [ - + ]: 33 : if (p->error_indicator) {
20932 : 0 : p->level--;
20933 : 0 : 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 : 33 : if (
20944 [ + - ]: 33 : (_opt_var = _tmp_182_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)]
20945 [ + - ]: 33 : &&
20946 : 33 : (_loop0_183_var = _loop0_183_rule(p)) // lambda_param_maybe_default*
20947 [ + + ]: 33 : &&
20948 : 33 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
20949 [ + + ]: 17 : &&
20950 : 17 : (_tmp_184_var = _tmp_184_rule(p)) // ',' | lambda_param_no_default
20951 [ + - ]: 15 : &&
20952 : 15 : (_loop0_185_var = _loop0_185_rule(p)) // lambda_param_maybe_default*
20953 [ + + ]: 15 : &&
20954 : 15 : (a = _PyPegen_expect_token(p, 17)) // 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 : 7 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ must be ahead of *" );
20959 [ + - + - ]: 7 : if (_res == NULL && PyErr_Occurred()) {
20960 : 7 : p->error_indicator = 1;
20961 : 7 : p->level--;
20962 : 7 : return NULL;
20963 : : }
20964 : 0 : goto done;
20965 : : }
20966 : 26 : 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 [ - + ]: 26 : if (p->error_indicator) {
20972 : 0 : p->level--;
20973 : 0 : 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 [ + + ]: 26 : if (
20980 : 26 : (_loop1_186_var = _loop1_186_rule(p)) // lambda_param_maybe_default+
20981 [ + + ]: 16 : &&
20982 : 16 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
20983 [ + + ]: 4 : &&
20984 : 4 : (a = _PyPegen_expect_token(p, 16)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected comma between / and *" );
20989 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
20990 : 1 : p->error_indicator = 1;
20991 : 1 : p->level--;
20992 : 1 : return NULL;
20993 : : }
20994 : 0 : goto done;
20995 : : }
20996 : 25 : 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 : 25 : _res = NULL;
21001 : 25 : done:
21002 : 25 : p->level--;
21003 : 25 : return _res;
21004 : : }
21005 : :
21006 : : // invalid_lambda_parameters_helper:
21007 : : // | lambda_slash_with_default
21008 : : // | lambda_param_with_default+
21009 : : static void *
21010 : 52 : invalid_lambda_parameters_helper_rule(Parser *p)
21011 : : {
21012 [ - + ]: 52 : if (p->level++ == MAXSTACK) {
21013 : 0 : p->error_indicator = 1;
21014 : : PyErr_NoMemory();
21015 : : }
21016 [ - + ]: 52 : if (p->error_indicator) {
21017 : 0 : p->level--;
21018 : 0 : return NULL;
21019 : : }
21020 : 52 : void * _res = NULL;
21021 : 52 : int _mark = p->mark;
21022 : : { // lambda_slash_with_default
21023 [ - + ]: 52 : if (p->error_indicator) {
21024 : 0 : p->level--;
21025 : 0 : 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 [ + + ]: 52 : if (
21030 : 52 : (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 : 3 : _res = _PyPegen_singleton_seq ( p , a );
21035 [ - + - - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
21036 : 0 : p->error_indicator = 1;
21037 : 0 : p->level--;
21038 : 0 : return NULL;
21039 : : }
21040 : 3 : goto done;
21041 : : }
21042 : 49 : 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 [ + + ]: 49 : if (p->error_indicator) {
21048 : 2 : p->level--;
21049 : 2 : 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 [ + + ]: 47 : if (
21054 : 47 : (_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 : 4 : _res = _loop1_187_var;
21059 : 4 : goto done;
21060 : : }
21061 : 43 : 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 : 43 : _res = NULL;
21066 : 50 : done:
21067 : 50 : p->level--;
21068 : 50 : 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 : 25 : invalid_lambda_star_etc_rule(Parser *p)
21077 : : {
21078 [ - + ]: 25 : if (p->level++ == MAXSTACK) {
21079 : 0 : p->error_indicator = 1;
21080 : : PyErr_NoMemory();
21081 : : }
21082 [ - + ]: 25 : if (p->error_indicator) {
21083 : 0 : p->level--;
21084 : 0 : return NULL;
21085 : : }
21086 : 25 : void * _res = NULL;
21087 : 25 : int _mark = p->mark;
21088 : : { // '*' (':' | ',' (':' | '**'))
21089 [ - + ]: 25 : if (p->error_indicator) {
21090 : 0 : p->level--;
21091 : 0 : 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 [ + + ]: 25 : if (
21097 : 25 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
21098 [ + + ]: 10 : &&
21099 : 10 : (_tmp_188_var = _tmp_188_rule(p)) // ':' | ',' (':' | '**')
21100 : : )
21101 : : {
21102 : : D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));
21103 : 1 : _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" );
21104 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
21105 : 1 : p->error_indicator = 1;
21106 : 1 : p->level--;
21107 : 1 : return NULL;
21108 : : }
21109 : 0 : goto done;
21110 : : }
21111 : 24 : 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 [ - + ]: 24 : if (p->error_indicator) {
21117 : 0 : p->level--;
21118 : 0 : 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 [ + + ]: 24 : if (
21125 : 24 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
21126 [ + - ]: 9 : &&
21127 : 9 : (lambda_param_var = lambda_param_rule(p)) // lambda_param
21128 [ + + ]: 9 : &&
21129 : 9 : (a = _PyPegen_expect_token(p, 22)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-positional argument cannot have default value" );
21134 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
21135 : 1 : p->error_indicator = 1;
21136 : 1 : p->level--;
21137 : 1 : return NULL;
21138 : : }
21139 : 0 : goto done;
21140 : : }
21141 : 23 : 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 [ - + ]: 23 : if (p->error_indicator) {
21147 : 0 : p->level--;
21148 : 0 : 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 [ + + ]: 23 : if (
21157 : 23 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
21158 [ + - ]: 8 : &&
21159 : 8 : (_tmp_189_var = _tmp_189_rule(p)) // lambda_param_no_default | ','
21160 [ + - ]: 8 : &&
21161 : 8 : (_loop0_190_var = _loop0_190_rule(p)) // lambda_param_maybe_default*
21162 [ + + ]: 8 : &&
21163 : 8 : (a = _PyPegen_expect_token(p, 16)) // token='*'
21164 [ + - ]: 4 : &&
21165 : 4 : (_tmp_191_var = _tmp_191_rule(p)) // 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 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "* argument may appear only once" );
21170 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
21171 : 4 : p->error_indicator = 1;
21172 : 4 : p->level--;
21173 : 4 : return NULL;
21174 : : }
21175 : 0 : goto done;
21176 : : }
21177 : 19 : 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 : 19 : _res = NULL;
21182 : 19 : done:
21183 : 19 : p->level--;
21184 : 19 : return _res;
21185 : : }
21186 : :
21187 : : // invalid_lambda_kwds:
21188 : : // | '**' lambda_param '='
21189 : : // | '**' lambda_param ',' lambda_param
21190 : : // | '**' lambda_param ',' ('*' | '**' | '/')
21191 : : static void *
21192 : 19 : invalid_lambda_kwds_rule(Parser *p)
21193 : : {
21194 [ - + ]: 19 : if (p->level++ == MAXSTACK) {
21195 : 0 : p->error_indicator = 1;
21196 : : PyErr_NoMemory();
21197 : : }
21198 [ - + ]: 19 : if (p->error_indicator) {
21199 : 0 : p->level--;
21200 : 0 : return NULL;
21201 : : }
21202 : 19 : void * _res = NULL;
21203 : 19 : int _mark = p->mark;
21204 : : { // '**' lambda_param '='
21205 [ - + ]: 19 : if (p->error_indicator) {
21206 : 0 : p->level--;
21207 : 0 : 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 [ + + ]: 19 : if (
21214 : 19 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
21215 [ + - ]: 7 : &&
21216 : 7 : (lambda_param_var = lambda_param_rule(p)) // lambda_param
21217 [ + + ]: 7 : &&
21218 : 7 : (a = _PyPegen_expect_token(p, 22)) // token='='
21219 : : )
21220 : : {
21221 : : D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param '='"));
21222 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-keyword argument cannot have default value" );
21223 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
21224 : 1 : p->error_indicator = 1;
21225 : 1 : p->level--;
21226 : 1 : return NULL;
21227 : : }
21228 : 0 : goto done;
21229 : : }
21230 : 18 : 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 [ - + ]: 18 : if (p->error_indicator) {
21236 : 0 : p->level--;
21237 : 0 : 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 [ + + ]: 18 : if (
21245 : 18 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
21246 [ + - ]: 6 : &&
21247 : 6 : (lambda_param_var = lambda_param_rule(p)) // lambda_param
21248 [ + - ]: 6 : &&
21249 : 6 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
21250 [ + + ]: 6 : &&
21251 : 6 : (a = lambda_param_rule(p)) // 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 : 2 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" );
21256 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
21257 : 2 : p->error_indicator = 1;
21258 : 2 : p->level--;
21259 : 2 : return NULL;
21260 : : }
21261 : 0 : goto done;
21262 : : }
21263 : 16 : 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 [ - + ]: 16 : if (p->error_indicator) {
21269 : 0 : p->level--;
21270 : 0 : 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 [ + + ]: 16 : if (
21278 : 16 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
21279 [ + - ]: 4 : &&
21280 : 4 : (lambda_param_var = lambda_param_rule(p)) // lambda_param
21281 [ + - ]: 4 : &&
21282 : 4 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
21283 [ + - ]: 4 : &&
21284 : 4 : (a = (Token*)_tmp_192_rule(p)) // '*' | '**' | '/'
21285 : : )
21286 : : {
21287 : : D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')"));
21288 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" );
21289 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
21290 : 4 : p->error_indicator = 1;
21291 : 4 : p->level--;
21292 : 4 : return NULL;
21293 : : }
21294 : 0 : goto done;
21295 : : }
21296 : 12 : 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 : 12 : _res = NULL;
21301 : 12 : done:
21302 : 12 : p->level--;
21303 : 12 : return _res;
21304 : : }
21305 : :
21306 : : // invalid_double_type_comments: TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
21307 : : static void *
21308 : 63 : invalid_double_type_comments_rule(Parser *p)
21309 : : {
21310 [ - + ]: 63 : if (p->level++ == MAXSTACK) {
21311 : 0 : p->error_indicator = 1;
21312 : : PyErr_NoMemory();
21313 : : }
21314 [ - + ]: 63 : if (p->error_indicator) {
21315 : 0 : p->level--;
21316 : 0 : return NULL;
21317 : : }
21318 : 63 : void * _res = NULL;
21319 : 63 : int _mark = p->mark;
21320 : : { // TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
21321 [ - + ]: 63 : if (p->error_indicator) {
21322 : 0 : p->level--;
21323 : 0 : 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 [ + + ]: 63 : if (
21332 : 63 : (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
21333 [ + - ]: 9 : &&
21334 : 9 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
21335 [ + - ]: 9 : &&
21336 : 9 : (type_comment_var_1 = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
21337 [ + - ]: 9 : &&
21338 : 9 : (newline_var_1 = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
21339 [ + - ]: 9 : &&
21340 : 9 : (indent_var = _PyPegen_expect_token(p, INDENT)) // 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 : 9 : _res = RAISE_SYNTAX_ERROR ( "Cannot have two type comments on def" );
21345 [ + - + - ]: 9 : if (_res == NULL && PyErr_Occurred()) {
21346 : 9 : p->error_indicator = 1;
21347 : 9 : p->level--;
21348 : 9 : return NULL;
21349 : : }
21350 : 0 : goto done;
21351 : : }
21352 : 54 : 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 : 54 : _res = NULL;
21357 : 54 : done:
21358 : 54 : p->level--;
21359 : 54 : return _res;
21360 : : }
21361 : :
21362 : : // invalid_with_item: expression 'as' expression &(',' | ')' | ':')
21363 : : static void *
21364 : 28 : invalid_with_item_rule(Parser *p)
21365 : : {
21366 [ - + ]: 28 : if (p->level++ == MAXSTACK) {
21367 : 0 : p->error_indicator = 1;
21368 : : PyErr_NoMemory();
21369 : : }
21370 [ - + ]: 28 : if (p->error_indicator) {
21371 : 0 : p->level--;
21372 : 0 : return NULL;
21373 : : }
21374 : 28 : void * _res = NULL;
21375 : 28 : int _mark = p->mark;
21376 : : { // expression 'as' expression &(',' | ')' | ':')
21377 [ - + ]: 28 : if (p->error_indicator) {
21378 : 0 : p->level--;
21379 : 0 : 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 [ + + ]: 28 : if (
21386 : 28 : (expression_var = expression_rule(p)) // expression
21387 [ + + ]: 24 : &&
21388 : 24 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
21389 [ + - ]: 14 : &&
21390 : 14 : (a = expression_rule(p)) // expression
21391 [ + + ]: 14 : &&
21392 : 14 : _PyPegen_lookahead(1, _tmp_193_rule, p)
21393 : : )
21394 : : {
21395 : : D(fprintf(stderr, "%*c+ invalid_with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' expression &(',' | ')' | ':')"));
21396 : 11 : _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a );
21397 [ + - + - ]: 11 : if (_res == NULL && PyErr_Occurred()) {
21398 : 11 : p->error_indicator = 1;
21399 : 11 : p->level--;
21400 : 11 : return NULL;
21401 : : }
21402 : 0 : goto done;
21403 : : }
21404 : 17 : 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 : 17 : _res = NULL;
21409 : 17 : done:
21410 : 17 : p->level--;
21411 : 17 : return _res;
21412 : : }
21413 : :
21414 : : // invalid_for_target: ASYNC? 'for' star_expressions
21415 : : static void *
21416 : 535 : invalid_for_target_rule(Parser *p)
21417 : : {
21418 [ - + ]: 535 : if (p->level++ == MAXSTACK) {
21419 : 0 : p->error_indicator = 1;
21420 : : PyErr_NoMemory();
21421 : : }
21422 [ - + ]: 535 : if (p->error_indicator) {
21423 : 0 : p->level--;
21424 : 0 : return NULL;
21425 : : }
21426 : 535 : void * _res = NULL;
21427 : 535 : int _mark = p->mark;
21428 : : { // ASYNC? 'for' star_expressions
21429 [ - + ]: 535 : if (p->error_indicator) {
21430 : 0 : p->level--;
21431 : 0 : 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 : 535 : if (
21439 [ + - ]: 535 : (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC?
21440 [ + + ]: 535 : &&
21441 : 535 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
21442 [ + + ]: 18 : &&
21443 : 18 : (a = star_expressions_rule(p)) // 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 : 16 : _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( FOR_TARGETS , a );
21448 [ + - + + ]: 16 : if (_res == NULL && PyErr_Occurred()) {
21449 : 13 : p->error_indicator = 1;
21450 : 13 : p->level--;
21451 : 13 : return NULL;
21452 : : }
21453 : 3 : goto done;
21454 : : }
21455 : 519 : 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 : 519 : _res = NULL;
21460 : 522 : done:
21461 : 522 : p->level--;
21462 : 522 : return _res;
21463 : : }
21464 : :
21465 : : // invalid_group: '(' starred_expression ')' | '(' '**' expression ')'
21466 : : static void *
21467 : 50 : invalid_group_rule(Parser *p)
21468 : : {
21469 [ - + ]: 50 : if (p->level++ == MAXSTACK) {
21470 : 0 : p->error_indicator = 1;
21471 : : PyErr_NoMemory();
21472 : : }
21473 [ - + ]: 50 : if (p->error_indicator) {
21474 : 0 : p->level--;
21475 : 0 : return NULL;
21476 : : }
21477 : 50 : void * _res = NULL;
21478 : 50 : int _mark = p->mark;
21479 : : { // '(' starred_expression ')'
21480 [ - + ]: 50 : if (p->error_indicator) {
21481 : 0 : p->level--;
21482 : 0 : 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 [ + - ]: 50 : if (
21489 : 50 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
21490 [ + + ]: 50 : &&
21491 : 50 : (a = starred_expression_rule(p)) // starred_expression
21492 [ + + ]: 10 : &&
21493 : 10 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
21494 : : )
21495 : : {
21496 : : D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'"));
21497 : 9 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use starred expression here" );
21498 [ + - + - ]: 9 : if (_res == NULL && PyErr_Occurred()) {
21499 : 9 : p->error_indicator = 1;
21500 : 9 : p->level--;
21501 : 9 : return NULL;
21502 : : }
21503 : 0 : goto done;
21504 : : }
21505 : 41 : 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 [ - + ]: 41 : if (p->error_indicator) {
21511 : 0 : p->level--;
21512 : 0 : 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 [ + - ]: 41 : if (
21520 : 41 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
21521 [ + + ]: 41 : &&
21522 : 41 : (a = _PyPegen_expect_token(p, 35)) // token='**'
21523 [ + - ]: 1 : &&
21524 : 1 : (expression_var = expression_rule(p)) // expression
21525 [ + - ]: 1 : &&
21526 : 1 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
21527 : : )
21528 : : {
21529 : : D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' '**' expression ')'"));
21530 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use double starred expression here" );
21531 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
21532 : 1 : p->error_indicator = 1;
21533 : 1 : p->level--;
21534 : 1 : return NULL;
21535 : : }
21536 : 0 : goto done;
21537 : : }
21538 : 40 : 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 : 40 : _res = NULL;
21543 : 40 : done:
21544 : 40 : p->level--;
21545 : 40 : return _res;
21546 : : }
21547 : :
21548 : : // invalid_import_from_targets: import_from_as_names ',' NEWLINE
21549 : : static void *
21550 : 10 : invalid_import_from_targets_rule(Parser *p)
21551 : : {
21552 [ - + ]: 10 : if (p->level++ == MAXSTACK) {
21553 : 0 : p->error_indicator = 1;
21554 : : PyErr_NoMemory();
21555 : : }
21556 [ - + ]: 10 : if (p->error_indicator) {
21557 : 0 : p->level--;
21558 : 0 : return NULL;
21559 : : }
21560 : 10 : void * _res = NULL;
21561 : 10 : int _mark = p->mark;
21562 : : { // import_from_as_names ',' NEWLINE
21563 [ - + ]: 10 : if (p->error_indicator) {
21564 : 0 : p->level--;
21565 : 0 : 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 [ + + ]: 10 : if (
21572 : 10 : (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names
21573 [ + - ]: 6 : &&
21574 : 6 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
21575 [ + + ]: 6 : &&
21576 : 6 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 5 : _res = RAISE_SYNTAX_ERROR ( "trailing comma not allowed without surrounding parentheses" );
21581 [ + - + - ]: 5 : if (_res == NULL && PyErr_Occurred()) {
21582 : 5 : p->error_indicator = 1;
21583 : 5 : p->level--;
21584 : 5 : return NULL;
21585 : : }
21586 : 0 : goto done;
21587 : : }
21588 : 5 : 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 : 5 : _res = NULL;
21593 : 5 : done:
21594 : 5 : p->level--;
21595 : 5 : 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 : 45 : invalid_with_stmt_rule(Parser *p)
21603 : : {
21604 [ - + ]: 45 : if (p->level++ == MAXSTACK) {
21605 : 0 : p->error_indicator = 1;
21606 : : PyErr_NoMemory();
21607 : : }
21608 [ - + ]: 45 : if (p->error_indicator) {
21609 : 0 : p->level--;
21610 : 0 : return NULL;
21611 : : }
21612 : 45 : void * _res = NULL;
21613 : 45 : int _mark = p->mark;
21614 : : { // ASYNC? 'with' ','.(expression ['as' star_target])+ NEWLINE
21615 [ - + ]: 45 : if (p->error_indicator) {
21616 : 0 : p->level--;
21617 : 0 : 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 : 45 : if (
21626 [ + - ]: 45 : (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC?
21627 [ + + ]: 45 : &&
21628 : 45 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
21629 [ + + ]: 11 : &&
21630 : 11 : (_gather_194_var = _gather_194_rule(p)) // ','.(expression ['as' star_target])+
21631 [ + + ]: 7 : &&
21632 : 7 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 6 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
21637 [ + - + - ]: 6 : if (_res == NULL && PyErr_Occurred()) {
21638 : 6 : p->error_indicator = 1;
21639 : 6 : p->level--;
21640 : 6 : return NULL;
21641 : : }
21642 : 0 : goto done;
21643 : : }
21644 : 39 : 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 [ - + ]: 39 : if (p->error_indicator) {
21650 : 0 : p->level--;
21651 : 0 : 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 : 39 : if (
21664 [ + - ]: 39 : (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC?
21665 [ + + ]: 39 : &&
21666 : 39 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
21667 [ + + ]: 5 : &&
21668 : 5 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
21669 [ + - ]: 3 : &&
21670 : 3 : (_gather_196_var = _gather_196_rule(p)) // ','.(expressions ['as' star_target])+
21671 : 3 : &&
21672 [ + - ]: 3 : (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
21673 [ + - ]: 3 : &&
21674 : 3 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
21675 [ + - ]: 3 : &&
21676 : 3 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 3 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
21681 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
21682 : 3 : p->error_indicator = 1;
21683 : 3 : p->level--;
21684 : 3 : return NULL;
21685 : : }
21686 : 0 : goto done;
21687 : : }
21688 : 36 : 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 : 36 : _res = NULL;
21693 : 36 : done:
21694 : 36 : p->level--;
21695 : 36 : 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 : 63 : invalid_with_stmt_indent_rule(Parser *p)
21703 : : {
21704 [ - + ]: 63 : if (p->level++ == MAXSTACK) {
21705 : 0 : p->error_indicator = 1;
21706 : : PyErr_NoMemory();
21707 : : }
21708 [ - + ]: 63 : if (p->error_indicator) {
21709 : 0 : p->level--;
21710 : 0 : return NULL;
21711 : : }
21712 : 63 : void * _res = NULL;
21713 : 63 : int _mark = p->mark;
21714 : : { // ASYNC? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT
21715 [ - + ]: 63 : if (p->error_indicator) {
21716 : 0 : p->level--;
21717 : 0 : 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 : 63 : if (
21727 [ + - ]: 63 : (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC?
21728 [ + + ]: 63 : &&
21729 : 63 : (a = _PyPegen_expect_token(p, 612)) // token='with'
21730 [ + + ]: 29 : &&
21731 : 29 : (_gather_198_var = _gather_198_rule(p)) // ','.(expression ['as' star_target])+
21732 [ + + ]: 22 : &&
21733 : 22 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
21734 [ + - ]: 4 : &&
21735 : 4 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
21736 [ + - ]: 4 : &&
21737 : 4 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 4 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno );
21742 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
21743 : 4 : p->error_indicator = 1;
21744 : 4 : p->level--;
21745 : 4 : return NULL;
21746 : : }
21747 : 0 : goto done;
21748 : : }
21749 : 59 : 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 [ + + ]: 59 : if (p->error_indicator) {
21755 : 1 : p->level--;
21756 : 1 : 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 : 58 : if (
21770 [ + - ]: 58 : (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC?
21771 [ + + ]: 58 : &&
21772 : 58 : (a = _PyPegen_expect_token(p, 612)) // token='with'
21773 [ + + ]: 24 : &&
21774 : 24 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
21775 [ + - ]: 6 : &&
21776 : 6 : (_gather_200_var = _gather_200_rule(p)) // ','.(expressions ['as' star_target])+
21777 : 6 : &&
21778 [ + - ]: 6 : (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
21779 [ + - ]: 6 : &&
21780 : 6 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
21781 [ + + ]: 6 : &&
21782 : 6 : (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
21783 [ + - ]: 2 : &&
21784 : 2 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
21785 [ + - ]: 2 : &&
21786 : 2 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 2 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno );
21791 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
21792 : 2 : p->error_indicator = 1;
21793 : 2 : p->level--;
21794 : 2 : return NULL;
21795 : : }
21796 : 0 : goto done;
21797 : : }
21798 : 56 : 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 : 56 : _res = NULL;
21803 : 56 : done:
21804 : 56 : p->level--;
21805 : 56 : 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 : 51 : invalid_try_stmt_rule(Parser *p)
21814 : : {
21815 [ - + ]: 51 : if (p->level++ == MAXSTACK) {
21816 : 0 : p->error_indicator = 1;
21817 : : PyErr_NoMemory();
21818 : : }
21819 [ - + ]: 51 : if (p->error_indicator) {
21820 : 0 : p->level--;
21821 : 0 : return NULL;
21822 : : }
21823 : 51 : void * _res = NULL;
21824 : 51 : int _mark = p->mark;
21825 : : { // 'try' ':' NEWLINE !INDENT
21826 [ - + ]: 51 : if (p->error_indicator) {
21827 : 0 : p->level--;
21828 : 0 : 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 [ + - ]: 51 : if (
21835 : 51 : (a = _PyPegen_expect_token(p, 618)) // token='try'
21836 [ + - ]: 51 : &&
21837 : 51 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
21838 [ + + ]: 51 : &&
21839 : 51 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
21840 [ + + ]: 34 : &&
21841 : 34 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 1 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'try' statement on line %d" , a -> lineno );
21846 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
21847 : 1 : p->error_indicator = 1;
21848 : 1 : p->level--;
21849 : 1 : return NULL;
21850 : : }
21851 : 0 : goto done;
21852 : : }
21853 : 50 : 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 [ - + ]: 50 : if (p->error_indicator) {
21859 : 0 : p->level--;
21860 : 0 : 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 [ + - ]: 50 : if (
21867 : 50 : (_keyword = _PyPegen_expect_token(p, 618)) // token='try'
21868 [ + - ]: 50 : &&
21869 : 50 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
21870 [ + + ]: 50 : &&
21871 : 50 : (block_var = block_rule(p)) // block
21872 [ + + ]: 41 : &&
21873 : 41 : _PyPegen_lookahead(0, _tmp_202_rule, p)
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 : 1 : _res = RAISE_SYNTAX_ERROR ( "expected 'except' or 'finally' block" );
21878 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
21879 : 1 : p->error_indicator = 1;
21880 : 1 : p->level--;
21881 : 1 : return NULL;
21882 : : }
21883 : 0 : goto done;
21884 : : }
21885 : 49 : 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 [ - + ]: 49 : if (p->error_indicator) {
21891 : 0 : p->level--;
21892 : 0 : 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 [ + - ]: 49 : if (
21901 : 49 : (_keyword = _PyPegen_expect_token(p, 618)) // token='try'
21902 [ + - ]: 49 : &&
21903 : 49 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
21904 [ + - ]: 49 : &&
21905 : 49 : (_loop0_203_var = _loop0_203_rule(p)) // block*
21906 [ + + ]: 49 : &&
21907 : 49 : (_tmp_204_var = _tmp_204_rule(p)) // (except_block+ except_star_block) | (except_star_block+ except_block)
21908 [ + - ]: 11 : &&
21909 : 11 : (_loop0_205_var = _loop0_205_rule(p)) // 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 : 11 : _res = RAISE_SYNTAX_ERROR ( "cannot have both 'except' and 'except*' on the same 'try'" );
21914 [ + - + - ]: 11 : if (_res == NULL && PyErr_Occurred()) {
21915 : 11 : p->error_indicator = 1;
21916 : 11 : p->level--;
21917 : 11 : return NULL;
21918 : : }
21919 : 0 : goto done;
21920 : : }
21921 : 38 : 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 : 38 : _res = NULL;
21926 : 38 : done:
21927 : 38 : p->level--;
21928 : 38 : 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 : 103 : invalid_except_stmt_rule(Parser *p)
21938 : : {
21939 [ - + ]: 103 : if (p->level++ == MAXSTACK) {
21940 : 0 : p->error_indicator = 1;
21941 : : PyErr_NoMemory();
21942 : : }
21943 [ - + ]: 103 : if (p->error_indicator) {
21944 : 0 : p->level--;
21945 : 0 : return NULL;
21946 : : }
21947 : 103 : void * _res = NULL;
21948 : 103 : int _mark = p->mark;
21949 : : { // 'except' '*'? expression ',' expressions ['as' NAME] ':'
21950 [ - + ]: 103 : if (p->error_indicator) {
21951 : 0 : p->level--;
21952 : 0 : 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 [ + + ]: 103 : if (
21965 : 103 : (_keyword = _PyPegen_expect_token(p, 629)) // token='except'
21966 : 43 : &&
21967 [ + - ]: 43 : (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'?
21968 [ + + ]: 43 : &&
21969 : 43 : (a = expression_rule(p)) // expression
21970 [ + + ]: 37 : &&
21971 : 37 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
21972 [ + - ]: 8 : &&
21973 : 8 : (expressions_var = expressions_rule(p)) // expressions
21974 : 8 : &&
21975 [ + - ]: 8 : (_opt_var_1 = _tmp_206_rule(p), !p->error_indicator) // ['as' NAME]
21976 [ + - ]: 8 : &&
21977 : 8 : (_literal_1 = _PyPegen_expect_token(p, 11)) // 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 : 8 : _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "multiple exception types must be parenthesized" );
21982 [ + - + - ]: 8 : if (_res == NULL && PyErr_Occurred()) {
21983 : 8 : p->error_indicator = 1;
21984 : 8 : p->level--;
21985 : 8 : return NULL;
21986 : : }
21987 : 0 : goto done;
21988 : : }
21989 : 95 : 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 [ - + ]: 95 : if (p->error_indicator) {
21995 : 0 : p->level--;
21996 : 0 : 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 [ + + ]: 95 : if (
22007 : 95 : (a = _PyPegen_expect_token(p, 629)) // token='except'
22008 : 35 : &&
22009 [ + - ]: 35 : (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'?
22010 [ + + ]: 35 : &&
22011 : 35 : (expression_var = expression_rule(p)) // expression
22012 : 29 : &&
22013 [ + - ]: 29 : (_opt_var_1 = _tmp_207_rule(p), !p->error_indicator) // ['as' NAME]
22014 [ - + ]: 29 : &&
22015 : 29 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 0 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
22020 [ # # # # ]: 0 : if (_res == NULL && PyErr_Occurred()) {
22021 : 0 : p->error_indicator = 1;
22022 : 0 : p->level--;
22023 : 0 : return NULL;
22024 : : }
22025 : 0 : goto done;
22026 : : }
22027 : 95 : 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 [ - + ]: 95 : if (p->error_indicator) {
22033 : 0 : p->level--;
22034 : 0 : 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 [ + + ]: 95 : if (
22040 : 95 : (a = _PyPegen_expect_token(p, 629)) // token='except'
22041 [ + + ]: 35 : &&
22042 : 35 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
22047 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22048 : 1 : p->error_indicator = 1;
22049 : 1 : p->level--;
22050 : 1 : return NULL;
22051 : : }
22052 : 0 : goto done;
22053 : : }
22054 : 94 : 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 [ - + ]: 94 : if (p->error_indicator) {
22060 : 0 : p->level--;
22061 : 0 : 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 [ + + ]: 94 : if (
22068 : 94 : (a = _PyPegen_expect_token(p, 629)) // token='except'
22069 [ + + ]: 34 : &&
22070 : 34 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
22071 [ + + ]: 23 : &&
22072 : 23 : (_tmp_208_var = _tmp_208_rule(p)) // NEWLINE | ':'
22073 : : )
22074 : : {
22075 : : D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')"));
22076 : 4 : _res = RAISE_SYNTAX_ERROR ( "expected one or more exception types" );
22077 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
22078 : 4 : p->error_indicator = 1;
22079 : 4 : p->level--;
22080 : 4 : return NULL;
22081 : : }
22082 : 0 : goto done;
22083 : : }
22084 : 90 : 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 : 90 : _res = NULL;
22089 : 90 : done:
22090 : 90 : p->level--;
22091 : 90 : return _res;
22092 : : }
22093 : :
22094 : : // invalid_finally_stmt: 'finally' ':' NEWLINE !INDENT
22095 : : static void *
22096 : 15 : invalid_finally_stmt_rule(Parser *p)
22097 : : {
22098 [ - + ]: 15 : if (p->level++ == MAXSTACK) {
22099 : 0 : p->error_indicator = 1;
22100 : : PyErr_NoMemory();
22101 : : }
22102 [ - + ]: 15 : if (p->error_indicator) {
22103 : 0 : p->level--;
22104 : 0 : return NULL;
22105 : : }
22106 : 15 : void * _res = NULL;
22107 : 15 : int _mark = p->mark;
22108 : : { // 'finally' ':' NEWLINE !INDENT
22109 [ - + ]: 15 : if (p->error_indicator) {
22110 : 0 : p->level--;
22111 : 0 : 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 [ + + ]: 15 : if (
22118 : 15 : (a = _PyPegen_expect_token(p, 625)) // token='finally'
22119 [ + - ]: 11 : &&
22120 : 11 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22121 [ + + ]: 11 : &&
22122 : 11 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22123 [ + - ]: 2 : &&
22124 : 2 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 2 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'finally' statement on line %d" , a -> lineno );
22129 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
22130 : 2 : p->error_indicator = 1;
22131 : 2 : p->level--;
22132 : 2 : return NULL;
22133 : : }
22134 : 0 : goto done;
22135 : : }
22136 : 13 : 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 : 13 : _res = NULL;
22141 : 13 : done:
22142 : 13 : p->level--;
22143 : 13 : return _res;
22144 : : }
22145 : :
22146 : : // invalid_except_stmt_indent:
22147 : : // | 'except' expression ['as' NAME] ':' NEWLINE !INDENT
22148 : : // | 'except' ':' NEWLINE !INDENT
22149 : : static void *
22150 : 78 : invalid_except_stmt_indent_rule(Parser *p)
22151 : : {
22152 [ - + ]: 78 : if (p->level++ == MAXSTACK) {
22153 : 0 : p->error_indicator = 1;
22154 : : PyErr_NoMemory();
22155 : : }
22156 [ - + ]: 78 : if (p->error_indicator) {
22157 : 0 : p->level--;
22158 : 0 : return NULL;
22159 : : }
22160 : 78 : void * _res = NULL;
22161 : 78 : int _mark = p->mark;
22162 : : { // 'except' expression ['as' NAME] ':' NEWLINE !INDENT
22163 [ - + ]: 78 : if (p->error_indicator) {
22164 : 0 : p->level--;
22165 : 0 : 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 [ + + ]: 78 : if (
22175 : 78 : (a = _PyPegen_expect_token(p, 629)) // token='except'
22176 [ + + ]: 48 : &&
22177 : 48 : (expression_var = expression_rule(p)) // expression
22178 : 21 : &&
22179 [ + - ]: 21 : (_opt_var = _tmp_209_rule(p), !p->error_indicator) // ['as' NAME]
22180 [ + + ]: 21 : &&
22181 : 21 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22182 [ + + ]: 15 : &&
22183 : 15 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22184 [ + + ]: 8 : &&
22185 : 8 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 1 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno );
22190 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22191 : 1 : p->error_indicator = 1;
22192 : 1 : p->level--;
22193 : 1 : return NULL;
22194 : : }
22195 : 0 : goto done;
22196 : : }
22197 : 77 : 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 [ - + ]: 77 : if (p->error_indicator) {
22203 : 0 : p->level--;
22204 : 0 : 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 [ + + ]: 77 : if (
22211 : 77 : (a = _PyPegen_expect_token(p, 629)) // token='except'
22212 [ + + ]: 47 : &&
22213 : 47 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22214 [ + + ]: 2 : &&
22215 : 2 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22216 [ + - ]: 1 : &&
22217 : 1 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 1 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno );
22222 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22223 : 1 : p->error_indicator = 1;
22224 : 1 : p->level--;
22225 : 1 : return NULL;
22226 : : }
22227 : 0 : goto done;
22228 : : }
22229 : 76 : 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 : 76 : _res = NULL;
22234 : 76 : done:
22235 : 76 : p->level--;
22236 : 76 : return _res;
22237 : : }
22238 : :
22239 : : // invalid_except_star_stmt_indent:
22240 : : // | 'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT
22241 : : static void *
22242 : 58 : invalid_except_star_stmt_indent_rule(Parser *p)
22243 : : {
22244 [ - + ]: 58 : if (p->level++ == MAXSTACK) {
22245 : 0 : p->error_indicator = 1;
22246 : : PyErr_NoMemory();
22247 : : }
22248 [ - + ]: 58 : if (p->error_indicator) {
22249 : 0 : p->level--;
22250 : 0 : return NULL;
22251 : : }
22252 : 58 : void * _res = NULL;
22253 : 58 : int _mark = p->mark;
22254 : : { // 'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT
22255 [ - + ]: 58 : if (p->error_indicator) {
22256 : 0 : p->level--;
22257 : 0 : 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 [ + + ]: 58 : if (
22268 : 58 : (a = _PyPegen_expect_token(p, 629)) // token='except'
22269 [ + + ]: 28 : &&
22270 : 28 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
22271 [ + + ]: 19 : &&
22272 : 19 : (expression_var = expression_rule(p)) // expression
22273 : 18 : &&
22274 [ + - ]: 18 : (_opt_var = _tmp_210_rule(p), !p->error_indicator) // ['as' NAME]
22275 [ + + ]: 18 : &&
22276 : 18 : (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
22277 [ + + ]: 16 : &&
22278 : 16 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22279 [ + + ]: 9 : &&
22280 : 9 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 1 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except*' statement on line %d" , a -> lineno );
22285 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22286 : 1 : p->error_indicator = 1;
22287 : 1 : p->level--;
22288 : 1 : return NULL;
22289 : : }
22290 : 0 : goto done;
22291 : : }
22292 : 57 : 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 : 57 : _res = NULL;
22297 : 57 : done:
22298 : 57 : p->level--;
22299 : 57 : return _res;
22300 : : }
22301 : :
22302 : : // invalid_match_stmt:
22303 : : // | "match" subject_expr NEWLINE
22304 : : // | "match" subject_expr ':' NEWLINE !INDENT
22305 : : static void *
22306 : 829 : invalid_match_stmt_rule(Parser *p)
22307 : : {
22308 [ - + ]: 829 : if (p->level++ == MAXSTACK) {
22309 : 0 : p->error_indicator = 1;
22310 : : PyErr_NoMemory();
22311 : : }
22312 [ - + ]: 829 : if (p->error_indicator) {
22313 : 0 : p->level--;
22314 : 0 : return NULL;
22315 : : }
22316 : 829 : void * _res = NULL;
22317 : 829 : int _mark = p->mark;
22318 : : { // "match" subject_expr NEWLINE
22319 [ - + ]: 829 : if (p->error_indicator) {
22320 : 0 : p->level--;
22321 : 0 : 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 [ + + ]: 829 : if (
22328 : 829 : (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"'
22329 [ + - ]: 12 : &&
22330 : 12 : (subject_expr_var = subject_expr_rule(p)) // subject_expr
22331 [ + + ]: 12 : &&
22332 : 12 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 1 : _res = CHECK_VERSION ( void* , 10 , "Pattern matching is" , RAISE_SYNTAX_ERROR ( "expected ':'" ) );
22337 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22338 : 1 : p->error_indicator = 1;
22339 : 1 : p->level--;
22340 : 1 : return NULL;
22341 : : }
22342 : 0 : goto done;
22343 : : }
22344 : 828 : 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 [ - + ]: 828 : if (p->error_indicator) {
22350 : 0 : p->level--;
22351 : 0 : 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 [ + + ]: 828 : if (
22359 : 828 : (a = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"'
22360 [ + - ]: 11 : &&
22361 : 11 : (subject = subject_expr_rule(p)) // subject_expr
22362 [ + + ]: 11 : &&
22363 : 11 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22364 [ + - ]: 10 : &&
22365 : 10 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22366 [ + + ]: 10 : &&
22367 : 10 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 1 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'match' statement on line %d" , a -> lineno );
22372 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22373 : 1 : p->error_indicator = 1;
22374 : 1 : p->level--;
22375 : 1 : return NULL;
22376 : : }
22377 : 0 : goto done;
22378 : : }
22379 : 827 : 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 : 827 : _res = NULL;
22384 : 827 : done:
22385 : 827 : p->level--;
22386 : 827 : return _res;
22387 : : }
22388 : :
22389 : : // invalid_case_block:
22390 : : // | "case" patterns guard? NEWLINE
22391 : : // | "case" patterns guard? ':' NEWLINE !INDENT
22392 : : static void *
22393 : 21 : invalid_case_block_rule(Parser *p)
22394 : : {
22395 [ - + ]: 21 : if (p->level++ == MAXSTACK) {
22396 : 0 : p->error_indicator = 1;
22397 : : PyErr_NoMemory();
22398 : : }
22399 [ - + ]: 21 : if (p->error_indicator) {
22400 : 0 : p->level--;
22401 : 0 : return NULL;
22402 : : }
22403 : 21 : void * _res = NULL;
22404 : 21 : int _mark = p->mark;
22405 : : { // "case" patterns guard? NEWLINE
22406 [ - + ]: 21 : if (p->error_indicator) {
22407 : 0 : p->level--;
22408 : 0 : 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 [ + + ]: 21 : if (
22417 : 21 : (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"'
22418 [ + + ]: 20 : &&
22419 : 20 : (patterns_var = patterns_rule(p)) // patterns
22420 : 6 : &&
22421 [ + - ]: 6 : (_opt_var = guard_rule(p), !p->error_indicator) // guard?
22422 [ + + ]: 6 : &&
22423 : 6 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 2 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
22428 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
22429 : 2 : p->error_indicator = 1;
22430 : 2 : p->level--;
22431 : 2 : return NULL;
22432 : : }
22433 : 0 : goto done;
22434 : : }
22435 : 19 : 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 [ + + ]: 19 : if (p->error_indicator) {
22441 : 7 : p->level--;
22442 : 7 : 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 [ + + ]: 12 : if (
22452 : 12 : (a = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"'
22453 [ + + ]: 11 : &&
22454 : 11 : (patterns_var = patterns_rule(p)) // patterns
22455 : 4 : &&
22456 [ + - ]: 4 : (_opt_var = guard_rule(p), !p->error_indicator) // guard?
22457 [ + - ]: 4 : &&
22458 : 4 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22459 [ + - ]: 4 : &&
22460 : 4 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22461 [ + + ]: 4 : &&
22462 : 4 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 2 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'case' statement on line %d" , a -> lineno );
22467 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
22468 : 2 : p->error_indicator = 1;
22469 : 2 : p->level--;
22470 : 2 : return NULL;
22471 : : }
22472 : 0 : goto done;
22473 : : }
22474 : 10 : 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 : 10 : _res = NULL;
22479 : 10 : done:
22480 : 10 : p->level--;
22481 : 10 : return _res;
22482 : : }
22483 : :
22484 : : // invalid_as_pattern: or_pattern 'as' "_" | or_pattern 'as' !NAME expression
22485 : : static void *
22486 : 107 : invalid_as_pattern_rule(Parser *p)
22487 : : {
22488 [ - + ]: 107 : if (p->level++ == MAXSTACK) {
22489 : 0 : p->error_indicator = 1;
22490 : : PyErr_NoMemory();
22491 : : }
22492 [ - + ]: 107 : if (p->error_indicator) {
22493 : 0 : p->level--;
22494 : 0 : return NULL;
22495 : : }
22496 : 107 : void * _res = NULL;
22497 : 107 : int _mark = p->mark;
22498 : : { // or_pattern 'as' "_"
22499 [ - + ]: 107 : if (p->error_indicator) {
22500 : 0 : p->level--;
22501 : 0 : 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 [ + + ]: 107 : if (
22508 : 107 : (or_pattern_var = or_pattern_rule(p)) // or_pattern
22509 [ + + ]: 49 : &&
22510 : 49 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
22511 [ + + ]: 3 : &&
22512 : 3 : (a = _PyPegen_expect_soft_keyword(p, "_")) // 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 : 2 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use '_' as a target" );
22517 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
22518 : 2 : p->error_indicator = 1;
22519 : 2 : p->level--;
22520 : 2 : return NULL;
22521 : : }
22522 : 0 : goto done;
22523 : : }
22524 : 105 : 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 [ - + ]: 105 : if (p->error_indicator) {
22530 : 0 : p->level--;
22531 : 0 : 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 [ + + ]: 105 : if (
22538 : 105 : (or_pattern_var = or_pattern_rule(p)) // or_pattern
22539 [ + + ]: 47 : &&
22540 : 47 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
22541 [ + - ]: 1 : &&
22542 : 1 : _PyPegen_lookahead_with_name(0, _PyPegen_name_token, p)
22543 [ + - ]: 1 : &&
22544 : 1 : (a = expression_rule(p)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "invalid pattern target" );
22549 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22550 : 1 : p->error_indicator = 1;
22551 : 1 : p->level--;
22552 : 1 : return NULL;
22553 : : }
22554 : 0 : goto done;
22555 : : }
22556 : 104 : 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 : 104 : _res = NULL;
22561 : 104 : done:
22562 : 104 : p->level--;
22563 : 104 : return _res;
22564 : : }
22565 : :
22566 : : // invalid_class_pattern: name_or_attr '(' invalid_class_argument_pattern
22567 : : static void *
22568 : 19 : invalid_class_pattern_rule(Parser *p)
22569 : : {
22570 [ - + ]: 19 : if (p->level++ == MAXSTACK) {
22571 : 0 : p->error_indicator = 1;
22572 : : PyErr_NoMemory();
22573 : : }
22574 [ - + ]: 19 : if (p->error_indicator) {
22575 : 0 : p->level--;
22576 : 0 : return NULL;
22577 : : }
22578 : 19 : void * _res = NULL;
22579 : 19 : int _mark = p->mark;
22580 : : { // name_or_attr '(' invalid_class_argument_pattern
22581 [ - + ]: 19 : if (p->error_indicator) {
22582 : 0 : p->level--;
22583 : 0 : 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 [ + + ]: 19 : if (
22590 : 19 : (name_or_attr_var = name_or_attr_rule(p)) // name_or_attr
22591 [ + + ]: 10 : &&
22592 : 10 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
22593 [ + - ]: 4 : &&
22594 : 4 : (a = invalid_class_argument_pattern_rule(p)) // 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 : 4 : _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( PyPegen_first_item ( a , pattern_ty ) , PyPegen_last_item ( a , pattern_ty ) , "positional patterns follow keyword patterns" );
22599 [ + - + - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
22600 : 4 : p->error_indicator = 1;
22601 : 4 : p->level--;
22602 : 4 : return NULL;
22603 : : }
22604 : 0 : goto done;
22605 : : }
22606 : 15 : 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 : 15 : _res = NULL;
22611 : 15 : done:
22612 : 15 : p->level--;
22613 : 15 : return _res;
22614 : : }
22615 : :
22616 : : // invalid_class_argument_pattern:
22617 : : // | [positional_patterns ','] keyword_patterns ',' positional_patterns
22618 : : static asdl_pattern_seq*
22619 : 4 : invalid_class_argument_pattern_rule(Parser *p)
22620 : : {
22621 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
22622 : 0 : p->error_indicator = 1;
22623 : : PyErr_NoMemory();
22624 : : }
22625 [ - + ]: 4 : if (p->error_indicator) {
22626 : 0 : p->level--;
22627 : 0 : return NULL;
22628 : : }
22629 : 4 : asdl_pattern_seq* _res = NULL;
22630 : 4 : int _mark = p->mark;
22631 : : { // [positional_patterns ','] keyword_patterns ',' positional_patterns
22632 [ - + ]: 4 : if (p->error_indicator) {
22633 : 0 : p->level--;
22634 : 0 : 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 : 4 : if (
22643 [ + - ]: 4 : (_opt_var = _tmp_211_rule(p), !p->error_indicator) // [positional_patterns ',']
22644 [ + - ]: 4 : &&
22645 : 4 : (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns
22646 [ + - ]: 4 : &&
22647 : 4 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
22648 [ + - ]: 4 : &&
22649 : 4 : (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 : 4 : _res = a;
22654 [ - + - - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
22655 : 0 : p->error_indicator = 1;
22656 : 0 : p->level--;
22657 : 0 : return NULL;
22658 : : }
22659 : 4 : goto done;
22660 : : }
22661 : 0 : 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 : 0 : _res = NULL;
22666 : 4 : done:
22667 : 4 : p->level--;
22668 : 4 : return _res;
22669 : : }
22670 : :
22671 : : // invalid_if_stmt:
22672 : : // | 'if' named_expression NEWLINE
22673 : : // | 'if' named_expression ':' NEWLINE !INDENT
22674 : : static void *
22675 : 39 : invalid_if_stmt_rule(Parser *p)
22676 : : {
22677 [ - + ]: 39 : if (p->level++ == MAXSTACK) {
22678 : 0 : p->error_indicator = 1;
22679 : : PyErr_NoMemory();
22680 : : }
22681 [ - + ]: 39 : if (p->error_indicator) {
22682 : 0 : p->level--;
22683 : 0 : return NULL;
22684 : : }
22685 : 39 : void * _res = NULL;
22686 : 39 : int _mark = p->mark;
22687 : : { // 'if' named_expression NEWLINE
22688 [ - + ]: 39 : if (p->error_indicator) {
22689 : 0 : p->level--;
22690 : 0 : 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 [ + - ]: 39 : if (
22697 : 39 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
22698 [ + + ]: 39 : &&
22699 : 39 : (named_expression_var = named_expression_rule(p)) // named_expression
22700 [ + + ]: 34 : &&
22701 : 34 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
22706 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22707 : 1 : p->error_indicator = 1;
22708 : 1 : p->level--;
22709 : 1 : return NULL;
22710 : : }
22711 : 0 : goto done;
22712 : : }
22713 : 38 : 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 [ + + ]: 38 : if (p->error_indicator) {
22719 : 2 : p->level--;
22720 : 2 : 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 [ + - ]: 36 : if (
22728 : 36 : (a = _PyPegen_expect_token(p, 634)) // token='if'
22729 [ + + ]: 36 : &&
22730 : 36 : (a_1 = named_expression_rule(p)) // named_expression
22731 [ + - ]: 33 : &&
22732 : 33 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22733 [ + + ]: 33 : &&
22734 : 33 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22735 [ + + ]: 25 : &&
22736 : 25 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 3 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'if' statement on line %d" , a -> lineno );
22741 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
22742 : 3 : p->error_indicator = 1;
22743 : 3 : p->level--;
22744 : 3 : return NULL;
22745 : : }
22746 : 0 : goto done;
22747 : : }
22748 : 33 : 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 : 33 : _res = NULL;
22753 : 33 : done:
22754 : 33 : p->level--;
22755 : 33 : return _res;
22756 : : }
22757 : :
22758 : : // invalid_elif_stmt:
22759 : : // | 'elif' named_expression NEWLINE
22760 : : // | 'elif' named_expression ':' NEWLINE !INDENT
22761 : : static void *
22762 : 8 : invalid_elif_stmt_rule(Parser *p)
22763 : : {
22764 [ - + ]: 8 : if (p->level++ == MAXSTACK) {
22765 : 0 : p->error_indicator = 1;
22766 : : PyErr_NoMemory();
22767 : : }
22768 [ - + ]: 8 : if (p->error_indicator) {
22769 : 0 : p->level--;
22770 : 0 : return NULL;
22771 : : }
22772 : 8 : void * _res = NULL;
22773 : 8 : int _mark = p->mark;
22774 : : { // 'elif' named_expression NEWLINE
22775 [ - + ]: 8 : if (p->error_indicator) {
22776 : 0 : p->level--;
22777 : 0 : 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 [ + + ]: 8 : if (
22784 : 8 : (_keyword = _PyPegen_expect_token(p, 636)) // token='elif'
22785 [ + - ]: 6 : &&
22786 : 6 : (named_expression_var = named_expression_rule(p)) // named_expression
22787 [ + + ]: 6 : &&
22788 : 6 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
22793 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22794 : 1 : p->error_indicator = 1;
22795 : 1 : p->level--;
22796 : 1 : return NULL;
22797 : : }
22798 : 0 : goto done;
22799 : : }
22800 : 7 : 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 [ - + ]: 7 : if (p->error_indicator) {
22806 : 0 : p->level--;
22807 : 0 : 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 [ + + ]: 7 : if (
22815 : 7 : (a = _PyPegen_expect_token(p, 636)) // token='elif'
22816 [ + - ]: 5 : &&
22817 : 5 : (named_expression_var = named_expression_rule(p)) // named_expression
22818 [ + - ]: 5 : &&
22819 : 5 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22820 [ + - ]: 5 : &&
22821 : 5 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22822 [ + + ]: 5 : &&
22823 : 5 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 1 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'elif' statement on line %d" , a -> lineno );
22828 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22829 : 1 : p->error_indicator = 1;
22830 : 1 : p->level--;
22831 : 1 : return NULL;
22832 : : }
22833 : 0 : goto done;
22834 : : }
22835 : 6 : 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 : 6 : _res = NULL;
22840 : 6 : done:
22841 : 6 : p->level--;
22842 : 6 : return _res;
22843 : : }
22844 : :
22845 : : // invalid_else_stmt: 'else' ':' NEWLINE !INDENT
22846 : : static void *
22847 : 6 : invalid_else_stmt_rule(Parser *p)
22848 : : {
22849 [ - + ]: 6 : if (p->level++ == MAXSTACK) {
22850 : 0 : p->error_indicator = 1;
22851 : : PyErr_NoMemory();
22852 : : }
22853 [ - + ]: 6 : if (p->error_indicator) {
22854 : 0 : p->level--;
22855 : 0 : return NULL;
22856 : : }
22857 : 6 : void * _res = NULL;
22858 : 6 : int _mark = p->mark;
22859 : : { // 'else' ':' NEWLINE !INDENT
22860 [ - + ]: 6 : if (p->error_indicator) {
22861 : 0 : p->level--;
22862 : 0 : 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 [ + + ]: 6 : if (
22869 : 6 : (a = _PyPegen_expect_token(p, 637)) // token='else'
22870 [ + - ]: 4 : &&
22871 : 4 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22872 [ + - ]: 4 : &&
22873 : 4 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22874 [ + + ]: 4 : &&
22875 : 4 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 3 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'else' statement on line %d" , a -> lineno );
22880 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
22881 : 3 : p->error_indicator = 1;
22882 : 3 : p->level--;
22883 : 3 : return NULL;
22884 : : }
22885 : 0 : goto done;
22886 : : }
22887 : 3 : 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 : 3 : _res = NULL;
22892 : 3 : done:
22893 : 3 : p->level--;
22894 : 3 : return _res;
22895 : : }
22896 : :
22897 : : // invalid_while_stmt:
22898 : : // | 'while' named_expression NEWLINE
22899 : : // | 'while' named_expression ':' NEWLINE !INDENT
22900 : : static void *
22901 : 23 : invalid_while_stmt_rule(Parser *p)
22902 : : {
22903 [ - + ]: 23 : if (p->level++ == MAXSTACK) {
22904 : 0 : p->error_indicator = 1;
22905 : : PyErr_NoMemory();
22906 : : }
22907 [ - + ]: 23 : if (p->error_indicator) {
22908 : 0 : p->level--;
22909 : 0 : return NULL;
22910 : : }
22911 : 23 : void * _res = NULL;
22912 : 23 : int _mark = p->mark;
22913 : : { // 'while' named_expression NEWLINE
22914 [ - + ]: 23 : if (p->error_indicator) {
22915 : 0 : p->level--;
22916 : 0 : 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 [ + - ]: 23 : if (
22923 : 23 : (_keyword = _PyPegen_expect_token(p, 639)) // token='while'
22924 [ + + ]: 23 : &&
22925 : 23 : (named_expression_var = named_expression_rule(p)) // named_expression
22926 [ + + ]: 20 : &&
22927 : 20 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
22932 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22933 : 1 : p->error_indicator = 1;
22934 : 1 : p->level--;
22935 : 1 : return NULL;
22936 : : }
22937 : 0 : goto done;
22938 : : }
22939 : 22 : 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 [ + + ]: 22 : if (p->error_indicator) {
22945 : 2 : p->level--;
22946 : 2 : 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 [ + - ]: 20 : if (
22954 : 20 : (a = _PyPegen_expect_token(p, 639)) // token='while'
22955 [ + + ]: 20 : &&
22956 : 20 : (named_expression_var = named_expression_rule(p)) // named_expression
22957 [ + - ]: 19 : &&
22958 : 19 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22959 [ + + ]: 19 : &&
22960 : 19 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22961 [ + + ]: 10 : &&
22962 : 10 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 1 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'while' statement on line %d" , a -> lineno );
22967 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
22968 : 1 : p->error_indicator = 1;
22969 : 1 : p->level--;
22970 : 1 : return NULL;
22971 : : }
22972 : 0 : goto done;
22973 : : }
22974 : 19 : 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 : 19 : _res = NULL;
22979 : 19 : done:
22980 : 19 : p->level--;
22981 : 19 : 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 : 54 : invalid_for_stmt_rule(Parser *p)
22989 : : {
22990 [ - + ]: 54 : if (p->level++ == MAXSTACK) {
22991 : 0 : p->error_indicator = 1;
22992 : : PyErr_NoMemory();
22993 : : }
22994 [ - + ]: 54 : if (p->error_indicator) {
22995 : 0 : p->level--;
22996 : 0 : return NULL;
22997 : : }
22998 : 54 : void * _res = NULL;
22999 : 54 : int _mark = p->mark;
23000 : : { // ASYNC? 'for' star_targets 'in' star_expressions NEWLINE
23001 [ - + ]: 54 : if (p->error_indicator) {
23002 : 0 : p->level--;
23003 : 0 : 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 : 54 : if (
23014 [ + - ]: 54 : (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC?
23015 [ + + ]: 54 : &&
23016 : 54 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
23017 [ + + ]: 22 : &&
23018 : 22 : (star_targets_var = star_targets_rule(p)) // star_targets
23019 [ + + ]: 13 : &&
23020 : 13 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
23021 [ + - ]: 7 : &&
23022 : 7 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
23023 [ + + ]: 7 : &&
23024 : 7 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
23029 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
23030 : 1 : p->error_indicator = 1;
23031 : 1 : p->level--;
23032 : 1 : return NULL;
23033 : : }
23034 : 0 : goto done;
23035 : : }
23036 : 53 : 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 [ - + ]: 53 : if (p->error_indicator) {
23042 : 0 : p->level--;
23043 : 0 : 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 : 53 : if (
23055 [ + - ]: 53 : (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC?
23056 [ + + ]: 53 : &&
23057 : 53 : (a = _PyPegen_expect_token(p, 642)) // token='for'
23058 [ + + ]: 21 : &&
23059 : 21 : (star_targets_var = star_targets_rule(p)) // star_targets
23060 [ + + ]: 12 : &&
23061 : 12 : (_keyword = _PyPegen_expect_token(p, 643)) // token='in'
23062 [ + - ]: 6 : &&
23063 : 6 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
23064 [ + + ]: 6 : &&
23065 : 6 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23066 [ + + ]: 5 : &&
23067 : 5 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23068 [ + + ]: 4 : &&
23069 : 4 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 2 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'for' statement on line %d" , a -> lineno );
23074 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
23075 : 2 : p->error_indicator = 1;
23076 : 2 : p->level--;
23077 : 2 : return NULL;
23078 : : }
23079 : 0 : goto done;
23080 : : }
23081 : 51 : 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 : 51 : _res = NULL;
23086 : 51 : done:
23087 : 51 : p->level--;
23088 : 51 : return _res;
23089 : : }
23090 : :
23091 : : // invalid_def_raw:
23092 : : // | ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT
23093 : : static void *
23094 : 217 : invalid_def_raw_rule(Parser *p)
23095 : : {
23096 [ - + ]: 217 : if (p->level++ == MAXSTACK) {
23097 : 0 : p->error_indicator = 1;
23098 : : PyErr_NoMemory();
23099 : : }
23100 [ - + ]: 217 : if (p->error_indicator) {
23101 : 0 : p->level--;
23102 : 0 : return NULL;
23103 : : }
23104 : 217 : void * _res = NULL;
23105 : 217 : int _mark = p->mark;
23106 : : { // ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT
23107 [ - + ]: 217 : if (p->error_indicator) {
23108 : 0 : p->level--;
23109 : 0 : 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 : 217 : if (
23125 [ + - ]: 217 : (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator) // ASYNC?
23126 [ + + ]: 217 : &&
23127 : 217 : (a = _PyPegen_expect_token(p, 644)) // token='def'
23128 [ + + ]: 196 : &&
23129 : 196 : (name_var = _PyPegen_name_token(p)) // NAME
23130 [ + - ]: 187 : &&
23131 : 187 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
23132 : 187 : &&
23133 [ + + ]: 187 : (_opt_var_1 = params_rule(p), !p->error_indicator) // params?
23134 [ + + ]: 118 : &&
23135 : 118 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
23136 : 66 : &&
23137 [ + - ]: 66 : (_opt_var_2 = _tmp_212_rule(p), !p->error_indicator) // ['->' expression]
23138 [ + - ]: 66 : &&
23139 : 66 : (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
23140 [ + + ]: 66 : &&
23141 : 66 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23142 [ + + ]: 39 : &&
23143 : 39 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 3 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after function definition on line %d" , a -> lineno );
23148 [ + - + - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
23149 : 3 : p->error_indicator = 1;
23150 : 3 : p->level--;
23151 : 3 : return NULL;
23152 : : }
23153 : 0 : goto done;
23154 : : }
23155 : 214 : 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 : 214 : _res = NULL;
23160 : 214 : done:
23161 : 214 : p->level--;
23162 : 214 : return _res;
23163 : : }
23164 : :
23165 : : // invalid_class_def_raw:
23166 : : // | 'class' NAME ['(' arguments? ')'] NEWLINE
23167 : : // | 'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT
23168 : : static void *
23169 : 15 : invalid_class_def_raw_rule(Parser *p)
23170 : : {
23171 [ - + ]: 15 : if (p->level++ == MAXSTACK) {
23172 : 0 : p->error_indicator = 1;
23173 : : PyErr_NoMemory();
23174 : : }
23175 [ - + ]: 15 : if (p->error_indicator) {
23176 : 0 : p->level--;
23177 : 0 : return NULL;
23178 : : }
23179 : 15 : void * _res = NULL;
23180 : 15 : int _mark = p->mark;
23181 : : { // 'class' NAME ['(' arguments? ')'] NEWLINE
23182 [ - + ]: 15 : if (p->error_indicator) {
23183 : 0 : p->level--;
23184 : 0 : 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 [ + + ]: 15 : if (
23193 : 15 : (_keyword = _PyPegen_expect_token(p, 646)) // token='class'
23194 [ + + ]: 11 : &&
23195 : 11 : (name_var = _PyPegen_name_token(p)) // NAME
23196 : 6 : &&
23197 [ + - ]: 6 : (_opt_var = _tmp_213_rule(p), !p->error_indicator) // ['(' arguments? ')']
23198 [ + + ]: 6 : &&
23199 : 6 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
23204 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
23205 : 1 : p->error_indicator = 1;
23206 : 1 : p->level--;
23207 : 1 : return NULL;
23208 : : }
23209 : 0 : goto done;
23210 : : }
23211 : 14 : 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 [ - + ]: 14 : if (p->error_indicator) {
23217 : 0 : p->level--;
23218 : 0 : 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 [ + + ]: 14 : if (
23228 : 14 : (a = _PyPegen_expect_token(p, 646)) // token='class'
23229 [ + + ]: 10 : &&
23230 : 10 : (name_var = _PyPegen_name_token(p)) // NAME
23231 : 5 : &&
23232 [ + - ]: 5 : (_opt_var = _tmp_214_rule(p), !p->error_indicator) // ['(' arguments? ')']
23233 [ + + ]: 5 : &&
23234 : 5 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23235 [ + - ]: 3 : &&
23236 : 3 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23237 [ + + ]: 3 : &&
23238 : 3 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // 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 : 1 : _res = RAISE_INDENTATION_ERROR ( "expected an indented block after class definition on line %d" , a -> lineno );
23243 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
23244 : 1 : p->error_indicator = 1;
23245 : 1 : p->level--;
23246 : 1 : return NULL;
23247 : : }
23248 : 0 : goto done;
23249 : : }
23250 : 13 : 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 : 13 : _res = NULL;
23255 : 13 : done:
23256 : 13 : p->level--;
23257 : 13 : 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 : 13769 : invalid_double_starred_kvpairs_rule(Parser *p)
23266 : : {
23267 [ - + ]: 13769 : if (p->level++ == MAXSTACK) {
23268 : 0 : p->error_indicator = 1;
23269 : : PyErr_NoMemory();
23270 : : }
23271 [ - + ]: 13769 : if (p->error_indicator) {
23272 : 0 : p->level--;
23273 : 0 : return NULL;
23274 : : }
23275 : 13769 : void * _res = NULL;
23276 : 13769 : int _mark = p->mark;
23277 : : { // ','.double_starred_kvpair+ ',' invalid_kvpair
23278 [ - + ]: 13769 : if (p->error_indicator) {
23279 : 0 : p->level--;
23280 : 0 : 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 [ + + ]: 13769 : if (
23287 : 13769 : (_gather_215_var = _gather_215_rule(p)) // ','.double_starred_kvpair+
23288 [ + + ]: 3792 : &&
23289 : 3792 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
23290 [ - + ]: 3 : &&
23291 : 3 : (invalid_kvpair_var = invalid_kvpair_rule(p)) // 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 : 0 : _res = _PyPegen_dummy_name(p, _gather_215_var, _literal, invalid_kvpair_var);
23296 : 0 : goto done;
23297 : : }
23298 : 13769 : 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 [ + + ]: 13769 : if (p->error_indicator) {
23304 : 3 : p->level--;
23305 : 3 : 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 [ + + ]: 13766 : if (
23313 : 13766 : (expression_var = expression_rule(p)) // expression
23314 [ + + ]: 13681 : &&
23315 : 13681 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23316 [ + + ]: 3801 : &&
23317 : 3801 : (a = _PyPegen_expect_token(p, 16)) // token='*'
23318 [ + - ]: 2 : &&
23319 : 2 : (bitwise_or_var = bitwise_or_rule(p)) // 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 : 2 : _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" );
23324 [ + - + - ]: 2 : if (_res == NULL && PyErr_Occurred()) {
23325 : 2 : p->error_indicator = 1;
23326 : 2 : p->level--;
23327 : 2 : return NULL;
23328 : : }
23329 : 0 : goto done;
23330 : : }
23331 : 13764 : 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 [ - + ]: 13764 : if (p->error_indicator) {
23337 : 0 : p->level--;
23338 : 0 : 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 [ + + ]: 13764 : if (
23344 : 13764 : (expression_var = expression_rule(p)) // expression
23345 [ + + ]: 13679 : &&
23346 : 13679 : (a = _PyPegen_expect_token(p, 11)) // token=':'
23347 [ + + ]: 3799 : &&
23348 : 3799 : _PyPegen_lookahead(1, _tmp_217_rule, p)
23349 : : )
23350 : : {
23351 : : D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')"));
23352 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" );
23353 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
23354 : 1 : p->error_indicator = 1;
23355 : 1 : p->level--;
23356 : 1 : return NULL;
23357 : : }
23358 : 0 : goto done;
23359 : : }
23360 : 13763 : 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 : 13763 : _res = NULL;
23365 : 13763 : done:
23366 : 13763 : p->level--;
23367 : 13763 : return _res;
23368 : : }
23369 : :
23370 : : // invalid_kvpair:
23371 : : // | expression !(':')
23372 : : // | expression ':' '*' bitwise_or
23373 : : // | expression ':' &('}' | ',')
23374 : : static void *
23375 : 3 : invalid_kvpair_rule(Parser *p)
23376 : : {
23377 [ - + ]: 3 : if (p->level++ == MAXSTACK) {
23378 : 0 : p->error_indicator = 1;
23379 : : PyErr_NoMemory();
23380 : : }
23381 [ - + ]: 3 : if (p->error_indicator) {
23382 : 0 : p->level--;
23383 : 0 : return NULL;
23384 : : }
23385 : 3 : void * _res = NULL;
23386 : 3 : int _mark = p->mark;
23387 : : { // expression !(':')
23388 [ - + ]: 3 : if (p->error_indicator) {
23389 : 0 : p->level--;
23390 : 0 : 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 [ + - ]: 3 : if (
23395 : 3 : (a = expression_rule(p)) // expression
23396 [ + + ]: 3 : &&
23397 : 3 : _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 : 1 : _res = RAISE_ERROR_KNOWN_LOCATION ( p , PyExc_SyntaxError , a -> lineno , a -> end_col_offset - 1 , a -> end_lineno , - 1 , "':' expected after dictionary key" );
23402 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
23403 : 1 : p->error_indicator = 1;
23404 : 1 : p->level--;
23405 : 1 : return NULL;
23406 : : }
23407 : 0 : goto done;
23408 : : }
23409 : 2 : 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 [ - + ]: 2 : if (p->error_indicator) {
23415 : 0 : p->level--;
23416 : 0 : 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 [ + - ]: 2 : if (
23424 : 2 : (expression_var = expression_rule(p)) // expression
23425 [ + - ]: 2 : &&
23426 : 2 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23427 [ + + ]: 2 : &&
23428 : 2 : (a = _PyPegen_expect_token(p, 16)) // token='*'
23429 [ + - ]: 1 : &&
23430 : 1 : (bitwise_or_var = bitwise_or_rule(p)) // 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 : 1 : _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" );
23435 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
23436 : 1 : p->error_indicator = 1;
23437 : 1 : p->level--;
23438 : 1 : return NULL;
23439 : : }
23440 : 0 : goto done;
23441 : : }
23442 : 1 : 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 [ - + ]: 1 : if (p->error_indicator) {
23448 : 0 : p->level--;
23449 : 0 : 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 [ + - ]: 1 : if (
23455 : 1 : (expression_var = expression_rule(p)) // expression
23456 [ + - ]: 1 : &&
23457 : 1 : (a = _PyPegen_expect_token(p, 11)) // token=':'
23458 [ + - ]: 1 : &&
23459 : 1 : _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 : 1 : _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" );
23464 [ + - + - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
23465 : 1 : p->error_indicator = 1;
23466 : 1 : p->level--;
23467 : 1 : return NULL;
23468 : : }
23469 : 0 : goto done;
23470 : : }
23471 : 0 : 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 : 0 : _res = NULL;
23476 : 0 : done:
23477 : 0 : p->level--;
23478 : 0 : return _res;
23479 : : }
23480 : :
23481 : : // _loop0_1: NEWLINE
23482 : : static asdl_seq *
23483 : 72068 : _loop0_1_rule(Parser *p)
23484 : : {
23485 [ - + ]: 72068 : if (p->level++ == MAXSTACK) {
23486 : 0 : p->error_indicator = 1;
23487 : : PyErr_NoMemory();
23488 : : }
23489 [ - + ]: 72068 : if (p->error_indicator) {
23490 : 0 : p->level--;
23491 : 0 : return NULL;
23492 : : }
23493 : 72068 : void *_res = NULL;
23494 : 72068 : int _mark = p->mark;
23495 : 72068 : int _start_mark = p->mark;
23496 : 72068 : void **_children = PyMem_Malloc(sizeof(void *));
23497 [ - + ]: 72068 : if (!_children) {
23498 : 0 : p->error_indicator = 1;
23499 : : PyErr_NoMemory();
23500 : 0 : p->level--;
23501 : 0 : return NULL;
23502 : : }
23503 : 72068 : Py_ssize_t _children_capacity = 1;
23504 : 72068 : Py_ssize_t _n = 0;
23505 : : { // NEWLINE
23506 [ - + ]: 72068 : if (p->error_indicator) {
23507 : 0 : p->level--;
23508 : 0 : 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 : 72068 : while (
23513 [ + + ]: 72084 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23514 : : )
23515 : : {
23516 : 16 : _res = newline_var;
23517 [ - + ]: 16 : if (_n == _children_capacity) {
23518 : 0 : _children_capacity *= 2;
23519 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
23520 [ # # ]: 0 : if (!_new_children) {
23521 : 0 : p->error_indicator = 1;
23522 : : PyErr_NoMemory();
23523 : 0 : p->level--;
23524 : 0 : return NULL;
23525 : : }
23526 : 0 : _children = _new_children;
23527 : : }
23528 : 16 : _children[_n++] = _res;
23529 : 16 : _mark = p->mark;
23530 : : }
23531 : 72068 : 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 : 72068 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
23536 [ - + ]: 72068 : if (!_seq) {
23537 : 0 : PyMem_Free(_children);
23538 : 0 : p->error_indicator = 1;
23539 : : PyErr_NoMemory();
23540 : 0 : p->level--;
23541 : 0 : return NULL;
23542 : : }
23543 [ + + ]: 72084 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
23544 : 72068 : PyMem_Free(_children);
23545 : 72068 : _PyPegen_insert_memo(p, _start_mark, _loop0_1_type, _seq);
23546 : 72068 : p->level--;
23547 : 72068 : return _seq;
23548 : : }
23549 : :
23550 : : // _loop0_2: NEWLINE
23551 : : static asdl_seq *
23552 : 12 : _loop0_2_rule(Parser *p)
23553 : : {
23554 [ - + ]: 12 : if (p->level++ == MAXSTACK) {
23555 : 0 : p->error_indicator = 1;
23556 : : PyErr_NoMemory();
23557 : : }
23558 [ - + ]: 12 : if (p->error_indicator) {
23559 : 0 : p->level--;
23560 : 0 : return NULL;
23561 : : }
23562 : 12 : void *_res = NULL;
23563 : 12 : int _mark = p->mark;
23564 : 12 : int _start_mark = p->mark;
23565 : 12 : void **_children = PyMem_Malloc(sizeof(void *));
23566 [ - + ]: 12 : if (!_children) {
23567 : 0 : p->error_indicator = 1;
23568 : : PyErr_NoMemory();
23569 : 0 : p->level--;
23570 : 0 : return NULL;
23571 : : }
23572 : 12 : Py_ssize_t _children_capacity = 1;
23573 : 12 : Py_ssize_t _n = 0;
23574 : : { // NEWLINE
23575 [ - + ]: 12 : if (p->error_indicator) {
23576 : 0 : p->level--;
23577 : 0 : 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 : 12 : while (
23582 [ - + ]: 12 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23583 : : )
23584 : : {
23585 : 0 : _res = newline_var;
23586 [ # # ]: 0 : if (_n == _children_capacity) {
23587 : 0 : _children_capacity *= 2;
23588 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
23589 [ # # ]: 0 : if (!_new_children) {
23590 : 0 : p->error_indicator = 1;
23591 : : PyErr_NoMemory();
23592 : 0 : p->level--;
23593 : 0 : return NULL;
23594 : : }
23595 : 0 : _children = _new_children;
23596 : : }
23597 : 0 : _children[_n++] = _res;
23598 : 0 : _mark = p->mark;
23599 : : }
23600 : 12 : 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 : 12 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
23605 [ - + ]: 12 : if (!_seq) {
23606 : 0 : PyMem_Free(_children);
23607 : 0 : p->error_indicator = 1;
23608 : : PyErr_NoMemory();
23609 : 0 : p->level--;
23610 : 0 : return NULL;
23611 : : }
23612 [ - + ]: 12 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
23613 : 12 : PyMem_Free(_children);
23614 : 12 : _PyPegen_insert_memo(p, _start_mark, _loop0_2_type, _seq);
23615 : 12 : p->level--;
23616 : 12 : return _seq;
23617 : : }
23618 : :
23619 : : // _loop1_3: statement
23620 : : static asdl_seq *
23621 : 1038152 : _loop1_3_rule(Parser *p)
23622 : : {
23623 [ - + ]: 1038152 : if (p->level++ == MAXSTACK) {
23624 : 0 : p->error_indicator = 1;
23625 : : PyErr_NoMemory();
23626 : : }
23627 [ - + ]: 1038152 : if (p->error_indicator) {
23628 : 0 : p->level--;
23629 : 0 : return NULL;
23630 : : }
23631 : 1038152 : void *_res = NULL;
23632 : 1038152 : int _mark = p->mark;
23633 : 1038152 : int _start_mark = p->mark;
23634 : 1038152 : void **_children = PyMem_Malloc(sizeof(void *));
23635 [ - + ]: 1038152 : if (!_children) {
23636 : 0 : p->error_indicator = 1;
23637 : : PyErr_NoMemory();
23638 : 0 : p->level--;
23639 : 0 : return NULL;
23640 : : }
23641 : 1038152 : Py_ssize_t _children_capacity = 1;
23642 : 1038152 : Py_ssize_t _n = 0;
23643 : : { // statement
23644 [ - + ]: 1038152 : if (p->error_indicator) {
23645 : 0 : p->level--;
23646 : 0 : 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 : 1038152 : while (
23651 [ + + ]: 4032083 : (statement_var = statement_rule(p)) // statement
23652 : : )
23653 : : {
23654 : 2993931 : _res = statement_var;
23655 [ + + ]: 2993931 : if (_n == _children_capacity) {
23656 : 913971 : _children_capacity *= 2;
23657 : 913971 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
23658 [ - + ]: 913971 : if (!_new_children) {
23659 : 0 : p->error_indicator = 1;
23660 : : PyErr_NoMemory();
23661 : 0 : p->level--;
23662 : 0 : return NULL;
23663 : : }
23664 : 913971 : _children = _new_children;
23665 : : }
23666 : 2993931 : _children[_n++] = _res;
23667 : 2993931 : _mark = p->mark;
23668 : : }
23669 : 1038152 : 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 [ + + + + ]: 1038152 : if (_n == 0 || p->error_indicator) {
23674 : 1981 : PyMem_Free(_children);
23675 : 1981 : p->level--;
23676 : 1981 : return NULL;
23677 : : }
23678 : 1036171 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
23679 [ - + ]: 1036171 : if (!_seq) {
23680 : 0 : PyMem_Free(_children);
23681 : 0 : p->error_indicator = 1;
23682 : : PyErr_NoMemory();
23683 : 0 : p->level--;
23684 : 0 : return NULL;
23685 : : }
23686 [ + + ]: 4030064 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
23687 : 1036171 : PyMem_Free(_children);
23688 : 1036171 : _PyPegen_insert_memo(p, _start_mark, _loop1_3_type, _seq);
23689 : 1036171 : p->level--;
23690 : 1036171 : return _seq;
23691 : : }
23692 : :
23693 : : // _loop0_5: ';' simple_stmt
23694 : : static asdl_seq *
23695 : 2724 : _loop0_5_rule(Parser *p)
23696 : : {
23697 [ - + ]: 2724 : if (p->level++ == MAXSTACK) {
23698 : 0 : p->error_indicator = 1;
23699 : : PyErr_NoMemory();
23700 : : }
23701 [ - + ]: 2724 : if (p->error_indicator) {
23702 : 0 : p->level--;
23703 : 0 : return NULL;
23704 : : }
23705 : 2724 : void *_res = NULL;
23706 : 2724 : int _mark = p->mark;
23707 : 2724 : int _start_mark = p->mark;
23708 : 2724 : void **_children = PyMem_Malloc(sizeof(void *));
23709 [ - + ]: 2724 : if (!_children) {
23710 : 0 : p->error_indicator = 1;
23711 : : PyErr_NoMemory();
23712 : 0 : p->level--;
23713 : 0 : return NULL;
23714 : : }
23715 : 2724 : Py_ssize_t _children_capacity = 1;
23716 : 2724 : Py_ssize_t _n = 0;
23717 : : { // ';' simple_stmt
23718 [ - + ]: 2724 : if (p->error_indicator) {
23719 : 0 : p->level--;
23720 : 0 : 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 : 2724 : while (
23726 : 10365 : (_literal = _PyPegen_expect_token(p, 13)) // token=';'
23727 [ + + + + ]: 18151 : &&
23728 : 7786 : (elem = simple_stmt_rule(p)) // simple_stmt
23729 : : )
23730 : : {
23731 : 7641 : _res = elem;
23732 [ - + - - ]: 7641 : if (_res == NULL && PyErr_Occurred()) {
23733 : 0 : p->error_indicator = 1;
23734 : 0 : PyMem_Free(_children);
23735 : 0 : p->level--;
23736 : 0 : return NULL;
23737 : : }
23738 [ + + ]: 7641 : if (_n == _children_capacity) {
23739 : 1026 : _children_capacity *= 2;
23740 : 1026 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
23741 [ - + ]: 1026 : if (!_new_children) {
23742 : 0 : p->error_indicator = 1;
23743 : : PyErr_NoMemory();
23744 : 0 : p->level--;
23745 : 0 : return NULL;
23746 : : }
23747 : 1026 : _children = _new_children;
23748 : : }
23749 : 7641 : _children[_n++] = _res;
23750 : 7641 : _mark = p->mark;
23751 : : }
23752 : 2724 : 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 : 2724 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
23757 [ - + ]: 2724 : if (!_seq) {
23758 : 0 : PyMem_Free(_children);
23759 : 0 : p->error_indicator = 1;
23760 : : PyErr_NoMemory();
23761 : 0 : p->level--;
23762 : 0 : return NULL;
23763 : : }
23764 [ + + ]: 10365 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
23765 : 2724 : PyMem_Free(_children);
23766 : 2724 : _PyPegen_insert_memo(p, _start_mark, _loop0_5_type, _seq);
23767 : 2724 : p->level--;
23768 : 2724 : return _seq;
23769 : : }
23770 : :
23771 : : // _gather_4: simple_stmt _loop0_5
23772 : : static asdl_seq *
23773 : 1040748 : _gather_4_rule(Parser *p)
23774 : : {
23775 [ - + ]: 1040748 : if (p->level++ == MAXSTACK) {
23776 : 0 : p->error_indicator = 1;
23777 : : PyErr_NoMemory();
23778 : : }
23779 [ - + ]: 1040748 : if (p->error_indicator) {
23780 : 0 : p->level--;
23781 : 0 : return NULL;
23782 : : }
23783 : 1040748 : asdl_seq * _res = NULL;
23784 : 1040748 : int _mark = p->mark;
23785 : : { // simple_stmt _loop0_5
23786 [ - + ]: 1040748 : if (p->error_indicator) {
23787 : 0 : p->level--;
23788 : 0 : 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 [ + + ]: 1040748 : if (
23794 : 1040748 : (elem = simple_stmt_rule(p)) // simple_stmt
23795 [ + - ]: 2724 : &&
23796 : 2724 : (seq = _loop0_5_rule(p)) // _loop0_5
23797 : : )
23798 : : {
23799 : : D(fprintf(stderr, "%*c+ _gather_4[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt _loop0_5"));
23800 : 2724 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
23801 : 2724 : goto done;
23802 : : }
23803 : 1038024 : 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 : 1038024 : _res = NULL;
23808 : 1040748 : done:
23809 : 1040748 : p->level--;
23810 : 1040748 : return _res;
23811 : : }
23812 : :
23813 : : // _tmp_6: 'import' | 'from'
23814 : : static void *
23815 : 1271877 : _tmp_6_rule(Parser *p)
23816 : : {
23817 [ - + ]: 1271877 : if (p->level++ == MAXSTACK) {
23818 : 0 : p->error_indicator = 1;
23819 : : PyErr_NoMemory();
23820 : : }
23821 [ - + ]: 1271877 : if (p->error_indicator) {
23822 : 0 : p->level--;
23823 : 0 : return NULL;
23824 : : }
23825 : 1271877 : void * _res = NULL;
23826 : 1271877 : int _mark = p->mark;
23827 : : { // 'import'
23828 [ - + ]: 1271877 : if (p->error_indicator) {
23829 : 0 : p->level--;
23830 : 0 : return NULL;
23831 : : }
23832 : : D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'"));
23833 : : Token * _keyword;
23834 [ + + ]: 1271877 : if (
23835 : 1271877 : (_keyword = _PyPegen_expect_token(p, 531)) // token='import'
23836 : : )
23837 : : {
23838 : : D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'"));
23839 : 44837 : _res = _keyword;
23840 : 44837 : goto done;
23841 : : }
23842 : 1227040 : 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 [ - + ]: 1227040 : if (p->error_indicator) {
23848 : 0 : p->level--;
23849 : 0 : return NULL;
23850 : : }
23851 : : D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'"));
23852 : : Token * _keyword;
23853 [ + + ]: 1227040 : if (
23854 : 1227040 : (_keyword = _PyPegen_expect_token(p, 572)) // token='from'
23855 : : )
23856 : : {
23857 : : D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'"));
23858 : 45790 : _res = _keyword;
23859 : 45790 : goto done;
23860 : : }
23861 : 1181250 : 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 : 1181250 : _res = NULL;
23866 : 1271877 : done:
23867 : 1271877 : p->level--;
23868 : 1271877 : return _res;
23869 : : }
23870 : :
23871 : : // _tmp_7: 'def' | '@' | ASYNC
23872 : : static void *
23873 : 4037143 : _tmp_7_rule(Parser *p)
23874 : : {
23875 [ - + ]: 4037143 : if (p->level++ == MAXSTACK) {
23876 : 0 : p->error_indicator = 1;
23877 : : PyErr_NoMemory();
23878 : : }
23879 [ - + ]: 4037143 : if (p->error_indicator) {
23880 : 0 : p->level--;
23881 : 0 : return NULL;
23882 : : }
23883 : 4037143 : void * _res = NULL;
23884 : 4037143 : int _mark = p->mark;
23885 : : { // 'def'
23886 [ - + ]: 4037143 : if (p->error_indicator) {
23887 : 0 : p->level--;
23888 : 0 : return NULL;
23889 : : }
23890 : : D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'"));
23891 : : Token * _keyword;
23892 [ + + ]: 4037143 : if (
23893 : 4037143 : (_keyword = _PyPegen_expect_token(p, 644)) // token='def'
23894 : : )
23895 : : {
23896 : : D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'"));
23897 : 306462 : _res = _keyword;
23898 : 306462 : goto done;
23899 : : }
23900 : 3730681 : 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 [ + + ]: 3730681 : if (p->error_indicator) {
23906 : 78 : p->level--;
23907 : 78 : return NULL;
23908 : : }
23909 : : D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
23910 : : Token * _literal;
23911 [ + + ]: 3730603 : if (
23912 : 3730603 : (_literal = _PyPegen_expect_token(p, 49)) // token='@'
23913 : : )
23914 : : {
23915 : : D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
23916 : 34183 : _res = _literal;
23917 : 34183 : goto done;
23918 : : }
23919 : 3696420 : 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 [ - + ]: 3696420 : if (p->error_indicator) {
23925 : 0 : p->level--;
23926 : 0 : 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 [ + + ]: 3696420 : if (
23931 : 3696420 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
23932 : : )
23933 : : {
23934 : : D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));
23935 : 3714 : _res = async_var;
23936 : 3714 : goto done;
23937 : : }
23938 : 3692706 : 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 : 3692706 : _res = NULL;
23943 : 4037065 : done:
23944 : 4037065 : p->level--;
23945 : 4037065 : return _res;
23946 : : }
23947 : :
23948 : : // _tmp_8: 'class' | '@'
23949 : : static void *
23950 : 3209662 : _tmp_8_rule(Parser *p)
23951 : : {
23952 [ - + ]: 3209662 : if (p->level++ == MAXSTACK) {
23953 : 0 : p->error_indicator = 1;
23954 : : PyErr_NoMemory();
23955 : : }
23956 [ - + ]: 3209662 : if (p->error_indicator) {
23957 : 0 : p->level--;
23958 : 0 : return NULL;
23959 : : }
23960 : 3209662 : void * _res = NULL;
23961 : 3209662 : int _mark = p->mark;
23962 : : { // 'class'
23963 [ - + ]: 3209662 : if (p->error_indicator) {
23964 : 0 : p->level--;
23965 : 0 : return NULL;
23966 : : }
23967 : : D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'"));
23968 : : Token * _keyword;
23969 [ + + ]: 3209662 : if (
23970 : 3209662 : (_keyword = _PyPegen_expect_token(p, 646)) // token='class'
23971 : : )
23972 : : {
23973 : : D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'"));
23974 : 53300 : _res = _keyword;
23975 : 53300 : goto done;
23976 : : }
23977 : 3156362 : 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 [ - + ]: 3156362 : if (p->error_indicator) {
23983 : 0 : p->level--;
23984 : 0 : return NULL;
23985 : : }
23986 : : D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
23987 : : Token * _literal;
23988 [ + + ]: 3156362 : if (
23989 : 3156362 : (_literal = _PyPegen_expect_token(p, 49)) // token='@'
23990 : : )
23991 : : {
23992 : : D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
23993 : 3190 : _res = _literal;
23994 : 3190 : goto done;
23995 : : }
23996 : 3153172 : 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 : 3153172 : _res = NULL;
24001 : 3209662 : done:
24002 : 3209662 : p->level--;
24003 : 3209662 : return _res;
24004 : : }
24005 : :
24006 : : // _tmp_9: 'with' | ASYNC
24007 : : static void *
24008 : 3153205 : _tmp_9_rule(Parser *p)
24009 : : {
24010 [ - + ]: 3153205 : if (p->level++ == MAXSTACK) {
24011 : 0 : p->error_indicator = 1;
24012 : : PyErr_NoMemory();
24013 : : }
24014 [ - + ]: 3153205 : if (p->error_indicator) {
24015 : 0 : p->level--;
24016 : 0 : return NULL;
24017 : : }
24018 : 3153205 : void * _res = NULL;
24019 : 3153205 : int _mark = p->mark;
24020 : : { // 'with'
24021 [ - + ]: 3153205 : if (p->error_indicator) {
24022 : 0 : p->level--;
24023 : 0 : return NULL;
24024 : : }
24025 : : D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'"));
24026 : : Token * _keyword;
24027 [ + + ]: 3153205 : if (
24028 : 3153205 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
24029 : : )
24030 : : {
24031 : : D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'"));
24032 : 38632 : _res = _keyword;
24033 : 38632 : goto done;
24034 : : }
24035 : 3114573 : 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 [ - + ]: 3114573 : if (p->error_indicator) {
24041 : 0 : p->level--;
24042 : 0 : 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 [ + + ]: 3114573 : if (
24047 : 3114573 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
24048 : : )
24049 : : {
24050 : : D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));
24051 : 650 : _res = async_var;
24052 : 650 : goto done;
24053 : : }
24054 : 3113923 : 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 : 3113923 : _res = NULL;
24059 : 3153205 : done:
24060 : 3153205 : p->level--;
24061 : 3153205 : return _res;
24062 : : }
24063 : :
24064 : : // _tmp_10: 'for' | ASYNC
24065 : : static void *
24066 : 3114231 : _tmp_10_rule(Parser *p)
24067 : : {
24068 [ - + ]: 3114231 : if (p->level++ == MAXSTACK) {
24069 : 0 : p->error_indicator = 1;
24070 : : PyErr_NoMemory();
24071 : : }
24072 [ - + ]: 3114231 : if (p->error_indicator) {
24073 : 0 : p->level--;
24074 : 0 : return NULL;
24075 : : }
24076 : 3114231 : void * _res = NULL;
24077 : 3114231 : int _mark = p->mark;
24078 : : { // 'for'
24079 [ - + ]: 3114231 : if (p->error_indicator) {
24080 : 0 : p->level--;
24081 : 0 : return NULL;
24082 : : }
24083 : : D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'"));
24084 : : Token * _keyword;
24085 [ + + ]: 3114231 : if (
24086 : 3114231 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
24087 : : )
24088 : : {
24089 : : D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'"));
24090 : 61088 : _res = _keyword;
24091 : 61088 : goto done;
24092 : : }
24093 : 3053143 : 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 [ - + ]: 3053143 : if (p->error_indicator) {
24099 : 0 : p->level--;
24100 : 0 : 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 [ + + ]: 3053143 : if (
24105 : 3053143 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
24106 : : )
24107 : : {
24108 : : D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));
24109 : 276 : _res = async_var;
24110 : 276 : goto done;
24111 : : }
24112 : 3052867 : 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 : 3052867 : _res = NULL;
24117 : 3114231 : done:
24118 : 3114231 : p->level--;
24119 : 3114231 : return _res;
24120 : : }
24121 : :
24122 : : // _tmp_11: '=' annotated_rhs
24123 : : static void *
24124 : 9486 : _tmp_11_rule(Parser *p)
24125 : : {
24126 [ - + ]: 9486 : if (p->level++ == MAXSTACK) {
24127 : 0 : p->error_indicator = 1;
24128 : : PyErr_NoMemory();
24129 : : }
24130 [ - + ]: 9486 : if (p->error_indicator) {
24131 : 0 : p->level--;
24132 : 0 : return NULL;
24133 : : }
24134 : 9486 : void * _res = NULL;
24135 : 9486 : int _mark = p->mark;
24136 : : { // '=' annotated_rhs
24137 [ - + ]: 9486 : if (p->error_indicator) {
24138 : 0 : p->level--;
24139 : 0 : 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 [ + + ]: 9486 : if (
24145 : 9486 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
24146 [ + - ]: 6018 : &&
24147 : 6018 : (d = annotated_rhs_rule(p)) // annotated_rhs
24148 : : )
24149 : : {
24150 : : D(fprintf(stderr, "%*c+ _tmp_11[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
24151 : 6018 : _res = d;
24152 [ - + - - ]: 6018 : if (_res == NULL && PyErr_Occurred()) {
24153 : 0 : p->error_indicator = 1;
24154 : 0 : p->level--;
24155 : 0 : return NULL;
24156 : : }
24157 : 6018 : goto done;
24158 : : }
24159 : 3468 : 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 : 3468 : _res = NULL;
24164 : 9486 : done:
24165 : 9486 : p->level--;
24166 : 9486 : return _res;
24167 : : }
24168 : :
24169 : : // _tmp_12: '(' single_target ')' | single_subscript_attribute_target
24170 : : static void *
24171 : 3201373 : _tmp_12_rule(Parser *p)
24172 : : {
24173 [ - + ]: 3201373 : if (p->level++ == MAXSTACK) {
24174 : 0 : p->error_indicator = 1;
24175 : : PyErr_NoMemory();
24176 : : }
24177 [ - + ]: 3201373 : if (p->error_indicator) {
24178 : 0 : p->level--;
24179 : 0 : return NULL;
24180 : : }
24181 : 3201373 : void * _res = NULL;
24182 : 3201373 : int _mark = p->mark;
24183 : : { // '(' single_target ')'
24184 [ - + ]: 3201373 : if (p->error_indicator) {
24185 : 0 : p->level--;
24186 : 0 : 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 [ + + ]: 3201373 : if (
24193 : 3201373 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
24194 [ + + ]: 2066 : &&
24195 : 2066 : (b = single_target_rule(p)) // single_target
24196 [ + + ]: 1877 : &&
24197 : 1877 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
24198 : : )
24199 : : {
24200 : : D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
24201 : 27 : _res = b;
24202 [ - + - - ]: 27 : if (_res == NULL && PyErr_Occurred()) {
24203 : 0 : p->error_indicator = 1;
24204 : 0 : p->level--;
24205 : 0 : return NULL;
24206 : : }
24207 : 27 : goto done;
24208 : : }
24209 : 3201346 : 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 [ + + ]: 3201346 : if (p->error_indicator) {
24215 : 8 : p->level--;
24216 : 8 : 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 [ + + ]: 3201338 : if (
24221 : 3201338 : (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target
24222 : : )
24223 : : {
24224 : : D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
24225 : 178203 : _res = single_subscript_attribute_target_var;
24226 : 178203 : goto done;
24227 : : }
24228 : 3023135 : 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 : 3023135 : _res = NULL;
24233 : 3201365 : done:
24234 : 3201365 : p->level--;
24235 : 3201365 : return _res;
24236 : : }
24237 : :
24238 : : // _tmp_13: '=' annotated_rhs
24239 : : static void *
24240 : 1969 : _tmp_13_rule(Parser *p)
24241 : : {
24242 [ - + ]: 1969 : if (p->level++ == MAXSTACK) {
24243 : 0 : p->error_indicator = 1;
24244 : : PyErr_NoMemory();
24245 : : }
24246 [ - + ]: 1969 : if (p->error_indicator) {
24247 : 0 : p->level--;
24248 : 0 : return NULL;
24249 : : }
24250 : 1969 : void * _res = NULL;
24251 : 1969 : int _mark = p->mark;
24252 : : { // '=' annotated_rhs
24253 [ - + ]: 1969 : if (p->error_indicator) {
24254 : 0 : p->level--;
24255 : 0 : 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 [ + + ]: 1969 : if (
24261 : 1969 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
24262 [ + - ]: 1586 : &&
24263 : 1586 : (d = annotated_rhs_rule(p)) // annotated_rhs
24264 : : )
24265 : : {
24266 : : D(fprintf(stderr, "%*c+ _tmp_13[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
24267 : 1586 : _res = d;
24268 [ - + - - ]: 1586 : if (_res == NULL && PyErr_Occurred()) {
24269 : 0 : p->error_indicator = 1;
24270 : 0 : p->level--;
24271 : 0 : return NULL;
24272 : : }
24273 : 1586 : goto done;
24274 : : }
24275 : 383 : 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 : 383 : _res = NULL;
24280 : 1969 : done:
24281 : 1969 : p->level--;
24282 : 1969 : return _res;
24283 : : }
24284 : :
24285 : : // _loop1_14: (star_targets '=')
24286 : : static asdl_seq *
24287 : 3199180 : _loop1_14_rule(Parser *p)
24288 : : {
24289 [ - + ]: 3199180 : if (p->level++ == MAXSTACK) {
24290 : 0 : p->error_indicator = 1;
24291 : : PyErr_NoMemory();
24292 : : }
24293 [ - + ]: 3199180 : if (p->error_indicator) {
24294 : 0 : p->level--;
24295 : 0 : return NULL;
24296 : : }
24297 : 3199180 : void *_res = NULL;
24298 : 3199180 : int _mark = p->mark;
24299 : 3199180 : int _start_mark = p->mark;
24300 : 3199180 : void **_children = PyMem_Malloc(sizeof(void *));
24301 [ - + ]: 3199180 : if (!_children) {
24302 : 0 : p->error_indicator = 1;
24303 : : PyErr_NoMemory();
24304 : 0 : p->level--;
24305 : 0 : return NULL;
24306 : : }
24307 : 3199180 : Py_ssize_t _children_capacity = 1;
24308 : 3199180 : Py_ssize_t _n = 0;
24309 : : { // (star_targets '=')
24310 [ - + ]: 3199180 : if (p->error_indicator) {
24311 : 0 : p->level--;
24312 : 0 : 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 : 3199180 : while (
24317 [ + + ]: 4011463 : (_tmp_219_var = _tmp_219_rule(p)) // star_targets '='
24318 : : )
24319 : : {
24320 : 812283 : _res = _tmp_219_var;
24321 [ + + ]: 812283 : if (_n == _children_capacity) {
24322 : 6420 : _children_capacity *= 2;
24323 : 6420 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
24324 [ - + ]: 6420 : if (!_new_children) {
24325 : 0 : p->error_indicator = 1;
24326 : : PyErr_NoMemory();
24327 : 0 : p->level--;
24328 : 0 : return NULL;
24329 : : }
24330 : 6420 : _children = _new_children;
24331 : : }
24332 : 812283 : _children[_n++] = _res;
24333 : 812283 : _mark = p->mark;
24334 : : }
24335 : 3199180 : 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 [ + + + + ]: 3199180 : if (_n == 0 || p->error_indicator) {
24340 : 2396007 : PyMem_Free(_children);
24341 : 2396007 : p->level--;
24342 : 2396007 : return NULL;
24343 : : }
24344 : 803173 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24345 [ - + ]: 803173 : if (!_seq) {
24346 : 0 : PyMem_Free(_children);
24347 : 0 : p->error_indicator = 1;
24348 : : PyErr_NoMemory();
24349 : 0 : p->level--;
24350 : 0 : return NULL;
24351 : : }
24352 [ + + ]: 1615422 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
24353 : 803173 : PyMem_Free(_children);
24354 : 803173 : _PyPegen_insert_memo(p, _start_mark, _loop1_14_type, _seq);
24355 : 803173 : p->level--;
24356 : 803173 : return _seq;
24357 : : }
24358 : :
24359 : : // _tmp_15: yield_expr | star_expressions
24360 : : static void *
24361 : 803173 : _tmp_15_rule(Parser *p)
24362 : : {
24363 [ - + ]: 803173 : if (p->level++ == MAXSTACK) {
24364 : 0 : p->error_indicator = 1;
24365 : : PyErr_NoMemory();
24366 : : }
24367 [ - + ]: 803173 : if (p->error_indicator) {
24368 : 0 : p->level--;
24369 : 0 : return NULL;
24370 : : }
24371 : 803173 : void * _res = NULL;
24372 : 803173 : int _mark = p->mark;
24373 : : { // yield_expr
24374 [ - + ]: 803173 : if (p->error_indicator) {
24375 : 0 : p->level--;
24376 : 0 : 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 [ + + ]: 803173 : if (
24381 : 803173 : (yield_expr_var = yield_expr_rule(p)) // yield_expr
24382 : : )
24383 : : {
24384 : : D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
24385 : 166 : _res = yield_expr_var;
24386 : 166 : goto done;
24387 : : }
24388 : 803007 : 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 [ - + ]: 803007 : if (p->error_indicator) {
24394 : 0 : p->level--;
24395 : 0 : 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 [ + + ]: 803007 : if (
24400 : 803007 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
24401 : : )
24402 : : {
24403 : : D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
24404 : 802991 : _res = star_expressions_var;
24405 : 802991 : goto done;
24406 : : }
24407 : 16 : 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 : 16 : _res = NULL;
24412 : 803173 : done:
24413 : 803173 : p->level--;
24414 : 803173 : return _res;
24415 : : }
24416 : :
24417 : : // _tmp_16: yield_expr | star_expressions
24418 : : static void *
24419 : 25588 : _tmp_16_rule(Parser *p)
24420 : : {
24421 [ - + ]: 25588 : if (p->level++ == MAXSTACK) {
24422 : 0 : p->error_indicator = 1;
24423 : : PyErr_NoMemory();
24424 : : }
24425 [ - + ]: 25588 : if (p->error_indicator) {
24426 : 0 : p->level--;
24427 : 0 : return NULL;
24428 : : }
24429 : 25588 : void * _res = NULL;
24430 : 25588 : int _mark = p->mark;
24431 : : { // yield_expr
24432 [ - + ]: 25588 : if (p->error_indicator) {
24433 : 0 : p->level--;
24434 : 0 : 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 [ + + ]: 25588 : if (
24439 : 25588 : (yield_expr_var = yield_expr_rule(p)) // yield_expr
24440 : : )
24441 : : {
24442 : : D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
24443 : 2 : _res = yield_expr_var;
24444 : 2 : goto done;
24445 : : }
24446 : 25586 : 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 [ - + ]: 25586 : if (p->error_indicator) {
24452 : 0 : p->level--;
24453 : 0 : 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 [ + - ]: 25586 : if (
24458 : 25586 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
24459 : : )
24460 : : {
24461 : : D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
24462 : 25586 : _res = star_expressions_var;
24463 : 25586 : goto done;
24464 : : }
24465 : 0 : 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 : 0 : _res = NULL;
24470 : 25588 : done:
24471 : 25588 : p->level--;
24472 : 25588 : return _res;
24473 : : }
24474 : :
24475 : : // _tmp_17: 'from' expression
24476 : : static void *
24477 : 56377 : _tmp_17_rule(Parser *p)
24478 : : {
24479 [ - + ]: 56377 : if (p->level++ == MAXSTACK) {
24480 : 0 : p->error_indicator = 1;
24481 : : PyErr_NoMemory();
24482 : : }
24483 [ - + ]: 56377 : if (p->error_indicator) {
24484 : 0 : p->level--;
24485 : 0 : return NULL;
24486 : : }
24487 : 56377 : void * _res = NULL;
24488 : 56377 : int _mark = p->mark;
24489 : : { // 'from' expression
24490 [ - + ]: 56377 : if (p->error_indicator) {
24491 : 0 : p->level--;
24492 : 0 : 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 [ + + ]: 56377 : if (
24498 : 56377 : (_keyword = _PyPegen_expect_token(p, 572)) // token='from'
24499 [ + - ]: 2859 : &&
24500 : 2859 : (z = expression_rule(p)) // expression
24501 : : )
24502 : : {
24503 : : D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' expression"));
24504 : 2859 : _res = z;
24505 [ - + - - ]: 2859 : if (_res == NULL && PyErr_Occurred()) {
24506 : 0 : p->error_indicator = 1;
24507 : 0 : p->level--;
24508 : 0 : return NULL;
24509 : : }
24510 : 2859 : goto done;
24511 : : }
24512 : 53518 : 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 : 53518 : _res = NULL;
24517 : 56377 : done:
24518 : 56377 : p->level--;
24519 : 56377 : return _res;
24520 : : }
24521 : :
24522 : : // _loop0_19: ',' NAME
24523 : : static asdl_seq *
24524 : 1816 : _loop0_19_rule(Parser *p)
24525 : : {
24526 [ - + ]: 1816 : if (p->level++ == MAXSTACK) {
24527 : 0 : p->error_indicator = 1;
24528 : : PyErr_NoMemory();
24529 : : }
24530 [ - + ]: 1816 : if (p->error_indicator) {
24531 : 0 : p->level--;
24532 : 0 : return NULL;
24533 : : }
24534 : 1816 : void *_res = NULL;
24535 : 1816 : int _mark = p->mark;
24536 : 1816 : int _start_mark = p->mark;
24537 : 1816 : void **_children = PyMem_Malloc(sizeof(void *));
24538 [ - + ]: 1816 : if (!_children) {
24539 : 0 : p->error_indicator = 1;
24540 : : PyErr_NoMemory();
24541 : 0 : p->level--;
24542 : 0 : return NULL;
24543 : : }
24544 : 1816 : Py_ssize_t _children_capacity = 1;
24545 : 1816 : Py_ssize_t _n = 0;
24546 : : { // ',' NAME
24547 [ - + ]: 1816 : if (p->error_indicator) {
24548 : 0 : p->level--;
24549 : 0 : 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 : 1816 : while (
24555 : 2363 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
24556 [ + + + - ]: 2910 : &&
24557 : 547 : (elem = _PyPegen_name_token(p)) // NAME
24558 : : )
24559 : : {
24560 : 547 : _res = elem;
24561 [ - + - - ]: 547 : if (_res == NULL && PyErr_Occurred()) {
24562 : 0 : p->error_indicator = 1;
24563 : 0 : PyMem_Free(_children);
24564 : 0 : p->level--;
24565 : 0 : return NULL;
24566 : : }
24567 [ + + ]: 547 : if (_n == _children_capacity) {
24568 : 129 : _children_capacity *= 2;
24569 : 129 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
24570 [ - + ]: 129 : if (!_new_children) {
24571 : 0 : p->error_indicator = 1;
24572 : : PyErr_NoMemory();
24573 : 0 : p->level--;
24574 : 0 : return NULL;
24575 : : }
24576 : 129 : _children = _new_children;
24577 : : }
24578 : 547 : _children[_n++] = _res;
24579 : 547 : _mark = p->mark;
24580 : : }
24581 : 1816 : 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 : 1816 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24586 [ - + ]: 1816 : if (!_seq) {
24587 : 0 : PyMem_Free(_children);
24588 : 0 : p->error_indicator = 1;
24589 : : PyErr_NoMemory();
24590 : 0 : p->level--;
24591 : 0 : return NULL;
24592 : : }
24593 [ + + ]: 2363 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
24594 : 1816 : PyMem_Free(_children);
24595 : 1816 : _PyPegen_insert_memo(p, _start_mark, _loop0_19_type, _seq);
24596 : 1816 : p->level--;
24597 : 1816 : return _seq;
24598 : : }
24599 : :
24600 : : // _gather_18: NAME _loop0_19
24601 : : static asdl_seq *
24602 : 1818 : _gather_18_rule(Parser *p)
24603 : : {
24604 [ - + ]: 1818 : if (p->level++ == MAXSTACK) {
24605 : 0 : p->error_indicator = 1;
24606 : : PyErr_NoMemory();
24607 : : }
24608 [ - + ]: 1818 : if (p->error_indicator) {
24609 : 0 : p->level--;
24610 : 0 : return NULL;
24611 : : }
24612 : 1818 : asdl_seq * _res = NULL;
24613 : 1818 : int _mark = p->mark;
24614 : : { // NAME _loop0_19
24615 [ - + ]: 1818 : if (p->error_indicator) {
24616 : 0 : p->level--;
24617 : 0 : 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 [ + + ]: 1818 : if (
24623 : 1818 : (elem = _PyPegen_name_token(p)) // NAME
24624 [ + - ]: 1816 : &&
24625 : 1816 : (seq = _loop0_19_rule(p)) // _loop0_19
24626 : : )
24627 : : {
24628 : : D(fprintf(stderr, "%*c+ _gather_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_19"));
24629 : 1816 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
24630 : 1816 : goto done;
24631 : : }
24632 : 2 : 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 : 2 : _res = NULL;
24637 : 1818 : done:
24638 : 1818 : p->level--;
24639 : 1818 : return _res;
24640 : : }
24641 : :
24642 : : // _loop0_21: ',' NAME
24643 : : static asdl_seq *
24644 : 928 : _loop0_21_rule(Parser *p)
24645 : : {
24646 [ - + ]: 928 : if (p->level++ == MAXSTACK) {
24647 : 0 : p->error_indicator = 1;
24648 : : PyErr_NoMemory();
24649 : : }
24650 [ - + ]: 928 : if (p->error_indicator) {
24651 : 0 : p->level--;
24652 : 0 : return NULL;
24653 : : }
24654 : 928 : void *_res = NULL;
24655 : 928 : int _mark = p->mark;
24656 : 928 : int _start_mark = p->mark;
24657 : 928 : void **_children = PyMem_Malloc(sizeof(void *));
24658 [ - + ]: 928 : if (!_children) {
24659 : 0 : p->error_indicator = 1;
24660 : : PyErr_NoMemory();
24661 : 0 : p->level--;
24662 : 0 : return NULL;
24663 : : }
24664 : 928 : Py_ssize_t _children_capacity = 1;
24665 : 928 : Py_ssize_t _n = 0;
24666 : : { // ',' NAME
24667 [ - + ]: 928 : if (p->error_indicator) {
24668 : 0 : p->level--;
24669 : 0 : 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 : 928 : while (
24675 : 1111 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
24676 [ + + + - ]: 1294 : &&
24677 : 183 : (elem = _PyPegen_name_token(p)) // NAME
24678 : : )
24679 : : {
24680 : 183 : _res = elem;
24681 [ - + - - ]: 183 : if (_res == NULL && PyErr_Occurred()) {
24682 : 0 : p->error_indicator = 1;
24683 : 0 : PyMem_Free(_children);
24684 : 0 : p->level--;
24685 : 0 : return NULL;
24686 : : }
24687 [ + + ]: 183 : if (_n == _children_capacity) {
24688 : 75 : _children_capacity *= 2;
24689 : 75 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
24690 [ - + ]: 75 : if (!_new_children) {
24691 : 0 : p->error_indicator = 1;
24692 : : PyErr_NoMemory();
24693 : 0 : p->level--;
24694 : 0 : return NULL;
24695 : : }
24696 : 75 : _children = _new_children;
24697 : : }
24698 : 183 : _children[_n++] = _res;
24699 : 183 : _mark = p->mark;
24700 : : }
24701 : 928 : 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 : 928 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24706 [ - + ]: 928 : if (!_seq) {
24707 : 0 : PyMem_Free(_children);
24708 : 0 : p->error_indicator = 1;
24709 : : PyErr_NoMemory();
24710 : 0 : p->level--;
24711 : 0 : return NULL;
24712 : : }
24713 [ + + ]: 1111 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
24714 : 928 : PyMem_Free(_children);
24715 : 928 : _PyPegen_insert_memo(p, _start_mark, _loop0_21_type, _seq);
24716 : 928 : p->level--;
24717 : 928 : return _seq;
24718 : : }
24719 : :
24720 : : // _gather_20: NAME _loop0_21
24721 : : static asdl_seq *
24722 : 930 : _gather_20_rule(Parser *p)
24723 : : {
24724 [ - + ]: 930 : if (p->level++ == MAXSTACK) {
24725 : 0 : p->error_indicator = 1;
24726 : : PyErr_NoMemory();
24727 : : }
24728 [ - + ]: 930 : if (p->error_indicator) {
24729 : 0 : p->level--;
24730 : 0 : return NULL;
24731 : : }
24732 : 930 : asdl_seq * _res = NULL;
24733 : 930 : int _mark = p->mark;
24734 : : { // NAME _loop0_21
24735 [ - + ]: 930 : if (p->error_indicator) {
24736 : 0 : p->level--;
24737 : 0 : 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 [ + + ]: 930 : if (
24743 : 930 : (elem = _PyPegen_name_token(p)) // NAME
24744 [ + - ]: 928 : &&
24745 : 928 : (seq = _loop0_21_rule(p)) // _loop0_21
24746 : : )
24747 : : {
24748 : : D(fprintf(stderr, "%*c+ _gather_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_21"));
24749 : 928 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
24750 : 928 : goto done;
24751 : : }
24752 : 2 : 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 : 2 : _res = NULL;
24757 : 930 : done:
24758 : 930 : p->level--;
24759 : 930 : return _res;
24760 : : }
24761 : :
24762 : : // _tmp_22: ';' | NEWLINE
24763 : : static void *
24764 : 8798 : _tmp_22_rule(Parser *p)
24765 : : {
24766 [ - + ]: 8798 : if (p->level++ == MAXSTACK) {
24767 : 0 : p->error_indicator = 1;
24768 : : PyErr_NoMemory();
24769 : : }
24770 [ - + ]: 8798 : if (p->error_indicator) {
24771 : 0 : p->level--;
24772 : 0 : return NULL;
24773 : : }
24774 : 8798 : void * _res = NULL;
24775 : 8798 : int _mark = p->mark;
24776 : : { // ';'
24777 [ - + ]: 8798 : if (p->error_indicator) {
24778 : 0 : p->level--;
24779 : 0 : return NULL;
24780 : : }
24781 : : D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'"));
24782 : : Token * _literal;
24783 [ + + ]: 8798 : if (
24784 : 8798 : (_literal = _PyPegen_expect_token(p, 13)) // token=';'
24785 : : )
24786 : : {
24787 : : D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'"));
24788 : 37 : _res = _literal;
24789 : 37 : goto done;
24790 : : }
24791 : 8761 : 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 [ - + ]: 8761 : if (p->error_indicator) {
24797 : 0 : p->level--;
24798 : 0 : 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 [ + + ]: 8761 : if (
24803 : 8761 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24804 : : )
24805 : : {
24806 : : D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
24807 : 8727 : _res = newline_var;
24808 : 8727 : goto done;
24809 : : }
24810 : 34 : 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 : 34 : _res = NULL;
24815 : 8798 : done:
24816 : 8798 : p->level--;
24817 : 8798 : return _res;
24818 : : }
24819 : :
24820 : : // _tmp_23: ',' expression
24821 : : static void *
24822 : 9808 : _tmp_23_rule(Parser *p)
24823 : : {
24824 [ - + ]: 9808 : if (p->level++ == MAXSTACK) {
24825 : 0 : p->error_indicator = 1;
24826 : : PyErr_NoMemory();
24827 : : }
24828 [ - + ]: 9808 : if (p->error_indicator) {
24829 : 0 : p->level--;
24830 : 0 : return NULL;
24831 : : }
24832 : 9808 : void * _res = NULL;
24833 : 9808 : int _mark = p->mark;
24834 : : { // ',' expression
24835 [ - + ]: 9808 : if (p->error_indicator) {
24836 : 0 : p->level--;
24837 : 0 : 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 [ + + ]: 9808 : if (
24843 : 9808 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
24844 [ + - ]: 2179 : &&
24845 : 2179 : (z = expression_rule(p)) // expression
24846 : : )
24847 : : {
24848 : : D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression"));
24849 : 2179 : _res = z;
24850 [ - + - - ]: 2179 : if (_res == NULL && PyErr_Occurred()) {
24851 : 0 : p->error_indicator = 1;
24852 : 0 : p->level--;
24853 : 0 : return NULL;
24854 : : }
24855 : 2179 : goto done;
24856 : : }
24857 : 7629 : 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 : 7629 : _res = NULL;
24862 : 9808 : done:
24863 : 9808 : p->level--;
24864 : 9808 : return _res;
24865 : : }
24866 : :
24867 : : // _loop0_24: ('.' | '...')
24868 : : static asdl_seq *
24869 : 45790 : _loop0_24_rule(Parser *p)
24870 : : {
24871 [ - + ]: 45790 : if (p->level++ == MAXSTACK) {
24872 : 0 : p->error_indicator = 1;
24873 : : PyErr_NoMemory();
24874 : : }
24875 [ - + ]: 45790 : if (p->error_indicator) {
24876 : 0 : p->level--;
24877 : 0 : return NULL;
24878 : : }
24879 : 45790 : void *_res = NULL;
24880 : 45790 : int _mark = p->mark;
24881 : 45790 : int _start_mark = p->mark;
24882 : 45790 : void **_children = PyMem_Malloc(sizeof(void *));
24883 [ - + ]: 45790 : if (!_children) {
24884 : 0 : p->error_indicator = 1;
24885 : : PyErr_NoMemory();
24886 : 0 : p->level--;
24887 : 0 : return NULL;
24888 : : }
24889 : 45790 : Py_ssize_t _children_capacity = 1;
24890 : 45790 : Py_ssize_t _n = 0;
24891 : : { // ('.' | '...')
24892 [ - + ]: 45790 : if (p->error_indicator) {
24893 : 0 : p->level--;
24894 : 0 : 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 : 45790 : while (
24899 [ + + ]: 57387 : (_tmp_220_var = _tmp_220_rule(p)) // '.' | '...'
24900 : : )
24901 : : {
24902 : 11597 : _res = _tmp_220_var;
24903 [ + + ]: 11597 : if (_n == _children_capacity) {
24904 : 652 : _children_capacity *= 2;
24905 : 652 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
24906 [ - + ]: 652 : if (!_new_children) {
24907 : 0 : p->error_indicator = 1;
24908 : : PyErr_NoMemory();
24909 : 0 : p->level--;
24910 : 0 : return NULL;
24911 : : }
24912 : 652 : _children = _new_children;
24913 : : }
24914 : 11597 : _children[_n++] = _res;
24915 : 11597 : _mark = p->mark;
24916 : : }
24917 : 45790 : 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 : 45790 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24922 [ - + ]: 45790 : if (!_seq) {
24923 : 0 : PyMem_Free(_children);
24924 : 0 : p->error_indicator = 1;
24925 : : PyErr_NoMemory();
24926 : 0 : p->level--;
24927 : 0 : return NULL;
24928 : : }
24929 [ + + ]: 57387 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
24930 : 45790 : PyMem_Free(_children);
24931 : 45790 : _PyPegen_insert_memo(p, _start_mark, _loop0_24_type, _seq);
24932 : 45790 : p->level--;
24933 : 45790 : return _seq;
24934 : : }
24935 : :
24936 : : // _loop1_25: ('.' | '...')
24937 : : static asdl_seq *
24938 : 1277 : _loop1_25_rule(Parser *p)
24939 : : {
24940 [ - + ]: 1277 : if (p->level++ == MAXSTACK) {
24941 : 0 : p->error_indicator = 1;
24942 : : PyErr_NoMemory();
24943 : : }
24944 [ - + ]: 1277 : if (p->error_indicator) {
24945 : 0 : p->level--;
24946 : 0 : return NULL;
24947 : : }
24948 : 1277 : void *_res = NULL;
24949 : 1277 : int _mark = p->mark;
24950 : 1277 : int _start_mark = p->mark;
24951 : 1277 : void **_children = PyMem_Malloc(sizeof(void *));
24952 [ - + ]: 1277 : if (!_children) {
24953 : 0 : p->error_indicator = 1;
24954 : : PyErr_NoMemory();
24955 : 0 : p->level--;
24956 : 0 : return NULL;
24957 : : }
24958 : 1277 : Py_ssize_t _children_capacity = 1;
24959 : 1277 : Py_ssize_t _n = 0;
24960 : : { // ('.' | '...')
24961 [ - + ]: 1277 : if (p->error_indicator) {
24962 : 0 : p->level--;
24963 : 0 : 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 : 1277 : while (
24968 [ + + ]: 2650 : (_tmp_221_var = _tmp_221_rule(p)) // '.' | '...'
24969 : : )
24970 : : {
24971 : 1373 : _res = _tmp_221_var;
24972 [ + + ]: 1373 : if (_n == _children_capacity) {
24973 : 115 : _children_capacity *= 2;
24974 : 115 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
24975 [ - + ]: 115 : if (!_new_children) {
24976 : 0 : p->error_indicator = 1;
24977 : : PyErr_NoMemory();
24978 : 0 : p->level--;
24979 : 0 : return NULL;
24980 : : }
24981 : 115 : _children = _new_children;
24982 : : }
24983 : 1373 : _children[_n++] = _res;
24984 : 1373 : _mark = p->mark;
24985 : : }
24986 : 1277 : 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 [ + + - + ]: 1277 : if (_n == 0 || p->error_indicator) {
24991 : 19 : PyMem_Free(_children);
24992 : 19 : p->level--;
24993 : 19 : return NULL;
24994 : : }
24995 : 1258 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24996 [ - + ]: 1258 : if (!_seq) {
24997 : 0 : PyMem_Free(_children);
24998 : 0 : p->error_indicator = 1;
24999 : : PyErr_NoMemory();
25000 : 0 : p->level--;
25001 : 0 : return NULL;
25002 : : }
25003 [ + + ]: 2631 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25004 : 1258 : PyMem_Free(_children);
25005 : 1258 : _PyPegen_insert_memo(p, _start_mark, _loop1_25_type, _seq);
25006 : 1258 : p->level--;
25007 : 1258 : return _seq;
25008 : : }
25009 : :
25010 : : // _loop0_27: ',' import_from_as_name
25011 : : static asdl_seq *
25012 : 44687 : _loop0_27_rule(Parser *p)
25013 : : {
25014 [ - + ]: 44687 : if (p->level++ == MAXSTACK) {
25015 : 0 : p->error_indicator = 1;
25016 : : PyErr_NoMemory();
25017 : : }
25018 [ - + ]: 44687 : if (p->error_indicator) {
25019 : 0 : p->level--;
25020 : 0 : return NULL;
25021 : : }
25022 : 44687 : void *_res = NULL;
25023 : 44687 : int _mark = p->mark;
25024 : 44687 : int _start_mark = p->mark;
25025 : 44687 : void **_children = PyMem_Malloc(sizeof(void *));
25026 [ - + ]: 44687 : if (!_children) {
25027 : 0 : p->error_indicator = 1;
25028 : : PyErr_NoMemory();
25029 : 0 : p->level--;
25030 : 0 : return NULL;
25031 : : }
25032 : 44687 : Py_ssize_t _children_capacity = 1;
25033 : 44687 : Py_ssize_t _n = 0;
25034 : : { // ',' import_from_as_name
25035 [ - + ]: 44687 : if (p->error_indicator) {
25036 : 0 : p->level--;
25037 : 0 : 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 : 44687 : while (
25043 : 76876 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
25044 [ + + + + ]: 110445 : &&
25045 : 33569 : (elem = import_from_as_name_rule(p)) // import_from_as_name
25046 : : )
25047 : : {
25048 : 32189 : _res = elem;
25049 [ - + - - ]: 32189 : if (_res == NULL && PyErr_Occurred()) {
25050 : 0 : p->error_indicator = 1;
25051 : 0 : PyMem_Free(_children);
25052 : 0 : p->level--;
25053 : 0 : return NULL;
25054 : : }
25055 [ + + ]: 32189 : if (_n == _children_capacity) {
25056 : 12624 : _children_capacity *= 2;
25057 : 12624 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25058 [ - + ]: 12624 : if (!_new_children) {
25059 : 0 : p->error_indicator = 1;
25060 : : PyErr_NoMemory();
25061 : 0 : p->level--;
25062 : 0 : return NULL;
25063 : : }
25064 : 12624 : _children = _new_children;
25065 : : }
25066 : 32189 : _children[_n++] = _res;
25067 : 32189 : _mark = p->mark;
25068 : : }
25069 : 44687 : 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 : 44687 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25074 [ - + ]: 44687 : if (!_seq) {
25075 : 0 : PyMem_Free(_children);
25076 : 0 : p->error_indicator = 1;
25077 : : PyErr_NoMemory();
25078 : 0 : p->level--;
25079 : 0 : return NULL;
25080 : : }
25081 [ + + ]: 76876 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25082 : 44687 : PyMem_Free(_children);
25083 : 44687 : _PyPegen_insert_memo(p, _start_mark, _loop0_27_type, _seq);
25084 : 44687 : p->level--;
25085 : 44687 : return _seq;
25086 : : }
25087 : :
25088 : : // _gather_26: import_from_as_name _loop0_27
25089 : : static asdl_seq *
25090 : 45800 : _gather_26_rule(Parser *p)
25091 : : {
25092 [ - + ]: 45800 : if (p->level++ == MAXSTACK) {
25093 : 0 : p->error_indicator = 1;
25094 : : PyErr_NoMemory();
25095 : : }
25096 [ - + ]: 45800 : if (p->error_indicator) {
25097 : 0 : p->level--;
25098 : 0 : return NULL;
25099 : : }
25100 : 45800 : asdl_seq * _res = NULL;
25101 : 45800 : int _mark = p->mark;
25102 : : { // import_from_as_name _loop0_27
25103 [ - + ]: 45800 : if (p->error_indicator) {
25104 : 0 : p->level--;
25105 : 0 : 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 [ + + ]: 45800 : if (
25111 : 45800 : (elem = import_from_as_name_rule(p)) // import_from_as_name
25112 [ + - ]: 44687 : &&
25113 : 44687 : (seq = _loop0_27_rule(p)) // _loop0_27
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 : 44687 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
25118 : 44687 : goto done;
25119 : : }
25120 : 1113 : 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 : 1113 : _res = NULL;
25125 : 45800 : done:
25126 : 45800 : p->level--;
25127 : 45800 : return _res;
25128 : : }
25129 : :
25130 : : // _tmp_28: 'as' NAME
25131 : : static void *
25132 : 76884 : _tmp_28_rule(Parser *p)
25133 : : {
25134 [ - + ]: 76884 : if (p->level++ == MAXSTACK) {
25135 : 0 : p->error_indicator = 1;
25136 : : PyErr_NoMemory();
25137 : : }
25138 [ - + ]: 76884 : if (p->error_indicator) {
25139 : 0 : p->level--;
25140 : 0 : return NULL;
25141 : : }
25142 : 76884 : void * _res = NULL;
25143 : 76884 : int _mark = p->mark;
25144 : : { // 'as' NAME
25145 [ - + ]: 76884 : if (p->error_indicator) {
25146 : 0 : p->level--;
25147 : 0 : 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 [ + + ]: 76884 : if (
25153 : 76884 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
25154 [ + + ]: 3124 : &&
25155 : 3124 : (z = _PyPegen_name_token(p)) // NAME
25156 : : )
25157 : : {
25158 : : D(fprintf(stderr, "%*c+ _tmp_28[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
25159 : 3120 : _res = z;
25160 [ - + - - ]: 3120 : if (_res == NULL && PyErr_Occurred()) {
25161 : 0 : p->error_indicator = 1;
25162 : 0 : p->level--;
25163 : 0 : return NULL;
25164 : : }
25165 : 3120 : goto done;
25166 : : }
25167 : 73764 : 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 : 73764 : _res = NULL;
25172 : 76884 : done:
25173 : 76884 : p->level--;
25174 : 76884 : return _res;
25175 : : }
25176 : :
25177 : : // _loop0_30: ',' dotted_as_name
25178 : : static asdl_seq *
25179 : 44819 : _loop0_30_rule(Parser *p)
25180 : : {
25181 [ - + ]: 44819 : if (p->level++ == MAXSTACK) {
25182 : 0 : p->error_indicator = 1;
25183 : : PyErr_NoMemory();
25184 : : }
25185 [ - + ]: 44819 : if (p->error_indicator) {
25186 : 0 : p->level--;
25187 : 0 : return NULL;
25188 : : }
25189 : 44819 : void *_res = NULL;
25190 : 44819 : int _mark = p->mark;
25191 : 44819 : int _start_mark = p->mark;
25192 : 44819 : void **_children = PyMem_Malloc(sizeof(void *));
25193 [ - + ]: 44819 : if (!_children) {
25194 : 0 : p->error_indicator = 1;
25195 : : PyErr_NoMemory();
25196 : 0 : p->level--;
25197 : 0 : return NULL;
25198 : : }
25199 : 44819 : Py_ssize_t _children_capacity = 1;
25200 : 44819 : Py_ssize_t _n = 0;
25201 : : { // ',' dotted_as_name
25202 [ - + ]: 44819 : if (p->error_indicator) {
25203 : 0 : p->level--;
25204 : 0 : 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 : 44819 : while (
25210 : 46076 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
25211 [ + + + - ]: 47333 : &&
25212 : 1257 : (elem = dotted_as_name_rule(p)) // dotted_as_name
25213 : : )
25214 : : {
25215 : 1257 : _res = elem;
25216 [ - + - - ]: 1257 : if (_res == NULL && PyErr_Occurred()) {
25217 : 0 : p->error_indicator = 1;
25218 : 0 : PyMem_Free(_children);
25219 : 0 : p->level--;
25220 : 0 : return NULL;
25221 : : }
25222 [ + + ]: 1257 : if (_n == _children_capacity) {
25223 : 283 : _children_capacity *= 2;
25224 : 283 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25225 [ - + ]: 283 : if (!_new_children) {
25226 : 0 : p->error_indicator = 1;
25227 : : PyErr_NoMemory();
25228 : 0 : p->level--;
25229 : 0 : return NULL;
25230 : : }
25231 : 283 : _children = _new_children;
25232 : : }
25233 : 1257 : _children[_n++] = _res;
25234 : 1257 : _mark = p->mark;
25235 : : }
25236 : 44819 : 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 : 44819 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25241 [ - + ]: 44819 : if (!_seq) {
25242 : 0 : PyMem_Free(_children);
25243 : 0 : p->error_indicator = 1;
25244 : : PyErr_NoMemory();
25245 : 0 : p->level--;
25246 : 0 : return NULL;
25247 : : }
25248 [ + + ]: 46076 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25249 : 44819 : PyMem_Free(_children);
25250 : 44819 : _PyPegen_insert_memo(p, _start_mark, _loop0_30_type, _seq);
25251 : 44819 : p->level--;
25252 : 44819 : return _seq;
25253 : : }
25254 : :
25255 : : // _gather_29: dotted_as_name _loop0_30
25256 : : static asdl_seq *
25257 : 44837 : _gather_29_rule(Parser *p)
25258 : : {
25259 [ - + ]: 44837 : if (p->level++ == MAXSTACK) {
25260 : 0 : p->error_indicator = 1;
25261 : : PyErr_NoMemory();
25262 : : }
25263 [ - + ]: 44837 : if (p->error_indicator) {
25264 : 0 : p->level--;
25265 : 0 : return NULL;
25266 : : }
25267 : 44837 : asdl_seq * _res = NULL;
25268 : 44837 : int _mark = p->mark;
25269 : : { // dotted_as_name _loop0_30
25270 [ - + ]: 44837 : if (p->error_indicator) {
25271 : 0 : p->level--;
25272 : 0 : 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 [ + + ]: 44837 : if (
25278 : 44837 : (elem = dotted_as_name_rule(p)) // dotted_as_name
25279 [ + - ]: 44819 : &&
25280 : 44819 : (seq = _loop0_30_rule(p)) // _loop0_30
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 : 44819 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
25285 : 44819 : goto done;
25286 : : }
25287 : 18 : 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 : 18 : _res = NULL;
25292 : 44837 : done:
25293 : 44837 : p->level--;
25294 : 44837 : return _res;
25295 : : }
25296 : :
25297 : : // _tmp_31: 'as' NAME
25298 : : static void *
25299 : 46076 : _tmp_31_rule(Parser *p)
25300 : : {
25301 [ - + ]: 46076 : if (p->level++ == MAXSTACK) {
25302 : 0 : p->error_indicator = 1;
25303 : : PyErr_NoMemory();
25304 : : }
25305 [ - + ]: 46076 : if (p->error_indicator) {
25306 : 0 : p->level--;
25307 : 0 : return NULL;
25308 : : }
25309 : 46076 : void * _res = NULL;
25310 : 46076 : int _mark = p->mark;
25311 : : { // 'as' NAME
25312 [ - + ]: 46076 : if (p->error_indicator) {
25313 : 0 : p->level--;
25314 : 0 : 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 [ + + ]: 46076 : if (
25320 : 46076 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
25321 [ + + ]: 1538 : &&
25322 : 1538 : (z = _PyPegen_name_token(p)) // NAME
25323 : : )
25324 : : {
25325 : : D(fprintf(stderr, "%*c+ _tmp_31[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
25326 : 1532 : _res = z;
25327 [ - + - - ]: 1532 : if (_res == NULL && PyErr_Occurred()) {
25328 : 0 : p->error_indicator = 1;
25329 : 0 : p->level--;
25330 : 0 : return NULL;
25331 : : }
25332 : 1532 : goto done;
25333 : : }
25334 : 44544 : 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 : 44544 : _res = NULL;
25339 : 46076 : done:
25340 : 46076 : p->level--;
25341 : 46076 : return _res;
25342 : : }
25343 : :
25344 : : // _loop1_32: ('@' named_expression NEWLINE)
25345 : : static asdl_seq *
25346 : 400849 : _loop1_32_rule(Parser *p)
25347 : : {
25348 [ - + ]: 400849 : if (p->level++ == MAXSTACK) {
25349 : 0 : p->error_indicator = 1;
25350 : : PyErr_NoMemory();
25351 : : }
25352 [ - + ]: 400849 : if (p->error_indicator) {
25353 : 0 : p->level--;
25354 : 0 : return NULL;
25355 : : }
25356 : 400849 : void *_res = NULL;
25357 : 400849 : int _mark = p->mark;
25358 : 400849 : int _start_mark = p->mark;
25359 : 400849 : void **_children = PyMem_Malloc(sizeof(void *));
25360 [ - + ]: 400849 : if (!_children) {
25361 : 0 : p->error_indicator = 1;
25362 : : PyErr_NoMemory();
25363 : 0 : p->level--;
25364 : 0 : return NULL;
25365 : : }
25366 : 400849 : Py_ssize_t _children_capacity = 1;
25367 : 400849 : Py_ssize_t _n = 0;
25368 : : { // ('@' named_expression NEWLINE)
25369 [ - + ]: 400849 : if (p->error_indicator) {
25370 : 0 : p->level--;
25371 : 0 : 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 : 400849 : while (
25376 [ + + ]: 440979 : (_tmp_222_var = _tmp_222_rule(p)) // '@' named_expression NEWLINE
25377 : : )
25378 : : {
25379 : 40130 : _res = _tmp_222_var;
25380 [ + + ]: 40130 : if (_n == _children_capacity) {
25381 : 2712 : _children_capacity *= 2;
25382 : 2712 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25383 [ - + ]: 2712 : if (!_new_children) {
25384 : 0 : p->error_indicator = 1;
25385 : : PyErr_NoMemory();
25386 : 0 : p->level--;
25387 : 0 : return NULL;
25388 : : }
25389 : 2712 : _children = _new_children;
25390 : : }
25391 : 40130 : _children[_n++] = _res;
25392 : 40130 : _mark = p->mark;
25393 : : }
25394 : 400849 : 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 [ + + - + ]: 400849 : if (_n == 0 || p->error_indicator) {
25399 : 363505 : PyMem_Free(_children);
25400 : 363505 : p->level--;
25401 : 363505 : return NULL;
25402 : : }
25403 : 37344 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25404 [ - + ]: 37344 : if (!_seq) {
25405 : 0 : PyMem_Free(_children);
25406 : 0 : p->error_indicator = 1;
25407 : : PyErr_NoMemory();
25408 : 0 : p->level--;
25409 : 0 : return NULL;
25410 : : }
25411 [ + + ]: 77474 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25412 : 37344 : PyMem_Free(_children);
25413 : 37344 : _PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq);
25414 : 37344 : p->level--;
25415 : 37344 : return _seq;
25416 : : }
25417 : :
25418 : : // _tmp_33: '(' arguments? ')'
25419 : : static void *
25420 : 56469 : _tmp_33_rule(Parser *p)
25421 : : {
25422 [ - + ]: 56469 : if (p->level++ == MAXSTACK) {
25423 : 0 : p->error_indicator = 1;
25424 : : PyErr_NoMemory();
25425 : : }
25426 [ - + ]: 56469 : if (p->error_indicator) {
25427 : 0 : p->level--;
25428 : 0 : return NULL;
25429 : : }
25430 : 56469 : void * _res = NULL;
25431 : 56469 : int _mark = p->mark;
25432 : : { // '(' arguments? ')'
25433 [ - + ]: 56469 : if (p->error_indicator) {
25434 : 0 : p->level--;
25435 : 0 : 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 [ + + ]: 56469 : if (
25442 : 56469 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
25443 : 42665 : &&
25444 [ + + ]: 42665 : (z = arguments_rule(p), !p->error_indicator) // arguments?
25445 [ + + ]: 42659 : &&
25446 : 42659 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
25447 : : )
25448 : : {
25449 : : D(fprintf(stderr, "%*c+ _tmp_33[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
25450 : 42657 : _res = z;
25451 [ + + - + ]: 42657 : if (_res == NULL && PyErr_Occurred()) {
25452 : 0 : p->error_indicator = 1;
25453 : 0 : p->level--;
25454 : 0 : return NULL;
25455 : : }
25456 : 42657 : goto done;
25457 : : }
25458 : 13812 : 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 : 13812 : _res = NULL;
25463 : 56469 : done:
25464 : 56469 : p->level--;
25465 : 56469 : return _res;
25466 : : }
25467 : :
25468 : : // _tmp_34: '->' expression
25469 : : static void *
25470 : 336834 : _tmp_34_rule(Parser *p)
25471 : : {
25472 [ - + ]: 336834 : if (p->level++ == MAXSTACK) {
25473 : 0 : p->error_indicator = 1;
25474 : : PyErr_NoMemory();
25475 : : }
25476 [ - + ]: 336834 : if (p->error_indicator) {
25477 : 0 : p->level--;
25478 : 0 : return NULL;
25479 : : }
25480 : 336834 : void * _res = NULL;
25481 : 336834 : int _mark = p->mark;
25482 : : { // '->' expression
25483 [ - + ]: 336834 : if (p->error_indicator) {
25484 : 0 : p->level--;
25485 : 0 : 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 [ + + ]: 336834 : if (
25491 : 336834 : (_literal = _PyPegen_expect_token(p, 51)) // token='->'
25492 [ + - ]: 32955 : &&
25493 : 32955 : (z = expression_rule(p)) // expression
25494 : : )
25495 : : {
25496 : : D(fprintf(stderr, "%*c+ _tmp_34[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
25497 : 32955 : _res = z;
25498 [ - + - - ]: 32955 : if (_res == NULL && PyErr_Occurred()) {
25499 : 0 : p->error_indicator = 1;
25500 : 0 : p->level--;
25501 : 0 : return NULL;
25502 : : }
25503 : 32955 : goto done;
25504 : : }
25505 : 303879 : 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 : 303879 : _res = NULL;
25510 : 336834 : done:
25511 : 336834 : p->level--;
25512 : 336834 : return _res;
25513 : : }
25514 : :
25515 : : // _tmp_35: '->' expression
25516 : : static void *
25517 : 3447 : _tmp_35_rule(Parser *p)
25518 : : {
25519 [ - + ]: 3447 : if (p->level++ == MAXSTACK) {
25520 : 0 : p->error_indicator = 1;
25521 : : PyErr_NoMemory();
25522 : : }
25523 [ - + ]: 3447 : if (p->error_indicator) {
25524 : 0 : p->level--;
25525 : 0 : return NULL;
25526 : : }
25527 : 3447 : void * _res = NULL;
25528 : 3447 : int _mark = p->mark;
25529 : : { // '->' expression
25530 [ - + ]: 3447 : if (p->error_indicator) {
25531 : 0 : p->level--;
25532 : 0 : 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 [ + + ]: 3447 : if (
25538 : 3447 : (_literal = _PyPegen_expect_token(p, 51)) // token='->'
25539 [ + - ]: 416 : &&
25540 : 416 : (z = expression_rule(p)) // expression
25541 : : )
25542 : : {
25543 : : D(fprintf(stderr, "%*c+ _tmp_35[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
25544 : 416 : _res = z;
25545 [ - + - - ]: 416 : if (_res == NULL && PyErr_Occurred()) {
25546 : 0 : p->error_indicator = 1;
25547 : 0 : p->level--;
25548 : 0 : return NULL;
25549 : : }
25550 : 416 : goto done;
25551 : : }
25552 : 3031 : 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 : 3031 : _res = NULL;
25557 : 3447 : done:
25558 : 3447 : p->level--;
25559 : 3447 : return _res;
25560 : : }
25561 : :
25562 : : // _loop0_36: param_no_default
25563 : : static asdl_seq *
25564 : 17578 : _loop0_36_rule(Parser *p)
25565 : : {
25566 [ - + ]: 17578 : if (p->level++ == MAXSTACK) {
25567 : 0 : p->error_indicator = 1;
25568 : : PyErr_NoMemory();
25569 : : }
25570 [ - + ]: 17578 : if (p->error_indicator) {
25571 : 0 : p->level--;
25572 : 0 : return NULL;
25573 : : }
25574 : 17578 : void *_res = NULL;
25575 : 17578 : int _mark = p->mark;
25576 : 17578 : int _start_mark = p->mark;
25577 : 17578 : void **_children = PyMem_Malloc(sizeof(void *));
25578 [ - + ]: 17578 : if (!_children) {
25579 : 0 : p->error_indicator = 1;
25580 : : PyErr_NoMemory();
25581 : 0 : p->level--;
25582 : 0 : return NULL;
25583 : : }
25584 : 17578 : Py_ssize_t _children_capacity = 1;
25585 : 17578 : Py_ssize_t _n = 0;
25586 : : { // param_no_default
25587 [ - + ]: 17578 : if (p->error_indicator) {
25588 : 0 : p->level--;
25589 : 0 : 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 : 17578 : while (
25594 [ + + ]: 17778 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
25595 : : )
25596 : : {
25597 : 200 : _res = param_no_default_var;
25598 [ + + ]: 200 : if (_n == _children_capacity) {
25599 : 71 : _children_capacity *= 2;
25600 : 71 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25601 [ - + ]: 71 : if (!_new_children) {
25602 : 0 : p->error_indicator = 1;
25603 : : PyErr_NoMemory();
25604 : 0 : p->level--;
25605 : 0 : return NULL;
25606 : : }
25607 : 71 : _children = _new_children;
25608 : : }
25609 : 200 : _children[_n++] = _res;
25610 : 200 : _mark = p->mark;
25611 : : }
25612 : 17578 : 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 : 17578 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25617 [ - + ]: 17578 : if (!_seq) {
25618 : 0 : PyMem_Free(_children);
25619 : 0 : p->error_indicator = 1;
25620 : : PyErr_NoMemory();
25621 : 0 : p->level--;
25622 : 0 : return NULL;
25623 : : }
25624 [ + + ]: 17778 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25625 : 17578 : PyMem_Free(_children);
25626 : 17578 : _PyPegen_insert_memo(p, _start_mark, _loop0_36_type, _seq);
25627 : 17578 : p->level--;
25628 : 17578 : return _seq;
25629 : : }
25630 : :
25631 : : // _loop0_37: param_with_default
25632 : : static asdl_seq *
25633 : 17578 : _loop0_37_rule(Parser *p)
25634 : : {
25635 [ - + ]: 17578 : if (p->level++ == MAXSTACK) {
25636 : 0 : p->error_indicator = 1;
25637 : : PyErr_NoMemory();
25638 : : }
25639 [ - + ]: 17578 : if (p->error_indicator) {
25640 : 0 : p->level--;
25641 : 0 : return NULL;
25642 : : }
25643 : 17578 : void *_res = NULL;
25644 : 17578 : int _mark = p->mark;
25645 : 17578 : int _start_mark = p->mark;
25646 : 17578 : void **_children = PyMem_Malloc(sizeof(void *));
25647 [ - + ]: 17578 : if (!_children) {
25648 : 0 : p->error_indicator = 1;
25649 : : PyErr_NoMemory();
25650 : 0 : p->level--;
25651 : 0 : return NULL;
25652 : : }
25653 : 17578 : Py_ssize_t _children_capacity = 1;
25654 : 17578 : Py_ssize_t _n = 0;
25655 : : { // param_with_default
25656 [ - + ]: 17578 : if (p->error_indicator) {
25657 : 0 : p->level--;
25658 : 0 : 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 : 17578 : while (
25663 [ + + ]: 17777 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
25664 : : )
25665 : : {
25666 : 199 : _res = param_with_default_var;
25667 [ + + ]: 199 : if (_n == _children_capacity) {
25668 : 97 : _children_capacity *= 2;
25669 : 97 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25670 [ - + ]: 97 : if (!_new_children) {
25671 : 0 : p->error_indicator = 1;
25672 : : PyErr_NoMemory();
25673 : 0 : p->level--;
25674 : 0 : return NULL;
25675 : : }
25676 : 97 : _children = _new_children;
25677 : : }
25678 : 199 : _children[_n++] = _res;
25679 : 199 : _mark = p->mark;
25680 : : }
25681 : 17578 : 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 : 17578 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25686 [ - + ]: 17578 : if (!_seq) {
25687 : 0 : PyMem_Free(_children);
25688 : 0 : p->error_indicator = 1;
25689 : : PyErr_NoMemory();
25690 : 0 : p->level--;
25691 : 0 : return NULL;
25692 : : }
25693 [ + + ]: 17777 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25694 : 17578 : PyMem_Free(_children);
25695 : 17578 : _PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq);
25696 : 17578 : p->level--;
25697 : 17578 : return _seq;
25698 : : }
25699 : :
25700 : : // _loop0_38: param_with_default
25701 : : static asdl_seq *
25702 : 367 : _loop0_38_rule(Parser *p)
25703 : : {
25704 [ - + ]: 367 : if (p->level++ == MAXSTACK) {
25705 : 0 : p->error_indicator = 1;
25706 : : PyErr_NoMemory();
25707 : : }
25708 [ - + ]: 367 : if (p->error_indicator) {
25709 : 0 : p->level--;
25710 : 0 : return NULL;
25711 : : }
25712 : 367 : void *_res = NULL;
25713 : 367 : int _mark = p->mark;
25714 : 367 : int _start_mark = p->mark;
25715 : 367 : void **_children = PyMem_Malloc(sizeof(void *));
25716 [ - + ]: 367 : if (!_children) {
25717 : 0 : p->error_indicator = 1;
25718 : : PyErr_NoMemory();
25719 : 0 : p->level--;
25720 : 0 : return NULL;
25721 : : }
25722 : 367 : Py_ssize_t _children_capacity = 1;
25723 : 367 : Py_ssize_t _n = 0;
25724 : : { // param_with_default
25725 [ - + ]: 367 : if (p->error_indicator) {
25726 : 0 : p->level--;
25727 : 0 : 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 : 367 : while (
25732 [ + + ]: 475 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
25733 : : )
25734 : : {
25735 : 108 : _res = param_with_default_var;
25736 [ + + ]: 108 : if (_n == _children_capacity) {
25737 : 32 : _children_capacity *= 2;
25738 : 32 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25739 [ - + ]: 32 : if (!_new_children) {
25740 : 0 : p->error_indicator = 1;
25741 : : PyErr_NoMemory();
25742 : 0 : p->level--;
25743 : 0 : return NULL;
25744 : : }
25745 : 32 : _children = _new_children;
25746 : : }
25747 : 108 : _children[_n++] = _res;
25748 : 108 : _mark = p->mark;
25749 : : }
25750 : 367 : 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 : 367 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25755 [ - + ]: 367 : if (!_seq) {
25756 : 0 : PyMem_Free(_children);
25757 : 0 : p->error_indicator = 1;
25758 : : PyErr_NoMemory();
25759 : 0 : p->level--;
25760 : 0 : return NULL;
25761 : : }
25762 [ + + ]: 475 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25763 : 367 : PyMem_Free(_children);
25764 : 367 : _PyPegen_insert_memo(p, _start_mark, _loop0_38_type, _seq);
25765 : 367 : p->level--;
25766 : 367 : return _seq;
25767 : : }
25768 : :
25769 : : // _loop1_39: param_no_default
25770 : : static asdl_seq *
25771 : 322646 : _loop1_39_rule(Parser *p)
25772 : : {
25773 [ - + ]: 322646 : if (p->level++ == MAXSTACK) {
25774 : 0 : p->error_indicator = 1;
25775 : : PyErr_NoMemory();
25776 : : }
25777 [ - + ]: 322646 : if (p->error_indicator) {
25778 : 0 : p->level--;
25779 : 0 : return NULL;
25780 : : }
25781 : 322646 : void *_res = NULL;
25782 : 322646 : int _mark = p->mark;
25783 : 322646 : int _start_mark = p->mark;
25784 : 322646 : void **_children = PyMem_Malloc(sizeof(void *));
25785 [ - + ]: 322646 : if (!_children) {
25786 : 0 : p->error_indicator = 1;
25787 : : PyErr_NoMemory();
25788 : 0 : p->level--;
25789 : 0 : return NULL;
25790 : : }
25791 : 322646 : Py_ssize_t _children_capacity = 1;
25792 : 322646 : Py_ssize_t _n = 0;
25793 : : { // param_no_default
25794 [ - + ]: 322646 : if (p->error_indicator) {
25795 : 0 : p->level--;
25796 : 0 : 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 : 322646 : while (
25801 [ + + ]: 786062 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
25802 : : )
25803 : : {
25804 : 463416 : _res = param_no_default_var;
25805 [ + + ]: 463416 : if (_n == _children_capacity) {
25806 : 148137 : _children_capacity *= 2;
25807 : 148137 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25808 [ - + ]: 148137 : if (!_new_children) {
25809 : 0 : p->error_indicator = 1;
25810 : : PyErr_NoMemory();
25811 : 0 : p->level--;
25812 : 0 : return NULL;
25813 : : }
25814 : 148137 : _children = _new_children;
25815 : : }
25816 : 463416 : _children[_n++] = _res;
25817 : 463416 : _mark = p->mark;
25818 : : }
25819 : 322646 : 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 [ + + - + ]: 322646 : if (_n == 0 || p->error_indicator) {
25824 : 24704 : PyMem_Free(_children);
25825 : 24704 : p->level--;
25826 : 24704 : return NULL;
25827 : : }
25828 : 297942 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25829 [ - + ]: 297942 : if (!_seq) {
25830 : 0 : PyMem_Free(_children);
25831 : 0 : p->error_indicator = 1;
25832 : : PyErr_NoMemory();
25833 : 0 : p->level--;
25834 : 0 : return NULL;
25835 : : }
25836 [ + + ]: 761358 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25837 : 297942 : PyMem_Free(_children);
25838 : 297942 : _PyPegen_insert_memo(p, _start_mark, _loop1_39_type, _seq);
25839 : 297942 : p->level--;
25840 : 297942 : return _seq;
25841 : : }
25842 : :
25843 : : // _loop0_40: param_with_default
25844 : : static asdl_seq *
25845 : 297942 : _loop0_40_rule(Parser *p)
25846 : : {
25847 [ - + ]: 297942 : if (p->level++ == MAXSTACK) {
25848 : 0 : p->error_indicator = 1;
25849 : : PyErr_NoMemory();
25850 : : }
25851 [ - + ]: 297942 : if (p->error_indicator) {
25852 : 0 : p->level--;
25853 : 0 : return NULL;
25854 : : }
25855 : 297942 : void *_res = NULL;
25856 : 297942 : int _mark = p->mark;
25857 : 297942 : int _start_mark = p->mark;
25858 : 297942 : void **_children = PyMem_Malloc(sizeof(void *));
25859 [ - + ]: 297942 : if (!_children) {
25860 : 0 : p->error_indicator = 1;
25861 : : PyErr_NoMemory();
25862 : 0 : p->level--;
25863 : 0 : return NULL;
25864 : : }
25865 : 297942 : Py_ssize_t _children_capacity = 1;
25866 : 297942 : Py_ssize_t _n = 0;
25867 : : { // param_with_default
25868 [ - + ]: 297942 : if (p->error_indicator) {
25869 : 0 : p->level--;
25870 : 0 : 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 : 297942 : while (
25875 [ + + ]: 364179 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
25876 : : )
25877 : : {
25878 : 66237 : _res = param_with_default_var;
25879 [ + + ]: 66237 : if (_n == _children_capacity) {
25880 : 22407 : _children_capacity *= 2;
25881 : 22407 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25882 [ - + ]: 22407 : if (!_new_children) {
25883 : 0 : p->error_indicator = 1;
25884 : : PyErr_NoMemory();
25885 : 0 : p->level--;
25886 : 0 : return NULL;
25887 : : }
25888 : 22407 : _children = _new_children;
25889 : : }
25890 : 66237 : _children[_n++] = _res;
25891 : 66237 : _mark = p->mark;
25892 : : }
25893 : 297942 : 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 : 297942 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25898 [ - + ]: 297942 : if (!_seq) {
25899 : 0 : PyMem_Free(_children);
25900 : 0 : p->error_indicator = 1;
25901 : : PyErr_NoMemory();
25902 : 0 : p->level--;
25903 : 0 : return NULL;
25904 : : }
25905 [ + + ]: 364179 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25906 : 297942 : PyMem_Free(_children);
25907 : 297942 : _PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq);
25908 : 297942 : p->level--;
25909 : 297942 : return _seq;
25910 : : }
25911 : :
25912 : : // _loop1_41: param_with_default
25913 : : static asdl_seq *
25914 : 24704 : _loop1_41_rule(Parser *p)
25915 : : {
25916 [ - + ]: 24704 : if (p->level++ == MAXSTACK) {
25917 : 0 : p->error_indicator = 1;
25918 : : PyErr_NoMemory();
25919 : : }
25920 [ - + ]: 24704 : if (p->error_indicator) {
25921 : 0 : p->level--;
25922 : 0 : return NULL;
25923 : : }
25924 : 24704 : void *_res = NULL;
25925 : 24704 : int _mark = p->mark;
25926 : 24704 : int _start_mark = p->mark;
25927 : 24704 : void **_children = PyMem_Malloc(sizeof(void *));
25928 [ - + ]: 24704 : if (!_children) {
25929 : 0 : p->error_indicator = 1;
25930 : : PyErr_NoMemory();
25931 : 0 : p->level--;
25932 : 0 : return NULL;
25933 : : }
25934 : 24704 : Py_ssize_t _children_capacity = 1;
25935 : 24704 : Py_ssize_t _n = 0;
25936 : : { // param_with_default
25937 [ - + ]: 24704 : if (p->error_indicator) {
25938 : 0 : p->level--;
25939 : 0 : 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 : 24704 : while (
25944 [ + + ]: 31429 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
25945 : : )
25946 : : {
25947 : 6725 : _res = param_with_default_var;
25948 [ + + ]: 6725 : if (_n == _children_capacity) {
25949 : 2752 : _children_capacity *= 2;
25950 : 2752 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25951 [ - + ]: 2752 : if (!_new_children) {
25952 : 0 : p->error_indicator = 1;
25953 : : PyErr_NoMemory();
25954 : 0 : p->level--;
25955 : 0 : return NULL;
25956 : : }
25957 : 2752 : _children = _new_children;
25958 : : }
25959 : 6725 : _children[_n++] = _res;
25960 : 6725 : _mark = p->mark;
25961 : : }
25962 : 24704 : 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 [ + + - + ]: 24704 : if (_n == 0 || p->error_indicator) {
25967 : 21609 : PyMem_Free(_children);
25968 : 21609 : p->level--;
25969 : 21609 : return NULL;
25970 : : }
25971 : 3095 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25972 [ - + ]: 3095 : if (!_seq) {
25973 : 0 : PyMem_Free(_children);
25974 : 0 : p->error_indicator = 1;
25975 : : PyErr_NoMemory();
25976 : 0 : p->level--;
25977 : 0 : return NULL;
25978 : : }
25979 [ + + ]: 9820 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25980 : 3095 : PyMem_Free(_children);
25981 : 3095 : _PyPegen_insert_memo(p, _start_mark, _loop1_41_type, _seq);
25982 : 3095 : p->level--;
25983 : 3095 : return _seq;
25984 : : }
25985 : :
25986 : : // _loop1_42: param_no_default
25987 : : static asdl_seq *
25988 : 341144 : _loop1_42_rule(Parser *p)
25989 : : {
25990 [ - + ]: 341144 : if (p->level++ == MAXSTACK) {
25991 : 0 : p->error_indicator = 1;
25992 : : PyErr_NoMemory();
25993 : : }
25994 [ - + ]: 341144 : if (p->error_indicator) {
25995 : 0 : p->level--;
25996 : 0 : return NULL;
25997 : : }
25998 : 341144 : void *_res = NULL;
25999 : 341144 : int _mark = p->mark;
26000 : 341144 : int _start_mark = p->mark;
26001 : 341144 : void **_children = PyMem_Malloc(sizeof(void *));
26002 [ - + ]: 341144 : if (!_children) {
26003 : 0 : p->error_indicator = 1;
26004 : : PyErr_NoMemory();
26005 : 0 : p->level--;
26006 : 0 : return NULL;
26007 : : }
26008 : 341144 : Py_ssize_t _children_capacity = 1;
26009 : 341144 : Py_ssize_t _n = 0;
26010 : : { // param_no_default
26011 [ - + ]: 341144 : if (p->error_indicator) {
26012 : 0 : p->level--;
26013 : 0 : 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 : 341144 : while (
26018 [ + + ]: 823714 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
26019 : : )
26020 : : {
26021 : 482570 : _res = param_no_default_var;
26022 [ + + ]: 482570 : if (_n == _children_capacity) {
26023 : 148714 : _children_capacity *= 2;
26024 : 148714 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26025 [ - + ]: 148714 : if (!_new_children) {
26026 : 0 : p->error_indicator = 1;
26027 : : PyErr_NoMemory();
26028 : 0 : p->level--;
26029 : 0 : return NULL;
26030 : : }
26031 : 148714 : _children = _new_children;
26032 : : }
26033 : 482570 : _children[_n++] = _res;
26034 : 482570 : _mark = p->mark;
26035 : : }
26036 : 341144 : 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 [ + + + + ]: 341144 : if (_n == 0 || p->error_indicator) {
26041 : 25256 : PyMem_Free(_children);
26042 : 25256 : p->level--;
26043 : 25256 : return NULL;
26044 : : }
26045 : 315888 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26046 [ - + ]: 315888 : if (!_seq) {
26047 : 0 : PyMem_Free(_children);
26048 : 0 : p->error_indicator = 1;
26049 : : PyErr_NoMemory();
26050 : 0 : p->level--;
26051 : 0 : return NULL;
26052 : : }
26053 [ + + ]: 798454 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26054 : 315888 : PyMem_Free(_children);
26055 : 315888 : _PyPegen_insert_memo(p, _start_mark, _loop1_42_type, _seq);
26056 : 315888 : p->level--;
26057 : 315888 : return _seq;
26058 : : }
26059 : :
26060 : : // _loop1_43: param_no_default
26061 : : static asdl_seq *
26062 : 323768 : _loop1_43_rule(Parser *p)
26063 : : {
26064 [ - + ]: 323768 : if (p->level++ == MAXSTACK) {
26065 : 0 : p->error_indicator = 1;
26066 : : PyErr_NoMemory();
26067 : : }
26068 [ - + ]: 323768 : if (p->error_indicator) {
26069 : 0 : p->level--;
26070 : 0 : return NULL;
26071 : : }
26072 : 323768 : void *_res = NULL;
26073 : 323768 : int _mark = p->mark;
26074 : 323768 : int _start_mark = p->mark;
26075 : 323768 : void **_children = PyMem_Malloc(sizeof(void *));
26076 [ - + ]: 323768 : if (!_children) {
26077 : 0 : p->error_indicator = 1;
26078 : : PyErr_NoMemory();
26079 : 0 : p->level--;
26080 : 0 : return NULL;
26081 : : }
26082 : 323768 : Py_ssize_t _children_capacity = 1;
26083 : 323768 : Py_ssize_t _n = 0;
26084 : : { // param_no_default
26085 [ - + ]: 323768 : if (p->error_indicator) {
26086 : 0 : p->level--;
26087 : 0 : 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 : 323768 : while (
26092 [ + + ]: 788538 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
26093 : : )
26094 : : {
26095 : 464770 : _res = param_no_default_var;
26096 [ + + ]: 464770 : if (_n == _children_capacity) {
26097 : 148311 : _children_capacity *= 2;
26098 : 148311 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26099 [ - + ]: 148311 : if (!_new_children) {
26100 : 0 : p->error_indicator = 1;
26101 : : PyErr_NoMemory();
26102 : 0 : p->level--;
26103 : 0 : return NULL;
26104 : : }
26105 : 148311 : _children = _new_children;
26106 : : }
26107 : 464770 : _children[_n++] = _res;
26108 : 464770 : _mark = p->mark;
26109 : : }
26110 : 323768 : 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 [ + + - + ]: 323768 : if (_n == 0 || p->error_indicator) {
26115 : 25243 : PyMem_Free(_children);
26116 : 25243 : p->level--;
26117 : 25243 : return NULL;
26118 : : }
26119 : 298525 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26120 [ - + ]: 298525 : if (!_seq) {
26121 : 0 : PyMem_Free(_children);
26122 : 0 : p->error_indicator = 1;
26123 : : PyErr_NoMemory();
26124 : 0 : p->level--;
26125 : 0 : return NULL;
26126 : : }
26127 [ + + ]: 763295 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26128 : 298525 : PyMem_Free(_children);
26129 : 298525 : _PyPegen_insert_memo(p, _start_mark, _loop1_43_type, _seq);
26130 : 298525 : p->level--;
26131 : 298525 : return _seq;
26132 : : }
26133 : :
26134 : : // _loop0_44: param_no_default
26135 : : static asdl_seq *
26136 : 323835 : _loop0_44_rule(Parser *p)
26137 : : {
26138 [ - + ]: 323835 : if (p->level++ == MAXSTACK) {
26139 : 0 : p->error_indicator = 1;
26140 : : PyErr_NoMemory();
26141 : : }
26142 [ - + ]: 323835 : if (p->error_indicator) {
26143 : 0 : p->level--;
26144 : 0 : return NULL;
26145 : : }
26146 : 323835 : void *_res = NULL;
26147 : 323835 : int _mark = p->mark;
26148 : 323835 : int _start_mark = p->mark;
26149 : 323835 : void **_children = PyMem_Malloc(sizeof(void *));
26150 [ - + ]: 323835 : if (!_children) {
26151 : 0 : p->error_indicator = 1;
26152 : : PyErr_NoMemory();
26153 : 0 : p->level--;
26154 : 0 : return NULL;
26155 : : }
26156 : 323835 : Py_ssize_t _children_capacity = 1;
26157 : 323835 : Py_ssize_t _n = 0;
26158 : : { // param_no_default
26159 [ - + ]: 323835 : if (p->error_indicator) {
26160 : 0 : p->level--;
26161 : 0 : 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 : 323835 : while (
26166 [ + + ]: 787630 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
26167 : : )
26168 : : {
26169 : 463795 : _res = param_no_default_var;
26170 [ + + ]: 463795 : if (_n == _children_capacity) {
26171 : 148159 : _children_capacity *= 2;
26172 : 148159 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26173 [ - + ]: 148159 : if (!_new_children) {
26174 : 0 : p->error_indicator = 1;
26175 : : PyErr_NoMemory();
26176 : 0 : p->level--;
26177 : 0 : return NULL;
26178 : : }
26179 : 148159 : _children = _new_children;
26180 : : }
26181 : 463795 : _children[_n++] = _res;
26182 : 463795 : _mark = p->mark;
26183 : : }
26184 : 323835 : 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 : 323835 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26189 [ - + ]: 323835 : if (!_seq) {
26190 : 0 : PyMem_Free(_children);
26191 : 0 : p->error_indicator = 1;
26192 : : PyErr_NoMemory();
26193 : 0 : p->level--;
26194 : 0 : return NULL;
26195 : : }
26196 [ + + ]: 787630 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26197 : 323835 : PyMem_Free(_children);
26198 : 323835 : _PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq);
26199 : 323835 : p->level--;
26200 : 323835 : return _seq;
26201 : : }
26202 : :
26203 : : // _loop1_45: param_with_default
26204 : : static asdl_seq *
26205 : 323835 : _loop1_45_rule(Parser *p)
26206 : : {
26207 [ - + ]: 323835 : if (p->level++ == MAXSTACK) {
26208 : 0 : p->error_indicator = 1;
26209 : : PyErr_NoMemory();
26210 : : }
26211 [ - + ]: 323835 : if (p->error_indicator) {
26212 : 0 : p->level--;
26213 : 0 : return NULL;
26214 : : }
26215 : 323835 : void *_res = NULL;
26216 : 323835 : int _mark = p->mark;
26217 : 323835 : int _start_mark = p->mark;
26218 : 323835 : void **_children = PyMem_Malloc(sizeof(void *));
26219 [ - + ]: 323835 : if (!_children) {
26220 : 0 : p->error_indicator = 1;
26221 : : PyErr_NoMemory();
26222 : 0 : p->level--;
26223 : 0 : return NULL;
26224 : : }
26225 : 323835 : Py_ssize_t _children_capacity = 1;
26226 : 323835 : Py_ssize_t _n = 0;
26227 : : { // param_with_default
26228 [ - + ]: 323835 : if (p->error_indicator) {
26229 : 0 : p->level--;
26230 : 0 : 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 : 323835 : while (
26235 [ + + ]: 397197 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
26236 : : )
26237 : : {
26238 : 73362 : _res = param_with_default_var;
26239 [ + + ]: 73362 : if (_n == _children_capacity) {
26240 : 25170 : _children_capacity *= 2;
26241 : 25170 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26242 [ - + ]: 25170 : if (!_new_children) {
26243 : 0 : p->error_indicator = 1;
26244 : : PyErr_NoMemory();
26245 : 0 : p->level--;
26246 : 0 : return NULL;
26247 : : }
26248 : 25170 : _children = _new_children;
26249 : : }
26250 : 73362 : _children[_n++] = _res;
26251 : 73362 : _mark = p->mark;
26252 : : }
26253 : 323835 : 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 [ + + + + ]: 323835 : if (_n == 0 || p->error_indicator) {
26258 : 284174 : PyMem_Free(_children);
26259 : 284174 : p->level--;
26260 : 284174 : return NULL;
26261 : : }
26262 : 39661 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26263 [ - + ]: 39661 : if (!_seq) {
26264 : 0 : PyMem_Free(_children);
26265 : 0 : p->error_indicator = 1;
26266 : : PyErr_NoMemory();
26267 : 0 : p->level--;
26268 : 0 : return NULL;
26269 : : }
26270 [ + + ]: 113022 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26271 : 39661 : PyMem_Free(_children);
26272 : 39661 : _PyPegen_insert_memo(p, _start_mark, _loop1_45_type, _seq);
26273 : 39661 : p->level--;
26274 : 39661 : return _seq;
26275 : : }
26276 : :
26277 : : // _loop0_46: param_no_default
26278 : : static asdl_seq *
26279 : 323480 : _loop0_46_rule(Parser *p)
26280 : : {
26281 [ - + ]: 323480 : if (p->level++ == MAXSTACK) {
26282 : 0 : p->error_indicator = 1;
26283 : : PyErr_NoMemory();
26284 : : }
26285 [ - + ]: 323480 : if (p->error_indicator) {
26286 : 0 : p->level--;
26287 : 0 : return NULL;
26288 : : }
26289 : 323480 : void *_res = NULL;
26290 : 323480 : int _mark = p->mark;
26291 : 323480 : int _start_mark = p->mark;
26292 : 323480 : void **_children = PyMem_Malloc(sizeof(void *));
26293 [ - + ]: 323480 : if (!_children) {
26294 : 0 : p->error_indicator = 1;
26295 : : PyErr_NoMemory();
26296 : 0 : p->level--;
26297 : 0 : return NULL;
26298 : : }
26299 : 323480 : Py_ssize_t _children_capacity = 1;
26300 : 323480 : Py_ssize_t _n = 0;
26301 : : { // param_no_default
26302 [ - + ]: 323480 : if (p->error_indicator) {
26303 : 0 : p->level--;
26304 : 0 : 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 : 323480 : while (
26309 [ + + ]: 786994 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
26310 : : )
26311 : : {
26312 : 463514 : _res = param_no_default_var;
26313 [ + + ]: 463514 : if (_n == _children_capacity) {
26314 : 148145 : _children_capacity *= 2;
26315 : 148145 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26316 [ - + ]: 148145 : if (!_new_children) {
26317 : 0 : p->error_indicator = 1;
26318 : : PyErr_NoMemory();
26319 : 0 : p->level--;
26320 : 0 : return NULL;
26321 : : }
26322 : 148145 : _children = _new_children;
26323 : : }
26324 : 463514 : _children[_n++] = _res;
26325 : 463514 : _mark = p->mark;
26326 : : }
26327 : 323480 : 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 : 323480 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26332 [ - + ]: 323480 : if (!_seq) {
26333 : 0 : PyMem_Free(_children);
26334 : 0 : p->error_indicator = 1;
26335 : : PyErr_NoMemory();
26336 : 0 : p->level--;
26337 : 0 : return NULL;
26338 : : }
26339 [ + + ]: 786994 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26340 : 323480 : PyMem_Free(_children);
26341 : 323480 : _PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq);
26342 : 323480 : p->level--;
26343 : 323480 : return _seq;
26344 : : }
26345 : :
26346 : : // _loop1_47: param_with_default
26347 : : static asdl_seq *
26348 : 323480 : _loop1_47_rule(Parser *p)
26349 : : {
26350 [ - + ]: 323480 : if (p->level++ == MAXSTACK) {
26351 : 0 : p->error_indicator = 1;
26352 : : PyErr_NoMemory();
26353 : : }
26354 [ - + ]: 323480 : if (p->error_indicator) {
26355 : 0 : p->level--;
26356 : 0 : return NULL;
26357 : : }
26358 : 323480 : void *_res = NULL;
26359 : 323480 : int _mark = p->mark;
26360 : 323480 : int _start_mark = p->mark;
26361 : 323480 : void **_children = PyMem_Malloc(sizeof(void *));
26362 [ - + ]: 323480 : if (!_children) {
26363 : 0 : p->error_indicator = 1;
26364 : : PyErr_NoMemory();
26365 : 0 : p->level--;
26366 : 0 : return NULL;
26367 : : }
26368 : 323480 : Py_ssize_t _children_capacity = 1;
26369 : 323480 : Py_ssize_t _n = 0;
26370 : : { // param_with_default
26371 [ - + ]: 323480 : if (p->error_indicator) {
26372 : 0 : p->level--;
26373 : 0 : 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 : 323480 : while (
26378 [ + + ]: 396478 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
26379 : : )
26380 : : {
26381 : 72998 : _res = param_with_default_var;
26382 [ + + ]: 72998 : if (_n == _children_capacity) {
26383 : 25159 : _children_capacity *= 2;
26384 : 25159 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26385 [ - + ]: 25159 : if (!_new_children) {
26386 : 0 : p->error_indicator = 1;
26387 : : PyErr_NoMemory();
26388 : 0 : p->level--;
26389 : 0 : return NULL;
26390 : : }
26391 : 25159 : _children = _new_children;
26392 : : }
26393 : 72998 : _children[_n++] = _res;
26394 : 72998 : _mark = p->mark;
26395 : : }
26396 : 323480 : 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 [ + + - + ]: 323480 : if (_n == 0 || p->error_indicator) {
26401 : 284171 : PyMem_Free(_children);
26402 : 284171 : p->level--;
26403 : 284171 : return NULL;
26404 : : }
26405 : 39309 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26406 [ - + ]: 39309 : if (!_seq) {
26407 : 0 : PyMem_Free(_children);
26408 : 0 : p->error_indicator = 1;
26409 : : PyErr_NoMemory();
26410 : 0 : p->level--;
26411 : 0 : return NULL;
26412 : : }
26413 [ + + ]: 112307 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26414 : 39309 : PyMem_Free(_children);
26415 : 39309 : _PyPegen_insert_memo(p, _start_mark, _loop1_47_type, _seq);
26416 : 39309 : p->level--;
26417 : 39309 : return _seq;
26418 : : }
26419 : :
26420 : : // _loop0_48: param_maybe_default
26421 : : static asdl_seq *
26422 : 27187 : _loop0_48_rule(Parser *p)
26423 : : {
26424 [ - + ]: 27187 : if (p->level++ == MAXSTACK) {
26425 : 0 : p->error_indicator = 1;
26426 : : PyErr_NoMemory();
26427 : : }
26428 [ - + ]: 27187 : if (p->error_indicator) {
26429 : 0 : p->level--;
26430 : 0 : return NULL;
26431 : : }
26432 : 27187 : void *_res = NULL;
26433 : 27187 : int _mark = p->mark;
26434 : 27187 : int _start_mark = p->mark;
26435 : 27187 : void **_children = PyMem_Malloc(sizeof(void *));
26436 [ - + ]: 27187 : if (!_children) {
26437 : 0 : p->error_indicator = 1;
26438 : : PyErr_NoMemory();
26439 : 0 : p->level--;
26440 : 0 : return NULL;
26441 : : }
26442 : 27187 : Py_ssize_t _children_capacity = 1;
26443 : 27187 : Py_ssize_t _n = 0;
26444 : : { // param_maybe_default
26445 [ - + ]: 27187 : if (p->error_indicator) {
26446 : 0 : p->level--;
26447 : 0 : 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 : 27187 : while (
26452 [ + + ]: 29061 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
26453 : : )
26454 : : {
26455 : 1874 : _res = param_maybe_default_var;
26456 [ + + ]: 1874 : if (_n == _children_capacity) {
26457 : 615 : _children_capacity *= 2;
26458 : 615 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26459 [ - + ]: 615 : if (!_new_children) {
26460 : 0 : p->error_indicator = 1;
26461 : : PyErr_NoMemory();
26462 : 0 : p->level--;
26463 : 0 : return NULL;
26464 : : }
26465 : 615 : _children = _new_children;
26466 : : }
26467 : 1874 : _children[_n++] = _res;
26468 : 1874 : _mark = p->mark;
26469 : : }
26470 : 27187 : 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 : 27187 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26475 [ - + ]: 27187 : if (!_seq) {
26476 : 0 : PyMem_Free(_children);
26477 : 0 : p->error_indicator = 1;
26478 : : PyErr_NoMemory();
26479 : 0 : p->level--;
26480 : 0 : return NULL;
26481 : : }
26482 [ + + ]: 29061 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26483 : 27187 : PyMem_Free(_children);
26484 : 27187 : _PyPegen_insert_memo(p, _start_mark, _loop0_48_type, _seq);
26485 : 27187 : p->level--;
26486 : 27187 : return _seq;
26487 : : }
26488 : :
26489 : : // _loop0_49: param_maybe_default
26490 : : static asdl_seq *
26491 : 20 : _loop0_49_rule(Parser *p)
26492 : : {
26493 [ - + ]: 20 : if (p->level++ == MAXSTACK) {
26494 : 0 : p->error_indicator = 1;
26495 : : PyErr_NoMemory();
26496 : : }
26497 [ - + ]: 20 : if (p->error_indicator) {
26498 : 0 : p->level--;
26499 : 0 : return NULL;
26500 : : }
26501 : 20 : void *_res = NULL;
26502 : 20 : int _mark = p->mark;
26503 : 20 : int _start_mark = p->mark;
26504 : 20 : void **_children = PyMem_Malloc(sizeof(void *));
26505 [ - + ]: 20 : if (!_children) {
26506 : 0 : p->error_indicator = 1;
26507 : : PyErr_NoMemory();
26508 : 0 : p->level--;
26509 : 0 : return NULL;
26510 : : }
26511 : 20 : Py_ssize_t _children_capacity = 1;
26512 : 20 : Py_ssize_t _n = 0;
26513 : : { // param_maybe_default
26514 [ - + ]: 20 : if (p->error_indicator) {
26515 : 0 : p->level--;
26516 : 0 : 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 : 20 : while (
26521 [ + + ]: 23 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
26522 : : )
26523 : : {
26524 : 3 : _res = param_maybe_default_var;
26525 [ - + ]: 3 : if (_n == _children_capacity) {
26526 : 0 : _children_capacity *= 2;
26527 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26528 [ # # ]: 0 : if (!_new_children) {
26529 : 0 : p->error_indicator = 1;
26530 : : PyErr_NoMemory();
26531 : 0 : p->level--;
26532 : 0 : return NULL;
26533 : : }
26534 : 0 : _children = _new_children;
26535 : : }
26536 : 3 : _children[_n++] = _res;
26537 : 3 : _mark = p->mark;
26538 : : }
26539 : 20 : 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 : 20 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26544 [ - + ]: 20 : if (!_seq) {
26545 : 0 : PyMem_Free(_children);
26546 : 0 : p->error_indicator = 1;
26547 : : PyErr_NoMemory();
26548 : 0 : p->level--;
26549 : 0 : return NULL;
26550 : : }
26551 [ + + ]: 23 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26552 : 20 : PyMem_Free(_children);
26553 : 20 : _PyPegen_insert_memo(p, _start_mark, _loop0_49_type, _seq);
26554 : 20 : p->level--;
26555 : 20 : return _seq;
26556 : : }
26557 : :
26558 : : // _loop1_50: param_maybe_default
26559 : : static asdl_seq *
26560 : 5934 : _loop1_50_rule(Parser *p)
26561 : : {
26562 [ - + ]: 5934 : if (p->level++ == MAXSTACK) {
26563 : 0 : p->error_indicator = 1;
26564 : : PyErr_NoMemory();
26565 : : }
26566 [ - + ]: 5934 : if (p->error_indicator) {
26567 : 0 : p->level--;
26568 : 0 : return NULL;
26569 : : }
26570 : 5934 : void *_res = NULL;
26571 : 5934 : int _mark = p->mark;
26572 : 5934 : int _start_mark = p->mark;
26573 : 5934 : void **_children = PyMem_Malloc(sizeof(void *));
26574 [ - + ]: 5934 : if (!_children) {
26575 : 0 : p->error_indicator = 1;
26576 : : PyErr_NoMemory();
26577 : 0 : p->level--;
26578 : 0 : return NULL;
26579 : : }
26580 : 5934 : Py_ssize_t _children_capacity = 1;
26581 : 5934 : Py_ssize_t _n = 0;
26582 : : { // param_maybe_default
26583 [ - + ]: 5934 : if (p->error_indicator) {
26584 : 0 : p->level--;
26585 : 0 : 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 : 5934 : while (
26590 [ + + ]: 22635 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
26591 : : )
26592 : : {
26593 : 16701 : _res = param_maybe_default_var;
26594 [ + + ]: 16701 : if (_n == _children_capacity) {
26595 : 6817 : _children_capacity *= 2;
26596 : 6817 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26597 [ - + ]: 6817 : if (!_new_children) {
26598 : 0 : p->error_indicator = 1;
26599 : : PyErr_NoMemory();
26600 : 0 : p->level--;
26601 : 0 : return NULL;
26602 : : }
26603 : 6817 : _children = _new_children;
26604 : : }
26605 : 16701 : _children[_n++] = _res;
26606 : 16701 : _mark = p->mark;
26607 : : }
26608 : 5934 : 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 [ + + - + ]: 5934 : if (_n == 0 || p->error_indicator) {
26613 : 13 : PyMem_Free(_children);
26614 : 13 : p->level--;
26615 : 13 : return NULL;
26616 : : }
26617 : 5921 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26618 [ - + ]: 5921 : if (!_seq) {
26619 : 0 : PyMem_Free(_children);
26620 : 0 : p->error_indicator = 1;
26621 : : PyErr_NoMemory();
26622 : 0 : p->level--;
26623 : 0 : return NULL;
26624 : : }
26625 [ + + ]: 22622 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26626 : 5921 : PyMem_Free(_children);
26627 : 5921 : _PyPegen_insert_memo(p, _start_mark, _loop1_50_type, _seq);
26628 : 5921 : p->level--;
26629 : 5921 : return _seq;
26630 : : }
26631 : :
26632 : : // _loop0_52: ',' with_item
26633 : : static asdl_seq *
26634 : 71 : _loop0_52_rule(Parser *p)
26635 : : {
26636 [ - + ]: 71 : if (p->level++ == MAXSTACK) {
26637 : 0 : p->error_indicator = 1;
26638 : : PyErr_NoMemory();
26639 : : }
26640 [ - + ]: 71 : if (p->error_indicator) {
26641 : 0 : p->level--;
26642 : 0 : return NULL;
26643 : : }
26644 : 71 : void *_res = NULL;
26645 : 71 : int _mark = p->mark;
26646 : 71 : int _start_mark = p->mark;
26647 : 71 : void **_children = PyMem_Malloc(sizeof(void *));
26648 [ - + ]: 71 : if (!_children) {
26649 : 0 : p->error_indicator = 1;
26650 : : PyErr_NoMemory();
26651 : 0 : p->level--;
26652 : 0 : return NULL;
26653 : : }
26654 : 71 : Py_ssize_t _children_capacity = 1;
26655 : 71 : Py_ssize_t _n = 0;
26656 : : { // ',' with_item
26657 [ - + ]: 71 : if (p->error_indicator) {
26658 : 0 : p->level--;
26659 : 0 : 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 : 71 : while (
26665 : 109 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
26666 [ + + + + ]: 156 : &&
26667 : 47 : (elem = with_item_rule(p)) // with_item
26668 : : )
26669 : : {
26670 : 38 : _res = elem;
26671 [ - + - - ]: 38 : if (_res == NULL && PyErr_Occurred()) {
26672 : 0 : p->error_indicator = 1;
26673 : 0 : PyMem_Free(_children);
26674 : 0 : p->level--;
26675 : 0 : return NULL;
26676 : : }
26677 [ + + ]: 38 : if (_n == _children_capacity) {
26678 : 8 : _children_capacity *= 2;
26679 : 8 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26680 [ - + ]: 8 : if (!_new_children) {
26681 : 0 : p->error_indicator = 1;
26682 : : PyErr_NoMemory();
26683 : 0 : p->level--;
26684 : 0 : return NULL;
26685 : : }
26686 : 8 : _children = _new_children;
26687 : : }
26688 : 38 : _children[_n++] = _res;
26689 : 38 : _mark = p->mark;
26690 : : }
26691 : 71 : 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 : 71 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26696 [ - + ]: 71 : if (!_seq) {
26697 : 0 : PyMem_Free(_children);
26698 : 0 : p->error_indicator = 1;
26699 : : PyErr_NoMemory();
26700 : 0 : p->level--;
26701 : 0 : return NULL;
26702 : : }
26703 [ + + ]: 109 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26704 : 71 : PyMem_Free(_children);
26705 : 71 : _PyPegen_insert_memo(p, _start_mark, _loop0_52_type, _seq);
26706 : 71 : p->level--;
26707 : 71 : return _seq;
26708 : : }
26709 : :
26710 : : // _gather_51: with_item _loop0_52
26711 : : static asdl_seq *
26712 : 72 : _gather_51_rule(Parser *p)
26713 : : {
26714 [ - + ]: 72 : if (p->level++ == MAXSTACK) {
26715 : 0 : p->error_indicator = 1;
26716 : : PyErr_NoMemory();
26717 : : }
26718 [ - + ]: 72 : if (p->error_indicator) {
26719 : 0 : p->level--;
26720 : 0 : return NULL;
26721 : : }
26722 : 72 : asdl_seq * _res = NULL;
26723 : 72 : int _mark = p->mark;
26724 : : { // with_item _loop0_52
26725 [ - + ]: 72 : if (p->error_indicator) {
26726 : 0 : p->level--;
26727 : 0 : 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 [ + + ]: 72 : if (
26733 : 72 : (elem = with_item_rule(p)) // with_item
26734 [ + - ]: 71 : &&
26735 : 71 : (seq = _loop0_52_rule(p)) // _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 : 71 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
26740 : 71 : goto done;
26741 : : }
26742 : 1 : 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 : 1 : _res = NULL;
26747 : 72 : done:
26748 : 72 : p->level--;
26749 : 72 : return _res;
26750 : : }
26751 : :
26752 : : // _loop0_54: ',' with_item
26753 : : static asdl_seq *
26754 : 38574 : _loop0_54_rule(Parser *p)
26755 : : {
26756 [ - + ]: 38574 : if (p->level++ == MAXSTACK) {
26757 : 0 : p->error_indicator = 1;
26758 : : PyErr_NoMemory();
26759 : : }
26760 [ - + ]: 38574 : if (p->error_indicator) {
26761 : 0 : p->level--;
26762 : 0 : return NULL;
26763 : : }
26764 : 38574 : void *_res = NULL;
26765 : 38574 : int _mark = p->mark;
26766 : 38574 : int _start_mark = p->mark;
26767 : 38574 : void **_children = PyMem_Malloc(sizeof(void *));
26768 [ - + ]: 38574 : if (!_children) {
26769 : 0 : p->error_indicator = 1;
26770 : : PyErr_NoMemory();
26771 : 0 : p->level--;
26772 : 0 : return NULL;
26773 : : }
26774 : 38574 : Py_ssize_t _children_capacity = 1;
26775 : 38574 : Py_ssize_t _n = 0;
26776 : : { // ',' with_item
26777 [ - + ]: 38574 : if (p->error_indicator) {
26778 : 0 : p->level--;
26779 : 0 : 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 : 38574 : while (
26785 : 39329 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
26786 [ + + + + ]: 40085 : &&
26787 : 756 : (elem = with_item_rule(p)) // with_item
26788 : : )
26789 : : {
26790 : 755 : _res = elem;
26791 [ - + - - ]: 755 : if (_res == NULL && PyErr_Occurred()) {
26792 : 0 : p->error_indicator = 1;
26793 : 0 : PyMem_Free(_children);
26794 : 0 : p->level--;
26795 : 0 : return NULL;
26796 : : }
26797 [ + + ]: 755 : if (_n == _children_capacity) {
26798 : 73 : _children_capacity *= 2;
26799 : 73 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26800 [ - + ]: 73 : if (!_new_children) {
26801 : 0 : p->error_indicator = 1;
26802 : : PyErr_NoMemory();
26803 : 0 : p->level--;
26804 : 0 : return NULL;
26805 : : }
26806 : 73 : _children = _new_children;
26807 : : }
26808 : 755 : _children[_n++] = _res;
26809 : 755 : _mark = p->mark;
26810 : : }
26811 : 38574 : 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 : 38574 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26816 [ - + ]: 38574 : if (!_seq) {
26817 : 0 : PyMem_Free(_children);
26818 : 0 : p->error_indicator = 1;
26819 : : PyErr_NoMemory();
26820 : 0 : p->level--;
26821 : 0 : return NULL;
26822 : : }
26823 [ + + ]: 39329 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26824 : 38574 : PyMem_Free(_children);
26825 : 38574 : _PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq);
26826 : 38574 : p->level--;
26827 : 38574 : return _seq;
26828 : : }
26829 : :
26830 : : // _gather_53: with_item _loop0_54
26831 : : static asdl_seq *
26832 : 38594 : _gather_53_rule(Parser *p)
26833 : : {
26834 [ - + ]: 38594 : if (p->level++ == MAXSTACK) {
26835 : 0 : p->error_indicator = 1;
26836 : : PyErr_NoMemory();
26837 : : }
26838 [ - + ]: 38594 : if (p->error_indicator) {
26839 : 0 : p->level--;
26840 : 0 : return NULL;
26841 : : }
26842 : 38594 : asdl_seq * _res = NULL;
26843 : 38594 : int _mark = p->mark;
26844 : : { // with_item _loop0_54
26845 [ - + ]: 38594 : if (p->error_indicator) {
26846 : 0 : p->level--;
26847 : 0 : 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 [ + + ]: 38594 : if (
26853 : 38594 : (elem = with_item_rule(p)) // with_item
26854 [ + - ]: 38574 : &&
26855 : 38574 : (seq = _loop0_54_rule(p)) // _loop0_54
26856 : : )
26857 : : {
26858 : : D(fprintf(stderr, "%*c+ _gather_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_54"));
26859 : 38574 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
26860 : 38574 : goto done;
26861 : : }
26862 : 20 : 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 : 20 : _res = NULL;
26867 : 38594 : done:
26868 : 38594 : p->level--;
26869 : 38594 : return _res;
26870 : : }
26871 : :
26872 : : // _loop0_56: ',' with_item
26873 : : static asdl_seq *
26874 : 1 : _loop0_56_rule(Parser *p)
26875 : : {
26876 [ - + ]: 1 : if (p->level++ == MAXSTACK) {
26877 : 0 : p->error_indicator = 1;
26878 : : PyErr_NoMemory();
26879 : : }
26880 [ - + ]: 1 : if (p->error_indicator) {
26881 : 0 : p->level--;
26882 : 0 : return NULL;
26883 : : }
26884 : 1 : void *_res = NULL;
26885 : 1 : int _mark = p->mark;
26886 : 1 : int _start_mark = p->mark;
26887 : 1 : void **_children = PyMem_Malloc(sizeof(void *));
26888 [ - + ]: 1 : if (!_children) {
26889 : 0 : p->error_indicator = 1;
26890 : : PyErr_NoMemory();
26891 : 0 : p->level--;
26892 : 0 : return NULL;
26893 : : }
26894 : 1 : Py_ssize_t _children_capacity = 1;
26895 : 1 : Py_ssize_t _n = 0;
26896 : : { // ',' with_item
26897 [ - + ]: 1 : if (p->error_indicator) {
26898 : 0 : p->level--;
26899 : 0 : 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 : 1 : while (
26905 : 2 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
26906 [ + + + - ]: 3 : &&
26907 : 1 : (elem = with_item_rule(p)) // with_item
26908 : : )
26909 : : {
26910 : 1 : _res = elem;
26911 [ - + - - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
26912 : 0 : p->error_indicator = 1;
26913 : 0 : PyMem_Free(_children);
26914 : 0 : p->level--;
26915 : 0 : return NULL;
26916 : : }
26917 [ - + ]: 1 : if (_n == _children_capacity) {
26918 : 0 : _children_capacity *= 2;
26919 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26920 [ # # ]: 0 : if (!_new_children) {
26921 : 0 : p->error_indicator = 1;
26922 : : PyErr_NoMemory();
26923 : 0 : p->level--;
26924 : 0 : return NULL;
26925 : : }
26926 : 0 : _children = _new_children;
26927 : : }
26928 : 1 : _children[_n++] = _res;
26929 : 1 : _mark = p->mark;
26930 : : }
26931 : 1 : 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 : 1 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26936 [ - + ]: 1 : if (!_seq) {
26937 : 0 : PyMem_Free(_children);
26938 : 0 : p->error_indicator = 1;
26939 : : PyErr_NoMemory();
26940 : 0 : p->level--;
26941 : 0 : return NULL;
26942 : : }
26943 [ + + ]: 2 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26944 : 1 : PyMem_Free(_children);
26945 : 1 : _PyPegen_insert_memo(p, _start_mark, _loop0_56_type, _seq);
26946 : 1 : p->level--;
26947 : 1 : return _seq;
26948 : : }
26949 : :
26950 : : // _gather_55: with_item _loop0_56
26951 : : static asdl_seq *
26952 : 1 : _gather_55_rule(Parser *p)
26953 : : {
26954 [ - + ]: 1 : if (p->level++ == MAXSTACK) {
26955 : 0 : p->error_indicator = 1;
26956 : : PyErr_NoMemory();
26957 : : }
26958 [ - + ]: 1 : if (p->error_indicator) {
26959 : 0 : p->level--;
26960 : 0 : return NULL;
26961 : : }
26962 : 1 : asdl_seq * _res = NULL;
26963 : 1 : int _mark = p->mark;
26964 : : { // with_item _loop0_56
26965 [ - + ]: 1 : if (p->error_indicator) {
26966 : 0 : p->level--;
26967 : 0 : 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 [ + - ]: 1 : if (
26973 : 1 : (elem = with_item_rule(p)) // with_item
26974 [ + - ]: 1 : &&
26975 : 1 : (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 : 1 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
26980 : 1 : goto done;
26981 : : }
26982 : 0 : 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 : 0 : _res = NULL;
26987 : 1 : done:
26988 : 1 : p->level--;
26989 : 1 : return _res;
26990 : : }
26991 : :
26992 : : // _loop0_58: ',' with_item
26993 : : static asdl_seq *
26994 : 373 : _loop0_58_rule(Parser *p)
26995 : : {
26996 [ - + ]: 373 : if (p->level++ == MAXSTACK) {
26997 : 0 : p->error_indicator = 1;
26998 : : PyErr_NoMemory();
26999 : : }
27000 [ - + ]: 373 : if (p->error_indicator) {
27001 : 0 : p->level--;
27002 : 0 : return NULL;
27003 : : }
27004 : 373 : void *_res = NULL;
27005 : 373 : int _mark = p->mark;
27006 : 373 : int _start_mark = p->mark;
27007 : 373 : void **_children = PyMem_Malloc(sizeof(void *));
27008 [ - + ]: 373 : if (!_children) {
27009 : 0 : p->error_indicator = 1;
27010 : : PyErr_NoMemory();
27011 : 0 : p->level--;
27012 : 0 : return NULL;
27013 : : }
27014 : 373 : Py_ssize_t _children_capacity = 1;
27015 : 373 : Py_ssize_t _n = 0;
27016 : : { // ',' with_item
27017 [ - + ]: 373 : if (p->error_indicator) {
27018 : 0 : p->level--;
27019 : 0 : 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 : 373 : while (
27025 : 392 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
27026 [ + + + - ]: 411 : &&
27027 : 19 : (elem = with_item_rule(p)) // with_item
27028 : : )
27029 : : {
27030 : 19 : _res = elem;
27031 [ - + - - ]: 19 : if (_res == NULL && PyErr_Occurred()) {
27032 : 0 : p->error_indicator = 1;
27033 : 0 : PyMem_Free(_children);
27034 : 0 : p->level--;
27035 : 0 : return NULL;
27036 : : }
27037 [ - + ]: 19 : if (_n == _children_capacity) {
27038 : 0 : _children_capacity *= 2;
27039 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27040 [ # # ]: 0 : if (!_new_children) {
27041 : 0 : p->error_indicator = 1;
27042 : : PyErr_NoMemory();
27043 : 0 : p->level--;
27044 : 0 : return NULL;
27045 : : }
27046 : 0 : _children = _new_children;
27047 : : }
27048 : 19 : _children[_n++] = _res;
27049 : 19 : _mark = p->mark;
27050 : : }
27051 : 373 : 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 : 373 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27056 [ - + ]: 373 : if (!_seq) {
27057 : 0 : PyMem_Free(_children);
27058 : 0 : p->error_indicator = 1;
27059 : : PyErr_NoMemory();
27060 : 0 : p->level--;
27061 : 0 : return NULL;
27062 : : }
27063 [ + + ]: 392 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27064 : 373 : PyMem_Free(_children);
27065 : 373 : _PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq);
27066 : 373 : p->level--;
27067 : 373 : return _seq;
27068 : : }
27069 : :
27070 : : // _gather_57: with_item _loop0_58
27071 : : static asdl_seq *
27072 : 374 : _gather_57_rule(Parser *p)
27073 : : {
27074 [ - + ]: 374 : if (p->level++ == MAXSTACK) {
27075 : 0 : p->error_indicator = 1;
27076 : : PyErr_NoMemory();
27077 : : }
27078 [ - + ]: 374 : if (p->error_indicator) {
27079 : 0 : p->level--;
27080 : 0 : return NULL;
27081 : : }
27082 : 374 : asdl_seq * _res = NULL;
27083 : 374 : int _mark = p->mark;
27084 : : { // with_item _loop0_58
27085 [ - + ]: 374 : if (p->error_indicator) {
27086 : 0 : p->level--;
27087 : 0 : 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 [ + + ]: 374 : if (
27093 : 374 : (elem = with_item_rule(p)) // with_item
27094 [ + - ]: 373 : &&
27095 : 373 : (seq = _loop0_58_rule(p)) // _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 : 373 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
27100 : 373 : goto done;
27101 : : }
27102 : 1 : 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 : 1 : _res = NULL;
27107 : 374 : done:
27108 : 374 : p->level--;
27109 : 374 : return _res;
27110 : : }
27111 : :
27112 : : // _tmp_59: ',' | ')' | ':'
27113 : : static void *
27114 : 16830 : _tmp_59_rule(Parser *p)
27115 : : {
27116 [ - + ]: 16830 : if (p->level++ == MAXSTACK) {
27117 : 0 : p->error_indicator = 1;
27118 : : PyErr_NoMemory();
27119 : : }
27120 [ - + ]: 16830 : if (p->error_indicator) {
27121 : 0 : p->level--;
27122 : 0 : return NULL;
27123 : : }
27124 : 16830 : void * _res = NULL;
27125 : 16830 : int _mark = p->mark;
27126 : : { // ','
27127 [ - + ]: 16830 : if (p->error_indicator) {
27128 : 0 : p->level--;
27129 : 0 : return NULL;
27130 : : }
27131 : : D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
27132 : : Token * _literal;
27133 [ + + ]: 16830 : if (
27134 : 16830 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
27135 : : )
27136 : : {
27137 : : D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
27138 : 484 : _res = _literal;
27139 : 484 : goto done;
27140 : : }
27141 : 16346 : 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 [ - + ]: 16346 : if (p->error_indicator) {
27147 : 0 : p->level--;
27148 : 0 : return NULL;
27149 : : }
27150 : : D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
27151 : : Token * _literal;
27152 [ + + ]: 16346 : if (
27153 : 16346 : (_literal = _PyPegen_expect_token(p, 8)) // token=')'
27154 : : )
27155 : : {
27156 : : D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
27157 : 16 : _res = _literal;
27158 : 16 : goto done;
27159 : : }
27160 : 16330 : 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 [ - + ]: 16330 : if (p->error_indicator) {
27166 : 0 : p->level--;
27167 : 0 : return NULL;
27168 : : }
27169 : : D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
27170 : : Token * _literal;
27171 [ + + ]: 16330 : if (
27172 : 16330 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
27173 : : )
27174 : : {
27175 : : D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
27176 : 16320 : _res = _literal;
27177 : 16320 : goto done;
27178 : : }
27179 : 10 : 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 : 10 : _res = NULL;
27184 : 16830 : done:
27185 : 16830 : p->level--;
27186 : 16830 : return _res;
27187 : : }
27188 : :
27189 : : // _loop1_60: except_block
27190 : : static asdl_seq *
27191 : 41588 : _loop1_60_rule(Parser *p)
27192 : : {
27193 [ - + ]: 41588 : if (p->level++ == MAXSTACK) {
27194 : 0 : p->error_indicator = 1;
27195 : : PyErr_NoMemory();
27196 : : }
27197 [ - + ]: 41588 : if (p->error_indicator) {
27198 : 0 : p->level--;
27199 : 0 : return NULL;
27200 : : }
27201 : 41588 : void *_res = NULL;
27202 : 41588 : int _mark = p->mark;
27203 : 41588 : int _start_mark = p->mark;
27204 : 41588 : void **_children = PyMem_Malloc(sizeof(void *));
27205 [ - + ]: 41588 : if (!_children) {
27206 : 0 : p->error_indicator = 1;
27207 : : PyErr_NoMemory();
27208 : 0 : p->level--;
27209 : 0 : return NULL;
27210 : : }
27211 : 41588 : Py_ssize_t _children_capacity = 1;
27212 : 41588 : Py_ssize_t _n = 0;
27213 : : { // except_block
27214 [ - + ]: 41588 : if (p->error_indicator) {
27215 : 0 : p->level--;
27216 : 0 : 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 : 41588 : while (
27221 [ + + ]: 85530 : (except_block_var = except_block_rule(p)) // except_block
27222 : : )
27223 : : {
27224 : 43942 : _res = except_block_var;
27225 [ + + ]: 43942 : if (_n == _children_capacity) {
27226 : 2434 : _children_capacity *= 2;
27227 : 2434 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27228 [ - + ]: 2434 : if (!_new_children) {
27229 : 0 : p->error_indicator = 1;
27230 : : PyErr_NoMemory();
27231 : 0 : p->level--;
27232 : 0 : return NULL;
27233 : : }
27234 : 2434 : _children = _new_children;
27235 : : }
27236 : 43942 : _children[_n++] = _res;
27237 : 43942 : _mark = p->mark;
27238 : : }
27239 : 41588 : 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 [ + + - + ]: 41588 : if (_n == 0 || p->error_indicator) {
27244 : 297 : PyMem_Free(_children);
27245 : 297 : p->level--;
27246 : 297 : return NULL;
27247 : : }
27248 : 41291 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27249 [ - + ]: 41291 : if (!_seq) {
27250 : 0 : PyMem_Free(_children);
27251 : 0 : p->error_indicator = 1;
27252 : : PyErr_NoMemory();
27253 : 0 : p->level--;
27254 : 0 : return NULL;
27255 : : }
27256 [ + + ]: 85233 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27257 : 41291 : PyMem_Free(_children);
27258 : 41291 : _PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq);
27259 : 41291 : p->level--;
27260 : 41291 : return _seq;
27261 : : }
27262 : :
27263 : : // _loop1_61: except_star_block
27264 : : static asdl_seq *
27265 : 297 : _loop1_61_rule(Parser *p)
27266 : : {
27267 [ - + ]: 297 : if (p->level++ == MAXSTACK) {
27268 : 0 : p->error_indicator = 1;
27269 : : PyErr_NoMemory();
27270 : : }
27271 [ - + ]: 297 : if (p->error_indicator) {
27272 : 0 : p->level--;
27273 : 0 : return NULL;
27274 : : }
27275 : 297 : void *_res = NULL;
27276 : 297 : int _mark = p->mark;
27277 : 297 : int _start_mark = p->mark;
27278 : 297 : void **_children = PyMem_Malloc(sizeof(void *));
27279 [ - + ]: 297 : if (!_children) {
27280 : 0 : p->error_indicator = 1;
27281 : : PyErr_NoMemory();
27282 : 0 : p->level--;
27283 : 0 : return NULL;
27284 : : }
27285 : 297 : Py_ssize_t _children_capacity = 1;
27286 : 297 : Py_ssize_t _n = 0;
27287 : : { // except_star_block
27288 [ - + ]: 297 : if (p->error_indicator) {
27289 : 0 : p->level--;
27290 : 0 : 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 : 297 : while (
27295 [ + + ]: 614 : (except_star_block_var = except_star_block_rule(p)) // except_star_block
27296 : : )
27297 : : {
27298 : 317 : _res = except_star_block_var;
27299 [ + + ]: 317 : if (_n == _children_capacity) {
27300 : 61 : _children_capacity *= 2;
27301 : 61 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27302 [ - + ]: 61 : if (!_new_children) {
27303 : 0 : p->error_indicator = 1;
27304 : : PyErr_NoMemory();
27305 : 0 : p->level--;
27306 : 0 : return NULL;
27307 : : }
27308 : 61 : _children = _new_children;
27309 : : }
27310 : 317 : _children[_n++] = _res;
27311 : 317 : _mark = p->mark;
27312 : : }
27313 : 297 : 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 [ + + - + ]: 297 : if (_n == 0 || p->error_indicator) {
27318 : 41 : PyMem_Free(_children);
27319 : 41 : p->level--;
27320 : 41 : return NULL;
27321 : : }
27322 : 256 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27323 [ - + ]: 256 : if (!_seq) {
27324 : 0 : PyMem_Free(_children);
27325 : 0 : p->error_indicator = 1;
27326 : : PyErr_NoMemory();
27327 : 0 : p->level--;
27328 : 0 : return NULL;
27329 : : }
27330 [ + + ]: 573 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27331 : 256 : PyMem_Free(_children);
27332 : 256 : _PyPegen_insert_memo(p, _start_mark, _loop1_61_type, _seq);
27333 : 256 : p->level--;
27334 : 256 : return _seq;
27335 : : }
27336 : :
27337 : : // _tmp_62: 'as' NAME
27338 : : static void *
27339 : 41811 : _tmp_62_rule(Parser *p)
27340 : : {
27341 [ - + ]: 41811 : if (p->level++ == MAXSTACK) {
27342 : 0 : p->error_indicator = 1;
27343 : : PyErr_NoMemory();
27344 : : }
27345 [ - + ]: 41811 : if (p->error_indicator) {
27346 : 0 : p->level--;
27347 : 0 : return NULL;
27348 : : }
27349 : 41811 : void * _res = NULL;
27350 : 41811 : int _mark = p->mark;
27351 : : { // 'as' NAME
27352 [ - + ]: 41811 : if (p->error_indicator) {
27353 : 0 : p->level--;
27354 : 0 : 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 [ + + ]: 41811 : if (
27360 : 41811 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
27361 [ + - ]: 9001 : &&
27362 : 9001 : (z = _PyPegen_name_token(p)) // NAME
27363 : : )
27364 : : {
27365 : : D(fprintf(stderr, "%*c+ _tmp_62[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
27366 : 9001 : _res = z;
27367 [ - + - - ]: 9001 : if (_res == NULL && PyErr_Occurred()) {
27368 : 0 : p->error_indicator = 1;
27369 : 0 : p->level--;
27370 : 0 : return NULL;
27371 : : }
27372 : 9001 : goto done;
27373 : : }
27374 : 32810 : 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 : 32810 : _res = NULL;
27379 : 41811 : done:
27380 : 41811 : p->level--;
27381 : 41811 : return _res;
27382 : : }
27383 : :
27384 : : // _tmp_63: 'as' NAME
27385 : : static void *
27386 : 339 : _tmp_63_rule(Parser *p)
27387 : : {
27388 [ - + ]: 339 : if (p->level++ == MAXSTACK) {
27389 : 0 : p->error_indicator = 1;
27390 : : PyErr_NoMemory();
27391 : : }
27392 [ - + ]: 339 : if (p->error_indicator) {
27393 : 0 : p->level--;
27394 : 0 : return NULL;
27395 : : }
27396 : 339 : void * _res = NULL;
27397 : 339 : int _mark = p->mark;
27398 : : { // 'as' NAME
27399 [ - + ]: 339 : if (p->error_indicator) {
27400 : 0 : p->level--;
27401 : 0 : 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 [ + + ]: 339 : if (
27407 : 339 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
27408 [ + - ]: 129 : &&
27409 : 129 : (z = _PyPegen_name_token(p)) // NAME
27410 : : )
27411 : : {
27412 : : D(fprintf(stderr, "%*c+ _tmp_63[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
27413 : 129 : _res = z;
27414 [ - + - - ]: 129 : if (_res == NULL && PyErr_Occurred()) {
27415 : 0 : p->error_indicator = 1;
27416 : 0 : p->level--;
27417 : 0 : return NULL;
27418 : : }
27419 : 129 : goto done;
27420 : : }
27421 : 210 : 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 : 210 : _res = NULL;
27426 : 339 : done:
27427 : 339 : p->level--;
27428 : 339 : return _res;
27429 : : }
27430 : :
27431 : : // _loop1_64: case_block
27432 : : static asdl_seq *
27433 : 1269 : _loop1_64_rule(Parser *p)
27434 : : {
27435 [ - + ]: 1269 : if (p->level++ == MAXSTACK) {
27436 : 0 : p->error_indicator = 1;
27437 : : PyErr_NoMemory();
27438 : : }
27439 [ - + ]: 1269 : if (p->error_indicator) {
27440 : 0 : p->level--;
27441 : 0 : return NULL;
27442 : : }
27443 : 1269 : void *_res = NULL;
27444 : 1269 : int _mark = p->mark;
27445 : 1269 : int _start_mark = p->mark;
27446 : 1269 : void **_children = PyMem_Malloc(sizeof(void *));
27447 [ - + ]: 1269 : if (!_children) {
27448 : 0 : p->error_indicator = 1;
27449 : : PyErr_NoMemory();
27450 : 0 : p->level--;
27451 : 0 : return NULL;
27452 : : }
27453 : 1269 : Py_ssize_t _children_capacity = 1;
27454 : 1269 : Py_ssize_t _n = 0;
27455 : : { // case_block
27456 [ - + ]: 1269 : if (p->error_indicator) {
27457 : 0 : p->level--;
27458 : 0 : 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 : 1269 : while (
27463 [ + + ]: 3053 : (case_block_var = case_block_rule(p)) // case_block
27464 : : )
27465 : : {
27466 : 1784 : _res = case_block_var;
27467 [ + + ]: 1784 : if (_n == _children_capacity) {
27468 : 515 : _children_capacity *= 2;
27469 : 515 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27470 [ - + ]: 515 : if (!_new_children) {
27471 : 0 : p->error_indicator = 1;
27472 : : PyErr_NoMemory();
27473 : 0 : p->level--;
27474 : 0 : return NULL;
27475 : : }
27476 : 515 : _children = _new_children;
27477 : : }
27478 : 1784 : _children[_n++] = _res;
27479 : 1784 : _mark = p->mark;
27480 : : }
27481 : 1269 : 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 [ + + + + ]: 1269 : if (_n == 0 || p->error_indicator) {
27486 : 45 : PyMem_Free(_children);
27487 : 45 : p->level--;
27488 : 45 : return NULL;
27489 : : }
27490 : 1224 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27491 [ - + ]: 1224 : if (!_seq) {
27492 : 0 : PyMem_Free(_children);
27493 : 0 : p->error_indicator = 1;
27494 : : PyErr_NoMemory();
27495 : 0 : p->level--;
27496 : 0 : return NULL;
27497 : : }
27498 [ + + ]: 3007 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27499 : 1224 : PyMem_Free(_children);
27500 : 1224 : _PyPegen_insert_memo(p, _start_mark, _loop1_64_type, _seq);
27501 : 1224 : p->level--;
27502 : 1224 : return _seq;
27503 : : }
27504 : :
27505 : : // _loop0_66: '|' closed_pattern
27506 : : static asdl_seq *
27507 : 12645 : _loop0_66_rule(Parser *p)
27508 : : {
27509 [ - + ]: 12645 : if (p->level++ == MAXSTACK) {
27510 : 0 : p->error_indicator = 1;
27511 : : PyErr_NoMemory();
27512 : : }
27513 [ - + ]: 12645 : if (p->error_indicator) {
27514 : 0 : p->level--;
27515 : 0 : return NULL;
27516 : : }
27517 : 12645 : void *_res = NULL;
27518 : 12645 : int _mark = p->mark;
27519 : 12645 : int _start_mark = p->mark;
27520 : 12645 : void **_children = PyMem_Malloc(sizeof(void *));
27521 [ - + ]: 12645 : if (!_children) {
27522 : 0 : p->error_indicator = 1;
27523 : : PyErr_NoMemory();
27524 : 0 : p->level--;
27525 : 0 : return NULL;
27526 : : }
27527 : 12645 : Py_ssize_t _children_capacity = 1;
27528 : 12645 : Py_ssize_t _n = 0;
27529 : : { // '|' closed_pattern
27530 [ - + ]: 12645 : if (p->error_indicator) {
27531 : 0 : p->level--;
27532 : 0 : 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 : 12645 : while (
27538 : 13873 : (_literal = _PyPegen_expect_token(p, 18)) // token='|'
27539 [ + + + - ]: 15101 : &&
27540 : 1228 : (elem = closed_pattern_rule(p)) // closed_pattern
27541 : : )
27542 : : {
27543 : 1228 : _res = elem;
27544 [ - + - - ]: 1228 : if (_res == NULL && PyErr_Occurred()) {
27545 : 0 : p->error_indicator = 1;
27546 : 0 : PyMem_Free(_children);
27547 : 0 : p->level--;
27548 : 0 : return NULL;
27549 : : }
27550 [ + + ]: 1228 : if (_n == _children_capacity) {
27551 : 506 : _children_capacity *= 2;
27552 : 506 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27553 [ - + ]: 506 : if (!_new_children) {
27554 : 0 : p->error_indicator = 1;
27555 : : PyErr_NoMemory();
27556 : 0 : p->level--;
27557 : 0 : return NULL;
27558 : : }
27559 : 506 : _children = _new_children;
27560 : : }
27561 : 1228 : _children[_n++] = _res;
27562 : 1228 : _mark = p->mark;
27563 : : }
27564 : 12645 : 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 : 12645 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27569 [ - + ]: 12645 : if (!_seq) {
27570 : 0 : PyMem_Free(_children);
27571 : 0 : p->error_indicator = 1;
27572 : : PyErr_NoMemory();
27573 : 0 : p->level--;
27574 : 0 : return NULL;
27575 : : }
27576 [ + + ]: 13873 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27577 : 12645 : PyMem_Free(_children);
27578 : 12645 : _PyPegen_insert_memo(p, _start_mark, _loop0_66_type, _seq);
27579 : 12645 : p->level--;
27580 : 12645 : return _seq;
27581 : : }
27582 : :
27583 : : // _gather_65: closed_pattern _loop0_66
27584 : : static asdl_seq *
27585 : 13517 : _gather_65_rule(Parser *p)
27586 : : {
27587 [ - + ]: 13517 : if (p->level++ == MAXSTACK) {
27588 : 0 : p->error_indicator = 1;
27589 : : PyErr_NoMemory();
27590 : : }
27591 [ - + ]: 13517 : if (p->error_indicator) {
27592 : 0 : p->level--;
27593 : 0 : return NULL;
27594 : : }
27595 : 13517 : asdl_seq * _res = NULL;
27596 : 13517 : int _mark = p->mark;
27597 : : { // closed_pattern _loop0_66
27598 [ - + ]: 13517 : if (p->error_indicator) {
27599 : 0 : p->level--;
27600 : 0 : 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 [ + + ]: 13517 : if (
27606 : 13517 : (elem = closed_pattern_rule(p)) // closed_pattern
27607 [ + - ]: 12645 : &&
27608 : 12645 : (seq = _loop0_66_rule(p)) // _loop0_66
27609 : : )
27610 : : {
27611 : : D(fprintf(stderr, "%*c+ _gather_65[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "closed_pattern _loop0_66"));
27612 : 12645 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
27613 : 12645 : goto done;
27614 : : }
27615 : 872 : 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 : 872 : _res = NULL;
27620 : 13517 : done:
27621 : 13517 : p->level--;
27622 : 13517 : return _res;
27623 : : }
27624 : :
27625 : : // _tmp_67: '+' | '-'
27626 : : static void *
27627 : 1353 : _tmp_67_rule(Parser *p)
27628 : : {
27629 [ - + ]: 1353 : if (p->level++ == MAXSTACK) {
27630 : 0 : p->error_indicator = 1;
27631 : : PyErr_NoMemory();
27632 : : }
27633 [ - + ]: 1353 : if (p->error_indicator) {
27634 : 0 : p->level--;
27635 : 0 : return NULL;
27636 : : }
27637 : 1353 : void * _res = NULL;
27638 : 1353 : int _mark = p->mark;
27639 : : { // '+'
27640 [ - + ]: 1353 : if (p->error_indicator) {
27641 : 0 : p->level--;
27642 : 0 : return NULL;
27643 : : }
27644 : : D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'"));
27645 : : Token * _literal;
27646 [ + + ]: 1353 : if (
27647 : 1353 : (_literal = _PyPegen_expect_token(p, 14)) // token='+'
27648 : : )
27649 : : {
27650 : : D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'"));
27651 : 23 : _res = _literal;
27652 : 23 : goto done;
27653 : : }
27654 : 1330 : 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 [ - + ]: 1330 : if (p->error_indicator) {
27660 : 0 : p->level--;
27661 : 0 : return NULL;
27662 : : }
27663 : : D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'"));
27664 : : Token * _literal;
27665 [ + + ]: 1330 : if (
27666 : 1330 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
27667 : : )
27668 : : {
27669 : : D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'"));
27670 : 20 : _res = _literal;
27671 : 20 : goto done;
27672 : : }
27673 : 1310 : 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 : 1310 : _res = NULL;
27678 : 1353 : done:
27679 : 1353 : p->level--;
27680 : 1353 : return _res;
27681 : : }
27682 : :
27683 : : // _tmp_68: '+' | '-'
27684 : : static void *
27685 : 581 : _tmp_68_rule(Parser *p)
27686 : : {
27687 [ - + ]: 581 : if (p->level++ == MAXSTACK) {
27688 : 0 : p->error_indicator = 1;
27689 : : PyErr_NoMemory();
27690 : : }
27691 [ - + ]: 581 : if (p->error_indicator) {
27692 : 0 : p->level--;
27693 : 0 : return NULL;
27694 : : }
27695 : 581 : void * _res = NULL;
27696 : 581 : int _mark = p->mark;
27697 : : { // '+'
27698 [ - + ]: 581 : if (p->error_indicator) {
27699 : 0 : p->level--;
27700 : 0 : return NULL;
27701 : : }
27702 : : D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'"));
27703 : : Token * _literal;
27704 [ + + ]: 581 : if (
27705 : 581 : (_literal = _PyPegen_expect_token(p, 14)) // token='+'
27706 : : )
27707 : : {
27708 : : D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'"));
27709 : 3 : _res = _literal;
27710 : 3 : goto done;
27711 : : }
27712 : 578 : 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 [ - + ]: 578 : if (p->error_indicator) {
27718 : 0 : p->level--;
27719 : 0 : return NULL;
27720 : : }
27721 : : D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'"));
27722 : : Token * _literal;
27723 [ + + ]: 578 : if (
27724 : 578 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
27725 : : )
27726 : : {
27727 : : D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'"));
27728 : 8 : _res = _literal;
27729 : 8 : goto done;
27730 : : }
27731 : 570 : 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 : 570 : _res = NULL;
27736 : 581 : done:
27737 : 581 : p->level--;
27738 : 581 : return _res;
27739 : : }
27740 : :
27741 : : // _tmp_69: '.' | '(' | '='
27742 : : static void *
27743 : 1820 : _tmp_69_rule(Parser *p)
27744 : : {
27745 [ - + ]: 1820 : if (p->level++ == MAXSTACK) {
27746 : 0 : p->error_indicator = 1;
27747 : : PyErr_NoMemory();
27748 : : }
27749 [ - + ]: 1820 : if (p->error_indicator) {
27750 : 0 : p->level--;
27751 : 0 : return NULL;
27752 : : }
27753 : 1820 : void * _res = NULL;
27754 : 1820 : int _mark = p->mark;
27755 : : { // '.'
27756 [ - + ]: 1820 : if (p->error_indicator) {
27757 : 0 : p->level--;
27758 : 0 : return NULL;
27759 : : }
27760 : : D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
27761 : : Token * _literal;
27762 [ + + ]: 1820 : if (
27763 : 1820 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
27764 : : )
27765 : : {
27766 : : D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
27767 : 111 : _res = _literal;
27768 : 111 : goto done;
27769 : : }
27770 : 1709 : 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 [ - + ]: 1709 : if (p->error_indicator) {
27776 : 0 : p->level--;
27777 : 0 : return NULL;
27778 : : }
27779 : : D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
27780 : : Token * _literal;
27781 [ + + ]: 1709 : if (
27782 : 1709 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
27783 : : )
27784 : : {
27785 : : D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
27786 : 249 : _res = _literal;
27787 : 249 : goto done;
27788 : : }
27789 : 1460 : 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 [ - + ]: 1460 : if (p->error_indicator) {
27795 : 0 : p->level--;
27796 : 0 : return NULL;
27797 : : }
27798 : : D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
27799 : : Token * _literal;
27800 [ + + ]: 1460 : if (
27801 : 1460 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
27802 : : )
27803 : : {
27804 : : D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));
27805 : 77 : _res = _literal;
27806 : 77 : goto done;
27807 : : }
27808 : 1383 : 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 : 1383 : _res = NULL;
27813 : 1820 : done:
27814 : 1820 : p->level--;
27815 : 1820 : return _res;
27816 : : }
27817 : :
27818 : : // _tmp_70: '.' | '(' | '='
27819 : : static void *
27820 : 111 : _tmp_70_rule(Parser *p)
27821 : : {
27822 [ - + ]: 111 : if (p->level++ == MAXSTACK) {
27823 : 0 : p->error_indicator = 1;
27824 : : PyErr_NoMemory();
27825 : : }
27826 [ - + ]: 111 : if (p->error_indicator) {
27827 : 0 : p->level--;
27828 : 0 : return NULL;
27829 : : }
27830 : 111 : void * _res = NULL;
27831 : 111 : int _mark = p->mark;
27832 : : { // '.'
27833 [ - + ]: 111 : if (p->error_indicator) {
27834 : 0 : p->level--;
27835 : 0 : return NULL;
27836 : : }
27837 : : D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
27838 : : Token * _literal;
27839 [ - + ]: 111 : if (
27840 : 111 : (_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 : 0 : _res = _literal;
27845 : 0 : goto done;
27846 : : }
27847 : 111 : 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 [ - + ]: 111 : if (p->error_indicator) {
27853 : 0 : p->level--;
27854 : 0 : return NULL;
27855 : : }
27856 : : D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
27857 : : Token * _literal;
27858 [ + + ]: 111 : if (
27859 : 111 : (_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 : 51 : _res = _literal;
27864 : 51 : goto done;
27865 : : }
27866 : 60 : 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 [ - + ]: 60 : if (p->error_indicator) {
27872 : 0 : p->level--;
27873 : 0 : return NULL;
27874 : : }
27875 : : D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
27876 : : Token * _literal;
27877 [ - + ]: 60 : if (
27878 : 60 : (_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 : 0 : _res = _literal;
27883 : 0 : goto done;
27884 : : }
27885 : 60 : 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 : 60 : _res = NULL;
27890 : 111 : done:
27891 : 111 : p->level--;
27892 : 111 : return _res;
27893 : : }
27894 : :
27895 : : // _loop0_72: ',' maybe_star_pattern
27896 : : static asdl_seq *
27897 : 627 : _loop0_72_rule(Parser *p)
27898 : : {
27899 [ - + ]: 627 : if (p->level++ == MAXSTACK) {
27900 : 0 : p->error_indicator = 1;
27901 : : PyErr_NoMemory();
27902 : : }
27903 [ - + ]: 627 : if (p->error_indicator) {
27904 : 0 : p->level--;
27905 : 0 : return NULL;
27906 : : }
27907 : 627 : void *_res = NULL;
27908 : 627 : int _mark = p->mark;
27909 : 627 : int _start_mark = p->mark;
27910 : 627 : void **_children = PyMem_Malloc(sizeof(void *));
27911 [ - + ]: 627 : if (!_children) {
27912 : 0 : p->error_indicator = 1;
27913 : : PyErr_NoMemory();
27914 : 0 : p->level--;
27915 : 0 : return NULL;
27916 : : }
27917 : 627 : Py_ssize_t _children_capacity = 1;
27918 : 627 : Py_ssize_t _n = 0;
27919 : : { // ',' maybe_star_pattern
27920 [ - + ]: 627 : if (p->error_indicator) {
27921 : 0 : p->level--;
27922 : 0 : 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 : 627 : while (
27928 : 1371 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
27929 [ + + + + ]: 2142 : &&
27930 : 771 : (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern
27931 : : )
27932 : : {
27933 : 744 : _res = elem;
27934 [ - + - - ]: 744 : if (_res == NULL && PyErr_Occurred()) {
27935 : 0 : p->error_indicator = 1;
27936 : 0 : PyMem_Free(_children);
27937 : 0 : p->level--;
27938 : 0 : return NULL;
27939 : : }
27940 [ + + ]: 744 : if (_n == _children_capacity) {
27941 : 272 : _children_capacity *= 2;
27942 : 272 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27943 [ - + ]: 272 : if (!_new_children) {
27944 : 0 : p->error_indicator = 1;
27945 : : PyErr_NoMemory();
27946 : 0 : p->level--;
27947 : 0 : return NULL;
27948 : : }
27949 : 272 : _children = _new_children;
27950 : : }
27951 : 744 : _children[_n++] = _res;
27952 : 744 : _mark = p->mark;
27953 : : }
27954 : 627 : 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 : 627 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27959 [ - + ]: 627 : if (!_seq) {
27960 : 0 : PyMem_Free(_children);
27961 : 0 : p->error_indicator = 1;
27962 : : PyErr_NoMemory();
27963 : 0 : p->level--;
27964 : 0 : return NULL;
27965 : : }
27966 [ + + ]: 1371 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27967 : 627 : PyMem_Free(_children);
27968 : 627 : _PyPegen_insert_memo(p, _start_mark, _loop0_72_type, _seq);
27969 : 627 : p->level--;
27970 : 627 : return _seq;
27971 : : }
27972 : :
27973 : : // _gather_71: maybe_star_pattern _loop0_72
27974 : : static asdl_seq *
27975 : 753 : _gather_71_rule(Parser *p)
27976 : : {
27977 [ - + ]: 753 : if (p->level++ == MAXSTACK) {
27978 : 0 : p->error_indicator = 1;
27979 : : PyErr_NoMemory();
27980 : : }
27981 [ - + ]: 753 : if (p->error_indicator) {
27982 : 0 : p->level--;
27983 : 0 : return NULL;
27984 : : }
27985 : 753 : asdl_seq * _res = NULL;
27986 : 753 : int _mark = p->mark;
27987 : : { // maybe_star_pattern _loop0_72
27988 [ - + ]: 753 : if (p->error_indicator) {
27989 : 0 : p->level--;
27990 : 0 : 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 [ + + ]: 753 : if (
27996 : 753 : (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern
27997 [ + - ]: 627 : &&
27998 : 627 : (seq = _loop0_72_rule(p)) // _loop0_72
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 : 627 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28003 : 627 : goto done;
28004 : : }
28005 : 126 : 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 : 126 : _res = NULL;
28010 : 753 : done:
28011 : 753 : p->level--;
28012 : 753 : return _res;
28013 : : }
28014 : :
28015 : : // _loop0_74: ',' key_value_pattern
28016 : : static asdl_seq *
28017 : 622 : _loop0_74_rule(Parser *p)
28018 : : {
28019 [ - + ]: 622 : if (p->level++ == MAXSTACK) {
28020 : 0 : p->error_indicator = 1;
28021 : : PyErr_NoMemory();
28022 : : }
28023 [ - + ]: 622 : if (p->error_indicator) {
28024 : 0 : p->level--;
28025 : 0 : return NULL;
28026 : : }
28027 : 622 : void *_res = NULL;
28028 : 622 : int _mark = p->mark;
28029 : 622 : int _start_mark = p->mark;
28030 : 622 : void **_children = PyMem_Malloc(sizeof(void *));
28031 [ - + ]: 622 : if (!_children) {
28032 : 0 : p->error_indicator = 1;
28033 : : PyErr_NoMemory();
28034 : 0 : p->level--;
28035 : 0 : return NULL;
28036 : : }
28037 : 622 : Py_ssize_t _children_capacity = 1;
28038 : 622 : Py_ssize_t _n = 0;
28039 : : { // ',' key_value_pattern
28040 [ - + ]: 622 : if (p->error_indicator) {
28041 : 0 : p->level--;
28042 : 0 : 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 : 622 : while (
28048 : 762 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
28049 [ + + + + ]: 926 : &&
28050 : 164 : (elem = key_value_pattern_rule(p)) // key_value_pattern
28051 : : )
28052 : : {
28053 : 140 : _res = elem;
28054 [ - + - - ]: 140 : if (_res == NULL && PyErr_Occurred()) {
28055 : 0 : p->error_indicator = 1;
28056 : 0 : PyMem_Free(_children);
28057 : 0 : p->level--;
28058 : 0 : return NULL;
28059 : : }
28060 [ + + ]: 140 : if (_n == _children_capacity) {
28061 : 24 : _children_capacity *= 2;
28062 : 24 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28063 [ - + ]: 24 : if (!_new_children) {
28064 : 0 : p->error_indicator = 1;
28065 : : PyErr_NoMemory();
28066 : 0 : p->level--;
28067 : 0 : return NULL;
28068 : : }
28069 : 24 : _children = _new_children;
28070 : : }
28071 : 140 : _children[_n++] = _res;
28072 : 140 : _mark = p->mark;
28073 : : }
28074 : 622 : 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 : 622 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28079 [ - + ]: 622 : if (!_seq) {
28080 : 0 : PyMem_Free(_children);
28081 : 0 : p->error_indicator = 1;
28082 : : PyErr_NoMemory();
28083 : 0 : p->level--;
28084 : 0 : return NULL;
28085 : : }
28086 [ + + ]: 762 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28087 : 622 : PyMem_Free(_children);
28088 : 622 : _PyPegen_insert_memo(p, _start_mark, _loop0_74_type, _seq);
28089 : 622 : p->level--;
28090 : 622 : return _seq;
28091 : : }
28092 : :
28093 : : // _gather_73: key_value_pattern _loop0_74
28094 : : static asdl_seq *
28095 : 645 : _gather_73_rule(Parser *p)
28096 : : {
28097 [ - + ]: 645 : if (p->level++ == MAXSTACK) {
28098 : 0 : p->error_indicator = 1;
28099 : : PyErr_NoMemory();
28100 : : }
28101 [ - + ]: 645 : if (p->error_indicator) {
28102 : 0 : p->level--;
28103 : 0 : return NULL;
28104 : : }
28105 : 645 : asdl_seq * _res = NULL;
28106 : 645 : int _mark = p->mark;
28107 : : { // key_value_pattern _loop0_74
28108 [ - + ]: 645 : if (p->error_indicator) {
28109 : 0 : p->level--;
28110 : 0 : 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 [ + + ]: 645 : if (
28116 : 645 : (elem = key_value_pattern_rule(p)) // key_value_pattern
28117 [ + - ]: 622 : &&
28118 : 622 : (seq = _loop0_74_rule(p)) // _loop0_74
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 : 622 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28123 : 622 : goto done;
28124 : : }
28125 : 23 : 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 : 23 : _res = NULL;
28130 : 645 : done:
28131 : 645 : p->level--;
28132 : 645 : return _res;
28133 : : }
28134 : :
28135 : : // _tmp_75: literal_expr | attr
28136 : : static void *
28137 : 809 : _tmp_75_rule(Parser *p)
28138 : : {
28139 [ - + ]: 809 : if (p->level++ == MAXSTACK) {
28140 : 0 : p->error_indicator = 1;
28141 : : PyErr_NoMemory();
28142 : : }
28143 [ - + ]: 809 : if (p->error_indicator) {
28144 : 0 : p->level--;
28145 : 0 : return NULL;
28146 : : }
28147 : 809 : void * _res = NULL;
28148 : 809 : int _mark = p->mark;
28149 : : { // literal_expr
28150 [ - + ]: 809 : if (p->error_indicator) {
28151 : 0 : p->level--;
28152 : 0 : 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 [ + + ]: 809 : if (
28157 : 809 : (literal_expr_var = literal_expr_rule(p)) // literal_expr
28158 : : )
28159 : : {
28160 : : D(fprintf(stderr, "%*c+ _tmp_75[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_expr"));
28161 : 754 : _res = literal_expr_var;
28162 : 754 : goto done;
28163 : : }
28164 : 55 : 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 [ + + ]: 55 : if (p->error_indicator) {
28170 : 3 : p->level--;
28171 : 3 : 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 [ + + ]: 52 : if (
28176 : 52 : (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 : 8 : _res = attr_var;
28181 : 8 : goto done;
28182 : : }
28183 : 44 : 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 : 44 : _res = NULL;
28188 : 806 : done:
28189 : 806 : p->level--;
28190 : 806 : return _res;
28191 : : }
28192 : :
28193 : : // _loop0_77: ',' pattern
28194 : : static asdl_seq *
28195 : 276 : _loop0_77_rule(Parser *p)
28196 : : {
28197 [ - + ]: 276 : if (p->level++ == MAXSTACK) {
28198 : 0 : p->error_indicator = 1;
28199 : : PyErr_NoMemory();
28200 : : }
28201 [ - + ]: 276 : if (p->error_indicator) {
28202 : 0 : p->level--;
28203 : 0 : return NULL;
28204 : : }
28205 : 276 : void *_res = NULL;
28206 : 276 : int _mark = p->mark;
28207 : 276 : int _start_mark = p->mark;
28208 : 276 : void **_children = PyMem_Malloc(sizeof(void *));
28209 [ - + ]: 276 : if (!_children) {
28210 : 0 : p->error_indicator = 1;
28211 : : PyErr_NoMemory();
28212 : 0 : p->level--;
28213 : 0 : return NULL;
28214 : : }
28215 : 276 : Py_ssize_t _children_capacity = 1;
28216 : 276 : Py_ssize_t _n = 0;
28217 : : { // ',' pattern
28218 [ - + ]: 276 : if (p->error_indicator) {
28219 : 0 : p->level--;
28220 : 0 : 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 : 276 : while (
28226 : 373 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
28227 [ + + + + ]: 559 : &&
28228 : 186 : (elem = pattern_rule(p)) // pattern
28229 : : )
28230 : : {
28231 : 97 : _res = elem;
28232 [ - + - - ]: 97 : if (_res == NULL && PyErr_Occurred()) {
28233 : 0 : p->error_indicator = 1;
28234 : 0 : PyMem_Free(_children);
28235 : 0 : p->level--;
28236 : 0 : return NULL;
28237 : : }
28238 [ + + ]: 97 : if (_n == _children_capacity) {
28239 : 8 : _children_capacity *= 2;
28240 : 8 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28241 [ - + ]: 8 : if (!_new_children) {
28242 : 0 : p->error_indicator = 1;
28243 : : PyErr_NoMemory();
28244 : 0 : p->level--;
28245 : 0 : return NULL;
28246 : : }
28247 : 8 : _children = _new_children;
28248 : : }
28249 : 97 : _children[_n++] = _res;
28250 : 97 : _mark = p->mark;
28251 : : }
28252 : 276 : 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 : 276 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28257 [ - + ]: 276 : if (!_seq) {
28258 : 0 : PyMem_Free(_children);
28259 : 0 : p->error_indicator = 1;
28260 : : PyErr_NoMemory();
28261 : 0 : p->level--;
28262 : 0 : return NULL;
28263 : : }
28264 [ + + ]: 373 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28265 : 276 : PyMem_Free(_children);
28266 : 276 : _PyPegen_insert_memo(p, _start_mark, _loop0_77_type, _seq);
28267 : 276 : p->level--;
28268 : 276 : return _seq;
28269 : : }
28270 : :
28271 : : // _gather_76: pattern _loop0_77
28272 : : static asdl_seq *
28273 : 317 : _gather_76_rule(Parser *p)
28274 : : {
28275 [ - + ]: 317 : if (p->level++ == MAXSTACK) {
28276 : 0 : p->error_indicator = 1;
28277 : : PyErr_NoMemory();
28278 : : }
28279 [ - + ]: 317 : if (p->error_indicator) {
28280 : 0 : p->level--;
28281 : 0 : return NULL;
28282 : : }
28283 : 317 : asdl_seq * _res = NULL;
28284 : 317 : int _mark = p->mark;
28285 : : { // pattern _loop0_77
28286 [ - + ]: 317 : if (p->error_indicator) {
28287 : 0 : p->level--;
28288 : 0 : 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 [ + + ]: 317 : if (
28294 : 317 : (elem = pattern_rule(p)) // pattern
28295 [ + - ]: 276 : &&
28296 : 276 : (seq = _loop0_77_rule(p)) // _loop0_77
28297 : : )
28298 : : {
28299 : : D(fprintf(stderr, "%*c+ _gather_76[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern _loop0_77"));
28300 : 276 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28301 : 276 : goto done;
28302 : : }
28303 : 41 : 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 : 41 : _res = NULL;
28308 : 317 : done:
28309 : 317 : p->level--;
28310 : 317 : return _res;
28311 : : }
28312 : :
28313 : : // _loop0_79: ',' keyword_pattern
28314 : : static asdl_seq *
28315 : 79 : _loop0_79_rule(Parser *p)
28316 : : {
28317 [ - + ]: 79 : if (p->level++ == MAXSTACK) {
28318 : 0 : p->error_indicator = 1;
28319 : : PyErr_NoMemory();
28320 : : }
28321 [ - + ]: 79 : if (p->error_indicator) {
28322 : 0 : p->level--;
28323 : 0 : return NULL;
28324 : : }
28325 : 79 : void *_res = NULL;
28326 : 79 : int _mark = p->mark;
28327 : 79 : int _start_mark = p->mark;
28328 : 79 : void **_children = PyMem_Malloc(sizeof(void *));
28329 [ - + ]: 79 : if (!_children) {
28330 : 0 : p->error_indicator = 1;
28331 : : PyErr_NoMemory();
28332 : 0 : p->level--;
28333 : 0 : return NULL;
28334 : : }
28335 : 79 : Py_ssize_t _children_capacity = 1;
28336 : 79 : Py_ssize_t _n = 0;
28337 : : { // ',' keyword_pattern
28338 [ - + ]: 79 : if (p->error_indicator) {
28339 : 0 : p->level--;
28340 : 0 : 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 : 79 : while (
28346 : 123 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
28347 [ + + + + ]: 179 : &&
28348 : 56 : (elem = keyword_pattern_rule(p)) // keyword_pattern
28349 : : )
28350 : : {
28351 : 44 : _res = elem;
28352 [ - + - - ]: 44 : if (_res == NULL && PyErr_Occurred()) {
28353 : 0 : p->error_indicator = 1;
28354 : 0 : PyMem_Free(_children);
28355 : 0 : p->level--;
28356 : 0 : return NULL;
28357 : : }
28358 [ + + ]: 44 : if (_n == _children_capacity) {
28359 : 8 : _children_capacity *= 2;
28360 : 8 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28361 [ - + ]: 8 : if (!_new_children) {
28362 : 0 : p->error_indicator = 1;
28363 : : PyErr_NoMemory();
28364 : 0 : p->level--;
28365 : 0 : return NULL;
28366 : : }
28367 : 8 : _children = _new_children;
28368 : : }
28369 : 44 : _children[_n++] = _res;
28370 : 44 : _mark = p->mark;
28371 : : }
28372 : 79 : 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 : 79 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28377 [ - + ]: 79 : if (!_seq) {
28378 : 0 : PyMem_Free(_children);
28379 : 0 : p->error_indicator = 1;
28380 : : PyErr_NoMemory();
28381 : 0 : p->level--;
28382 : 0 : return NULL;
28383 : : }
28384 [ + + ]: 123 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28385 : 79 : PyMem_Free(_children);
28386 : 79 : _PyPegen_insert_memo(p, _start_mark, _loop0_79_type, _seq);
28387 : 79 : p->level--;
28388 : 79 : return _seq;
28389 : : }
28390 : :
28391 : : // _gather_78: keyword_pattern _loop0_79
28392 : : static asdl_seq *
28393 : 122 : _gather_78_rule(Parser *p)
28394 : : {
28395 [ - + ]: 122 : if (p->level++ == MAXSTACK) {
28396 : 0 : p->error_indicator = 1;
28397 : : PyErr_NoMemory();
28398 : : }
28399 [ - + ]: 122 : if (p->error_indicator) {
28400 : 0 : p->level--;
28401 : 0 : return NULL;
28402 : : }
28403 : 122 : asdl_seq * _res = NULL;
28404 : 122 : int _mark = p->mark;
28405 : : { // keyword_pattern _loop0_79
28406 [ - + ]: 122 : if (p->error_indicator) {
28407 : 0 : p->level--;
28408 : 0 : 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 [ + + ]: 122 : if (
28414 : 122 : (elem = keyword_pattern_rule(p)) // keyword_pattern
28415 [ + - ]: 79 : &&
28416 : 79 : (seq = _loop0_79_rule(p)) // _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 : 79 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28421 : 79 : goto done;
28422 : : }
28423 : 43 : 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 : 43 : _res = NULL;
28428 : 122 : done:
28429 : 122 : p->level--;
28430 : 122 : return _res;
28431 : : }
28432 : :
28433 : : // _loop1_80: (',' expression)
28434 : : static asdl_seq *
28435 : 72089 : _loop1_80_rule(Parser *p)
28436 : : {
28437 [ - + ]: 72089 : if (p->level++ == MAXSTACK) {
28438 : 0 : p->error_indicator = 1;
28439 : : PyErr_NoMemory();
28440 : : }
28441 [ - + ]: 72089 : if (p->error_indicator) {
28442 : 0 : p->level--;
28443 : 0 : return NULL;
28444 : : }
28445 : 72089 : void *_res = NULL;
28446 : 72089 : int _mark = p->mark;
28447 : 72089 : int _start_mark = p->mark;
28448 : 72089 : void **_children = PyMem_Malloc(sizeof(void *));
28449 [ - + ]: 72089 : if (!_children) {
28450 : 0 : p->error_indicator = 1;
28451 : : PyErr_NoMemory();
28452 : 0 : p->level--;
28453 : 0 : return NULL;
28454 : : }
28455 : 72089 : Py_ssize_t _children_capacity = 1;
28456 : 72089 : Py_ssize_t _n = 0;
28457 : : { // (',' expression)
28458 [ - + ]: 72089 : if (p->error_indicator) {
28459 : 0 : p->level--;
28460 : 0 : 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 : 72089 : while (
28465 [ + + ]: 513299 : (_tmp_223_var = _tmp_223_rule(p)) // ',' expression
28466 : : )
28467 : : {
28468 : 441210 : _res = _tmp_223_var;
28469 [ + + ]: 441210 : if (_n == _children_capacity) {
28470 : 297 : _children_capacity *= 2;
28471 : 297 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28472 [ - + ]: 297 : if (!_new_children) {
28473 : 0 : p->error_indicator = 1;
28474 : : PyErr_NoMemory();
28475 : 0 : p->level--;
28476 : 0 : return NULL;
28477 : : }
28478 : 297 : _children = _new_children;
28479 : : }
28480 : 441210 : _children[_n++] = _res;
28481 : 441210 : _mark = p->mark;
28482 : : }
28483 : 72089 : 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 [ + + - + ]: 72089 : if (_n == 0 || p->error_indicator) {
28488 : 71876 : PyMem_Free(_children);
28489 : 71876 : p->level--;
28490 : 71876 : return NULL;
28491 : : }
28492 : 213 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28493 [ - + ]: 213 : if (!_seq) {
28494 : 0 : PyMem_Free(_children);
28495 : 0 : p->error_indicator = 1;
28496 : : PyErr_NoMemory();
28497 : 0 : p->level--;
28498 : 0 : return NULL;
28499 : : }
28500 [ + + ]: 441423 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28501 : 213 : PyMem_Free(_children);
28502 : 213 : _PyPegen_insert_memo(p, _start_mark, _loop1_80_type, _seq);
28503 : 213 : p->level--;
28504 : 213 : return _seq;
28505 : : }
28506 : :
28507 : : // _loop1_81: (',' star_expression)
28508 : : static asdl_seq *
28509 : 2094896 : _loop1_81_rule(Parser *p)
28510 : : {
28511 [ - + ]: 2094896 : if (p->level++ == MAXSTACK) {
28512 : 0 : p->error_indicator = 1;
28513 : : PyErr_NoMemory();
28514 : : }
28515 [ - + ]: 2094896 : if (p->error_indicator) {
28516 : 0 : p->level--;
28517 : 0 : return NULL;
28518 : : }
28519 : 2094896 : void *_res = NULL;
28520 : 2094896 : int _mark = p->mark;
28521 : 2094896 : int _start_mark = p->mark;
28522 : 2094896 : void **_children = PyMem_Malloc(sizeof(void *));
28523 [ - + ]: 2094896 : if (!_children) {
28524 : 0 : p->error_indicator = 1;
28525 : : PyErr_NoMemory();
28526 : 0 : p->level--;
28527 : 0 : return NULL;
28528 : : }
28529 : 2094896 : Py_ssize_t _children_capacity = 1;
28530 : 2094896 : Py_ssize_t _n = 0;
28531 : : { // (',' star_expression)
28532 [ - + ]: 2094896 : if (p->error_indicator) {
28533 : 0 : p->level--;
28534 : 0 : 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 : 2094896 : while (
28539 [ + + ]: 2122843 : (_tmp_224_var = _tmp_224_rule(p)) // ',' star_expression
28540 : : )
28541 : : {
28542 : 27947 : _res = _tmp_224_var;
28543 [ + + ]: 27947 : if (_n == _children_capacity) {
28544 : 7315 : _children_capacity *= 2;
28545 : 7315 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28546 [ - + ]: 7315 : if (!_new_children) {
28547 : 0 : p->error_indicator = 1;
28548 : : PyErr_NoMemory();
28549 : 0 : p->level--;
28550 : 0 : return NULL;
28551 : : }
28552 : 7315 : _children = _new_children;
28553 : : }
28554 : 27947 : _children[_n++] = _res;
28555 : 27947 : _mark = p->mark;
28556 : : }
28557 : 2094896 : 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 [ + + - + ]: 2094896 : if (_n == 0 || p->error_indicator) {
28562 : 2075366 : PyMem_Free(_children);
28563 : 2075366 : p->level--;
28564 : 2075366 : return NULL;
28565 : : }
28566 : 19530 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28567 [ - + ]: 19530 : if (!_seq) {
28568 : 0 : PyMem_Free(_children);
28569 : 0 : p->error_indicator = 1;
28570 : : PyErr_NoMemory();
28571 : 0 : p->level--;
28572 : 0 : return NULL;
28573 : : }
28574 [ + + ]: 47477 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28575 : 19530 : PyMem_Free(_children);
28576 : 19530 : _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq);
28577 : 19530 : p->level--;
28578 : 19530 : return _seq;
28579 : : }
28580 : :
28581 : : // _loop0_83: ',' star_named_expression
28582 : : static asdl_seq *
28583 : 648263 : _loop0_83_rule(Parser *p)
28584 : : {
28585 [ - + ]: 648263 : if (p->level++ == MAXSTACK) {
28586 : 0 : p->error_indicator = 1;
28587 : : PyErr_NoMemory();
28588 : : }
28589 [ - + ]: 648263 : if (p->error_indicator) {
28590 : 0 : p->level--;
28591 : 0 : return NULL;
28592 : : }
28593 : 648263 : void *_res = NULL;
28594 : 648263 : int _mark = p->mark;
28595 : 648263 : int _start_mark = p->mark;
28596 : 648263 : void **_children = PyMem_Malloc(sizeof(void *));
28597 [ - + ]: 648263 : if (!_children) {
28598 : 0 : p->error_indicator = 1;
28599 : : PyErr_NoMemory();
28600 : 0 : p->level--;
28601 : 0 : return NULL;
28602 : : }
28603 : 648263 : Py_ssize_t _children_capacity = 1;
28604 : 648263 : Py_ssize_t _n = 0;
28605 : : { // ',' star_named_expression
28606 [ - + ]: 648263 : if (p->error_indicator) {
28607 : 0 : p->level--;
28608 : 0 : 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 : 648263 : while (
28614 : 3597723 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
28615 [ + + + + ]: 6570530 : &&
28616 : 2972807 : (elem = star_named_expression_rule(p)) // star_named_expression
28617 : : )
28618 : : {
28619 : 2949460 : _res = elem;
28620 [ - + - - ]: 2949460 : if (_res == NULL && PyErr_Occurred()) {
28621 : 0 : p->error_indicator = 1;
28622 : 0 : PyMem_Free(_children);
28623 : 0 : p->level--;
28624 : 0 : return NULL;
28625 : : }
28626 [ + + ]: 2949460 : if (_n == _children_capacity) {
28627 : 338993 : _children_capacity *= 2;
28628 : 338993 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28629 [ - + ]: 338993 : if (!_new_children) {
28630 : 0 : p->error_indicator = 1;
28631 : : PyErr_NoMemory();
28632 : 0 : p->level--;
28633 : 0 : return NULL;
28634 : : }
28635 : 338993 : _children = _new_children;
28636 : : }
28637 : 2949460 : _children[_n++] = _res;
28638 : 2949460 : _mark = p->mark;
28639 : : }
28640 : 648263 : 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 : 648263 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28645 [ - + ]: 648263 : if (!_seq) {
28646 : 0 : PyMem_Free(_children);
28647 : 0 : p->error_indicator = 1;
28648 : : PyErr_NoMemory();
28649 : 0 : p->level--;
28650 : 0 : return NULL;
28651 : : }
28652 [ + + ]: 3597723 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28653 : 648263 : PyMem_Free(_children);
28654 : 648263 : _PyPegen_insert_memo(p, _start_mark, _loop0_83_type, _seq);
28655 : 648263 : p->level--;
28656 : 648263 : return _seq;
28657 : : }
28658 : :
28659 : : // _gather_82: star_named_expression _loop0_83
28660 : : static asdl_seq *
28661 : 823470 : _gather_82_rule(Parser *p)
28662 : : {
28663 [ - + ]: 823470 : if (p->level++ == MAXSTACK) {
28664 : 0 : p->error_indicator = 1;
28665 : : PyErr_NoMemory();
28666 : : }
28667 [ - + ]: 823470 : if (p->error_indicator) {
28668 : 0 : p->level--;
28669 : 0 : return NULL;
28670 : : }
28671 : 823470 : asdl_seq * _res = NULL;
28672 : 823470 : int _mark = p->mark;
28673 : : { // star_named_expression _loop0_83
28674 [ - + ]: 823470 : if (p->error_indicator) {
28675 : 0 : p->level--;
28676 : 0 : 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 [ + + ]: 823470 : if (
28682 : 823470 : (elem = star_named_expression_rule(p)) // star_named_expression
28683 [ + - ]: 648263 : &&
28684 : 648263 : (seq = _loop0_83_rule(p)) // _loop0_83
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 : 648263 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28689 : 648263 : goto done;
28690 : : }
28691 : 175207 : 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 : 175207 : _res = NULL;
28696 : 823470 : done:
28697 : 823470 : p->level--;
28698 : 823470 : return _res;
28699 : : }
28700 : :
28701 : : // _loop1_84: ('or' conjunction)
28702 : : static asdl_seq *
28703 : 9717377 : _loop1_84_rule(Parser *p)
28704 : : {
28705 [ - + ]: 9717377 : if (p->level++ == MAXSTACK) {
28706 : 0 : p->error_indicator = 1;
28707 : : PyErr_NoMemory();
28708 : : }
28709 [ - + ]: 9717377 : if (p->error_indicator) {
28710 : 0 : p->level--;
28711 : 0 : return NULL;
28712 : : }
28713 : 9717377 : void *_res = NULL;
28714 : 9717377 : int _mark = p->mark;
28715 : 9717377 : int _start_mark = p->mark;
28716 : 9717377 : void **_children = PyMem_Malloc(sizeof(void *));
28717 [ - + ]: 9717377 : if (!_children) {
28718 : 0 : p->error_indicator = 1;
28719 : : PyErr_NoMemory();
28720 : 0 : p->level--;
28721 : 0 : return NULL;
28722 : : }
28723 : 9717377 : Py_ssize_t _children_capacity = 1;
28724 : 9717377 : Py_ssize_t _n = 0;
28725 : : { // ('or' conjunction)
28726 [ - + ]: 9717377 : if (p->error_indicator) {
28727 : 0 : p->level--;
28728 : 0 : 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 : 9717377 : while (
28733 [ + + ]: 9746242 : (_tmp_225_var = _tmp_225_rule(p)) // 'or' conjunction
28734 : : )
28735 : : {
28736 : 28865 : _res = _tmp_225_var;
28737 [ + + ]: 28865 : if (_n == _children_capacity) {
28738 : 2360 : _children_capacity *= 2;
28739 : 2360 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28740 [ - + ]: 2360 : if (!_new_children) {
28741 : 0 : p->error_indicator = 1;
28742 : : PyErr_NoMemory();
28743 : 0 : p->level--;
28744 : 0 : return NULL;
28745 : : }
28746 : 2360 : _children = _new_children;
28747 : : }
28748 : 28865 : _children[_n++] = _res;
28749 : 28865 : _mark = p->mark;
28750 : : }
28751 : 9717377 : 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 [ + + - + ]: 9717377 : if (_n == 0 || p->error_indicator) {
28756 : 9691251 : PyMem_Free(_children);
28757 : 9691251 : p->level--;
28758 : 9691251 : return NULL;
28759 : : }
28760 : 26126 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28761 [ - + ]: 26126 : if (!_seq) {
28762 : 0 : PyMem_Free(_children);
28763 : 0 : p->error_indicator = 1;
28764 : : PyErr_NoMemory();
28765 : 0 : p->level--;
28766 : 0 : return NULL;
28767 : : }
28768 [ + + ]: 54991 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28769 : 26126 : PyMem_Free(_children);
28770 : 26126 : _PyPegen_insert_memo(p, _start_mark, _loop1_84_type, _seq);
28771 : 26126 : p->level--;
28772 : 26126 : return _seq;
28773 : : }
28774 : :
28775 : : // _loop1_85: ('and' inversion)
28776 : : static asdl_seq *
28777 : 9746242 : _loop1_85_rule(Parser *p)
28778 : : {
28779 [ - + ]: 9746242 : if (p->level++ == MAXSTACK) {
28780 : 0 : p->error_indicator = 1;
28781 : : PyErr_NoMemory();
28782 : : }
28783 [ - + ]: 9746242 : if (p->error_indicator) {
28784 : 0 : p->level--;
28785 : 0 : return NULL;
28786 : : }
28787 : 9746242 : void *_res = NULL;
28788 : 9746242 : int _mark = p->mark;
28789 : 9746242 : int _start_mark = p->mark;
28790 : 9746242 : void **_children = PyMem_Malloc(sizeof(void *));
28791 [ - + ]: 9746242 : if (!_children) {
28792 : 0 : p->error_indicator = 1;
28793 : : PyErr_NoMemory();
28794 : 0 : p->level--;
28795 : 0 : return NULL;
28796 : : }
28797 : 9746242 : Py_ssize_t _children_capacity = 1;
28798 : 9746242 : Py_ssize_t _n = 0;
28799 : : { // ('and' inversion)
28800 [ - + ]: 9746242 : if (p->error_indicator) {
28801 : 0 : p->level--;
28802 : 0 : 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 : 9746242 : while (
28807 [ + + ]: 9792135 : (_tmp_226_var = _tmp_226_rule(p)) // 'and' inversion
28808 : : )
28809 : : {
28810 : 45893 : _res = _tmp_226_var;
28811 [ + + ]: 45893 : if (_n == _children_capacity) {
28812 : 6005 : _children_capacity *= 2;
28813 : 6005 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28814 [ - + ]: 6005 : if (!_new_children) {
28815 : 0 : p->error_indicator = 1;
28816 : : PyErr_NoMemory();
28817 : 0 : p->level--;
28818 : 0 : return NULL;
28819 : : }
28820 : 6005 : _children = _new_children;
28821 : : }
28822 : 45893 : _children[_n++] = _res;
28823 : 45893 : _mark = p->mark;
28824 : : }
28825 : 9746242 : 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 [ + + - + ]: 9746242 : if (_n == 0 || p->error_indicator) {
28830 : 9707178 : PyMem_Free(_children);
28831 : 9707178 : p->level--;
28832 : 9707178 : return NULL;
28833 : : }
28834 : 39064 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28835 [ - + ]: 39064 : if (!_seq) {
28836 : 0 : PyMem_Free(_children);
28837 : 0 : p->error_indicator = 1;
28838 : : PyErr_NoMemory();
28839 : 0 : p->level--;
28840 : 0 : return NULL;
28841 : : }
28842 [ + + ]: 84957 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28843 : 39064 : PyMem_Free(_children);
28844 : 39064 : _PyPegen_insert_memo(p, _start_mark, _loop1_85_type, _seq);
28845 : 39064 : p->level--;
28846 : 39064 : return _seq;
28847 : : }
28848 : :
28849 : : // _loop1_86: compare_op_bitwise_or_pair
28850 : : static asdl_seq *
28851 : 9792136 : _loop1_86_rule(Parser *p)
28852 : : {
28853 [ - + ]: 9792136 : if (p->level++ == MAXSTACK) {
28854 : 0 : p->error_indicator = 1;
28855 : : PyErr_NoMemory();
28856 : : }
28857 [ - + ]: 9792136 : if (p->error_indicator) {
28858 : 0 : p->level--;
28859 : 0 : return NULL;
28860 : : }
28861 : 9792136 : void *_res = NULL;
28862 : 9792136 : int _mark = p->mark;
28863 : 9792136 : int _start_mark = p->mark;
28864 : 9792136 : void **_children = PyMem_Malloc(sizeof(void *));
28865 [ - + ]: 9792136 : if (!_children) {
28866 : 0 : p->error_indicator = 1;
28867 : : PyErr_NoMemory();
28868 : 0 : p->level--;
28869 : 0 : return NULL;
28870 : : }
28871 : 9792136 : Py_ssize_t _children_capacity = 1;
28872 : 9792136 : Py_ssize_t _n = 0;
28873 : : { // compare_op_bitwise_or_pair
28874 [ - + ]: 9792136 : if (p->error_indicator) {
28875 : 0 : p->level--;
28876 : 0 : 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 : 9792136 : while (
28881 [ + + ]: 10037237 : (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p)) // compare_op_bitwise_or_pair
28882 : : )
28883 : : {
28884 : 245101 : _res = compare_op_bitwise_or_pair_var;
28885 [ + + ]: 245101 : if (_n == _children_capacity) {
28886 : 3179 : _children_capacity *= 2;
28887 : 3179 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28888 [ - + ]: 3179 : if (!_new_children) {
28889 : 0 : p->error_indicator = 1;
28890 : : PyErr_NoMemory();
28891 : 0 : p->level--;
28892 : 0 : return NULL;
28893 : : }
28894 : 3179 : _children = _new_children;
28895 : : }
28896 : 245101 : _children[_n++] = _res;
28897 : 245101 : _mark = p->mark;
28898 : : }
28899 : 9792136 : 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 [ + + - + ]: 9792136 : if (_n == 0 || p->error_indicator) {
28904 : 9550370 : PyMem_Free(_children);
28905 : 9550370 : p->level--;
28906 : 9550370 : return NULL;
28907 : : }
28908 : 241766 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28909 [ - + ]: 241766 : if (!_seq) {
28910 : 0 : PyMem_Free(_children);
28911 : 0 : p->error_indicator = 1;
28912 : : PyErr_NoMemory();
28913 : 0 : p->level--;
28914 : 0 : return NULL;
28915 : : }
28916 [ + + ]: 486867 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28917 : 241766 : PyMem_Free(_children);
28918 : 241766 : _PyPegen_insert_memo(p, _start_mark, _loop1_86_type, _seq);
28919 : 241766 : p->level--;
28920 : 241766 : return _seq;
28921 : : }
28922 : :
28923 : : // _tmp_87: '!='
28924 : : static void *
28925 : 9966036 : _tmp_87_rule(Parser *p)
28926 : : {
28927 [ - + ]: 9966036 : if (p->level++ == MAXSTACK) {
28928 : 0 : p->error_indicator = 1;
28929 : : PyErr_NoMemory();
28930 : : }
28931 [ - + ]: 9966036 : if (p->error_indicator) {
28932 : 0 : p->level--;
28933 : 0 : return NULL;
28934 : : }
28935 : 9966036 : void * _res = NULL;
28936 : 9966036 : int _mark = p->mark;
28937 : : { // '!='
28938 [ - + ]: 9966036 : if (p->error_indicator) {
28939 : 0 : p->level--;
28940 : 0 : return NULL;
28941 : : }
28942 : : D(fprintf(stderr, "%*c> _tmp_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='"));
28943 : : Token * tok;
28944 [ + + ]: 9966036 : if (
28945 : 9966036 : (tok = _PyPegen_expect_token(p, 28)) // token='!='
28946 : : )
28947 : : {
28948 : : D(fprintf(stderr, "%*c+ _tmp_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='"));
28949 [ + + ]: 17557 : _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok;
28950 [ + + + + ]: 17557 : if (_res == NULL && PyErr_Occurred()) {
28951 : 1 : p->error_indicator = 1;
28952 : 1 : p->level--;
28953 : 1 : return NULL;
28954 : : }
28955 : 17556 : goto done;
28956 : : }
28957 : 9948479 : 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 : 9948479 : _res = NULL;
28962 : 9966035 : done:
28963 : 9966035 : p->level--;
28964 : 9966035 : return _res;
28965 : : }
28966 : :
28967 : : // _loop0_89: ',' (slice | starred_expression)
28968 : : static asdl_seq *
28969 : 21669 : _loop0_89_rule(Parser *p)
28970 : : {
28971 [ - + ]: 21669 : if (p->level++ == MAXSTACK) {
28972 : 0 : p->error_indicator = 1;
28973 : : PyErr_NoMemory();
28974 : : }
28975 [ - + ]: 21669 : if (p->error_indicator) {
28976 : 0 : p->level--;
28977 : 0 : return NULL;
28978 : : }
28979 : 21669 : void *_res = NULL;
28980 : 21669 : int _mark = p->mark;
28981 : 21669 : int _start_mark = p->mark;
28982 : 21669 : void **_children = PyMem_Malloc(sizeof(void *));
28983 [ - + ]: 21669 : if (!_children) {
28984 : 0 : p->error_indicator = 1;
28985 : : PyErr_NoMemory();
28986 : 0 : p->level--;
28987 : 0 : return NULL;
28988 : : }
28989 : 21669 : Py_ssize_t _children_capacity = 1;
28990 : 21669 : Py_ssize_t _n = 0;
28991 : : { // ',' (slice | starred_expression)
28992 [ - + ]: 21669 : if (p->error_indicator) {
28993 : 0 : p->level--;
28994 : 0 : 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 : 21669 : while (
29000 : 47489 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
29001 [ + + + + ]: 73739 : &&
29002 : 26250 : (elem = _tmp_227_rule(p)) // slice | starred_expression
29003 : : )
29004 : : {
29005 : 25820 : _res = elem;
29006 [ - + - - ]: 25820 : if (_res == NULL && PyErr_Occurred()) {
29007 : 0 : p->error_indicator = 1;
29008 : 0 : PyMem_Free(_children);
29009 : 0 : p->level--;
29010 : 0 : return NULL;
29011 : : }
29012 [ + + ]: 25820 : if (_n == _children_capacity) {
29013 : 4405 : _children_capacity *= 2;
29014 : 4405 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29015 [ - + ]: 4405 : if (!_new_children) {
29016 : 0 : p->error_indicator = 1;
29017 : : PyErr_NoMemory();
29018 : 0 : p->level--;
29019 : 0 : return NULL;
29020 : : }
29021 : 4405 : _children = _new_children;
29022 : : }
29023 : 25820 : _children[_n++] = _res;
29024 : 25820 : _mark = p->mark;
29025 : : }
29026 : 21669 : 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 : 21669 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29031 [ - + ]: 21669 : if (!_seq) {
29032 : 0 : PyMem_Free(_children);
29033 : 0 : p->error_indicator = 1;
29034 : : PyErr_NoMemory();
29035 : 0 : p->level--;
29036 : 0 : return NULL;
29037 : : }
29038 [ + + ]: 47489 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29039 : 21669 : PyMem_Free(_children);
29040 : 21669 : _PyPegen_insert_memo(p, _start_mark, _loop0_89_type, _seq);
29041 : 21669 : p->level--;
29042 : 21669 : return _seq;
29043 : : }
29044 : :
29045 : : // _gather_88: (slice | starred_expression) _loop0_89
29046 : : static asdl_seq *
29047 : 21764 : _gather_88_rule(Parser *p)
29048 : : {
29049 [ - + ]: 21764 : if (p->level++ == MAXSTACK) {
29050 : 0 : p->error_indicator = 1;
29051 : : PyErr_NoMemory();
29052 : : }
29053 [ - + ]: 21764 : if (p->error_indicator) {
29054 : 0 : p->level--;
29055 : 0 : return NULL;
29056 : : }
29057 : 21764 : asdl_seq * _res = NULL;
29058 : 21764 : int _mark = p->mark;
29059 : : { // (slice | starred_expression) _loop0_89
29060 [ - + ]: 21764 : if (p->error_indicator) {
29061 : 0 : p->level--;
29062 : 0 : 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 [ + + ]: 21764 : if (
29068 : 21764 : (elem = _tmp_227_rule(p)) // slice | starred_expression
29069 [ + - ]: 21669 : &&
29070 : 21669 : (seq = _loop0_89_rule(p)) // _loop0_89
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 : 21669 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
29075 : 21669 : goto done;
29076 : : }
29077 : 95 : 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 : 95 : _res = NULL;
29082 : 21764 : done:
29083 : 21764 : p->level--;
29084 : 21764 : return _res;
29085 : : }
29086 : :
29087 : : // _tmp_90: ':' expression?
29088 : : static void *
29089 : 68531 : _tmp_90_rule(Parser *p)
29090 : : {
29091 [ - + ]: 68531 : if (p->level++ == MAXSTACK) {
29092 : 0 : p->error_indicator = 1;
29093 : : PyErr_NoMemory();
29094 : : }
29095 [ - + ]: 68531 : if (p->error_indicator) {
29096 : 0 : p->level--;
29097 : 0 : return NULL;
29098 : : }
29099 : 68531 : void * _res = NULL;
29100 : 68531 : int _mark = p->mark;
29101 : : { // ':' expression?
29102 [ - + ]: 68531 : if (p->error_indicator) {
29103 : 0 : p->level--;
29104 : 0 : 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 [ + + ]: 68531 : if (
29110 : 68531 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
29111 : 3189 : &&
29112 [ + + ]: 3189 : (d = expression_rule(p), !p->error_indicator) // expression?
29113 : : )
29114 : : {
29115 : : D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?"));
29116 : 3185 : _res = d;
29117 [ + + - + ]: 3185 : if (_res == NULL && PyErr_Occurred()) {
29118 : 0 : p->error_indicator = 1;
29119 : 0 : p->level--;
29120 : 0 : return NULL;
29121 : : }
29122 : 3185 : goto done;
29123 : : }
29124 : 65346 : 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 : 65346 : _res = NULL;
29129 : 68531 : done:
29130 : 68531 : p->level--;
29131 : 68531 : return _res;
29132 : : }
29133 : :
29134 : : // _tmp_91: tuple | group | genexp
29135 : : static void *
29136 : 863699 : _tmp_91_rule(Parser *p)
29137 : : {
29138 [ - + ]: 863699 : if (p->level++ == MAXSTACK) {
29139 : 0 : p->error_indicator = 1;
29140 : : PyErr_NoMemory();
29141 : : }
29142 [ - + ]: 863699 : if (p->error_indicator) {
29143 : 0 : p->level--;
29144 : 0 : return NULL;
29145 : : }
29146 : 863699 : void * _res = NULL;
29147 : 863699 : int _mark = p->mark;
29148 : : { // tuple
29149 [ - + ]: 863699 : if (p->error_indicator) {
29150 : 0 : p->level--;
29151 : 0 : 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 [ + + ]: 863699 : if (
29156 : 863699 : (tuple_var = tuple_rule(p)) // tuple
29157 : : )
29158 : : {
29159 : : D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
29160 : 569900 : _res = tuple_var;
29161 : 569900 : goto done;
29162 : : }
29163 : 293799 : 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 [ + + ]: 293799 : if (p->error_indicator) {
29169 : 52 : p->level--;
29170 : 52 : 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 [ + + ]: 293747 : if (
29175 : 293747 : (group_var = group_rule(p)) // group
29176 : : )
29177 : : {
29178 : : D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group"));
29179 : 288226 : _res = group_var;
29180 : 288226 : goto done;
29181 : : }
29182 : 5521 : 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 [ + + ]: 5521 : if (p->error_indicator) {
29188 : 10 : p->level--;
29189 : 10 : 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 [ + + ]: 5511 : if (
29194 : 5511 : (genexp_var = genexp_rule(p)) // genexp
29195 : : )
29196 : : {
29197 : : D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"));
29198 : 5392 : _res = genexp_var;
29199 : 5392 : goto done;
29200 : : }
29201 : 119 : 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 : 119 : _res = NULL;
29206 : 863637 : done:
29207 : 863637 : p->level--;
29208 : 863637 : return _res;
29209 : : }
29210 : :
29211 : : // _tmp_92: list | listcomp
29212 : : static void *
29213 : 261397 : _tmp_92_rule(Parser *p)
29214 : : {
29215 [ - + ]: 261397 : if (p->level++ == MAXSTACK) {
29216 : 0 : p->error_indicator = 1;
29217 : : PyErr_NoMemory();
29218 : : }
29219 [ - + ]: 261397 : if (p->error_indicator) {
29220 : 0 : p->level--;
29221 : 0 : return NULL;
29222 : : }
29223 : 261397 : void * _res = NULL;
29224 : 261397 : int _mark = p->mark;
29225 : : { // list
29226 [ - + ]: 261397 : if (p->error_indicator) {
29227 : 0 : p->level--;
29228 : 0 : 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 [ + + ]: 261397 : if (
29233 : 261397 : (list_var = list_rule(p)) // list
29234 : : )
29235 : : {
29236 : : D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
29237 : 232140 : _res = list_var;
29238 : 232140 : goto done;
29239 : : }
29240 : 29257 : 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 [ + + ]: 29257 : if (p->error_indicator) {
29246 : 34 : p->level--;
29247 : 34 : 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 [ + + ]: 29223 : if (
29252 : 29223 : (listcomp_var = listcomp_rule(p)) // listcomp
29253 : : )
29254 : : {
29255 : : D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp"));
29256 : 29134 : _res = listcomp_var;
29257 : 29134 : goto done;
29258 : : }
29259 : 89 : 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 : 89 : _res = NULL;
29264 : 261363 : done:
29265 : 261363 : p->level--;
29266 : 261363 : return _res;
29267 : : }
29268 : :
29269 : : // _tmp_93: dict | set | dictcomp | setcomp
29270 : : static void *
29271 : 112968 : _tmp_93_rule(Parser *p)
29272 : : {
29273 [ - + ]: 112968 : if (p->level++ == MAXSTACK) {
29274 : 0 : p->error_indicator = 1;
29275 : : PyErr_NoMemory();
29276 : : }
29277 [ - + ]: 112968 : if (p->error_indicator) {
29278 : 0 : p->level--;
29279 : 0 : return NULL;
29280 : : }
29281 : 112968 : void * _res = NULL;
29282 : 112968 : int _mark = p->mark;
29283 : : { // dict
29284 [ - + ]: 112968 : if (p->error_indicator) {
29285 : 0 : p->level--;
29286 : 0 : 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 [ + + ]: 112968 : if (
29291 : 112968 : (dict_var = dict_rule(p)) // dict
29292 : : )
29293 : : {
29294 : : D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict"));
29295 : 99173 : _res = dict_var;
29296 : 99173 : goto done;
29297 : : }
29298 : 13795 : 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 [ + + ]: 13795 : if (p->error_indicator) {
29304 : 32 : p->level--;
29305 : 32 : 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 [ + + ]: 13763 : if (
29310 : 13763 : (set_var = set_rule(p)) // set
29311 : : )
29312 : : {
29313 : : D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set"));
29314 : 8391 : _res = set_var;
29315 : 8391 : goto done;
29316 : : }
29317 : 5372 : 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 [ + + ]: 5372 : if (p->error_indicator) {
29323 : 5 : p->level--;
29324 : 5 : 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 [ + + ]: 5367 : if (
29329 : 5367 : (dictcomp_var = dictcomp_rule(p)) // dictcomp
29330 : : )
29331 : : {
29332 : : D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp"));
29333 : 3780 : _res = dictcomp_var;
29334 : 3780 : goto done;
29335 : : }
29336 : 1587 : 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 [ + + ]: 1587 : if (p->error_indicator) {
29342 : 1 : p->level--;
29343 : 1 : 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 [ + + ]: 1586 : if (
29348 : 1586 : (setcomp_var = setcomp_rule(p)) // setcomp
29349 : : )
29350 : : {
29351 : : D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp"));
29352 : 1528 : _res = setcomp_var;
29353 : 1528 : goto done;
29354 : : }
29355 : 58 : 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 : 58 : _res = NULL;
29360 : 112930 : done:
29361 : 112930 : p->level--;
29362 : 112930 : return _res;
29363 : : }
29364 : :
29365 : : // _tmp_94: yield_expr | named_expression
29366 : : static void *
29367 : 293747 : _tmp_94_rule(Parser *p)
29368 : : {
29369 [ - + ]: 293747 : if (p->level++ == MAXSTACK) {
29370 : 0 : p->error_indicator = 1;
29371 : : PyErr_NoMemory();
29372 : : }
29373 [ - + ]: 293747 : if (p->error_indicator) {
29374 : 0 : p->level--;
29375 : 0 : return NULL;
29376 : : }
29377 : 293747 : void * _res = NULL;
29378 : 293747 : int _mark = p->mark;
29379 : : { // yield_expr
29380 [ - + ]: 293747 : if (p->error_indicator) {
29381 : 0 : p->level--;
29382 : 0 : 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 [ + + ]: 293747 : if (
29387 : 293747 : (yield_expr_var = yield_expr_rule(p)) // yield_expr
29388 : : )
29389 : : {
29390 : : D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
29391 : 504 : _res = yield_expr_var;
29392 : 504 : goto done;
29393 : : }
29394 : 293243 : 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 [ - + ]: 293243 : if (p->error_indicator) {
29400 : 0 : p->level--;
29401 : 0 : 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 [ + + ]: 293243 : if (
29406 : 293243 : (named_expression_var = named_expression_rule(p)) // named_expression
29407 : : )
29408 : : {
29409 : : D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
29410 : 293183 : _res = named_expression_var;
29411 : 293183 : goto done;
29412 : : }
29413 : 60 : 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 : 60 : _res = NULL;
29418 : 293747 : done:
29419 : 293747 : p->level--;
29420 : 293747 : return _res;
29421 : : }
29422 : :
29423 : : // _loop0_95: lambda_param_no_default
29424 : : static asdl_seq *
29425 : 79 : _loop0_95_rule(Parser *p)
29426 : : {
29427 [ - + ]: 79 : if (p->level++ == MAXSTACK) {
29428 : 0 : p->error_indicator = 1;
29429 : : PyErr_NoMemory();
29430 : : }
29431 [ - + ]: 79 : if (p->error_indicator) {
29432 : 0 : p->level--;
29433 : 0 : return NULL;
29434 : : }
29435 : 79 : void *_res = NULL;
29436 : 79 : int _mark = p->mark;
29437 : 79 : int _start_mark = p->mark;
29438 : 79 : void **_children = PyMem_Malloc(sizeof(void *));
29439 [ - + ]: 79 : if (!_children) {
29440 : 0 : p->error_indicator = 1;
29441 : : PyErr_NoMemory();
29442 : 0 : p->level--;
29443 : 0 : return NULL;
29444 : : }
29445 : 79 : Py_ssize_t _children_capacity = 1;
29446 : 79 : Py_ssize_t _n = 0;
29447 : : { // lambda_param_no_default
29448 [ - + ]: 79 : if (p->error_indicator) {
29449 : 0 : p->level--;
29450 : 0 : 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 : 79 : while (
29455 [ + + ]: 111 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
29456 : : )
29457 : : {
29458 : 32 : _res = lambda_param_no_default_var;
29459 [ + + ]: 32 : if (_n == _children_capacity) {
29460 : 1 : _children_capacity *= 2;
29461 : 1 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29462 [ - + ]: 1 : if (!_new_children) {
29463 : 0 : p->error_indicator = 1;
29464 : : PyErr_NoMemory();
29465 : 0 : p->level--;
29466 : 0 : return NULL;
29467 : : }
29468 : 1 : _children = _new_children;
29469 : : }
29470 : 32 : _children[_n++] = _res;
29471 : 32 : _mark = p->mark;
29472 : : }
29473 : 79 : 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 : 79 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29478 [ - + ]: 79 : if (!_seq) {
29479 : 0 : PyMem_Free(_children);
29480 : 0 : p->error_indicator = 1;
29481 : : PyErr_NoMemory();
29482 : 0 : p->level--;
29483 : 0 : return NULL;
29484 : : }
29485 [ + + ]: 111 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29486 : 79 : PyMem_Free(_children);
29487 : 79 : _PyPegen_insert_memo(p, _start_mark, _loop0_95_type, _seq);
29488 : 79 : p->level--;
29489 : 79 : return _seq;
29490 : : }
29491 : :
29492 : : // _loop0_96: lambda_param_with_default
29493 : : static asdl_seq *
29494 : 79 : _loop0_96_rule(Parser *p)
29495 : : {
29496 [ - + ]: 79 : if (p->level++ == MAXSTACK) {
29497 : 0 : p->error_indicator = 1;
29498 : : PyErr_NoMemory();
29499 : : }
29500 [ - + ]: 79 : if (p->error_indicator) {
29501 : 0 : p->level--;
29502 : 0 : return NULL;
29503 : : }
29504 : 79 : void *_res = NULL;
29505 : 79 : int _mark = p->mark;
29506 : 79 : int _start_mark = p->mark;
29507 : 79 : void **_children = PyMem_Malloc(sizeof(void *));
29508 [ - + ]: 79 : if (!_children) {
29509 : 0 : p->error_indicator = 1;
29510 : : PyErr_NoMemory();
29511 : 0 : p->level--;
29512 : 0 : return NULL;
29513 : : }
29514 : 79 : Py_ssize_t _children_capacity = 1;
29515 : 79 : Py_ssize_t _n = 0;
29516 : : { // lambda_param_with_default
29517 [ - + ]: 79 : if (p->error_indicator) {
29518 : 0 : p->level--;
29519 : 0 : 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 : 79 : while (
29524 [ + + ]: 119 : (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
29525 : : )
29526 : : {
29527 : 40 : _res = lambda_param_with_default_var;
29528 [ - + ]: 40 : if (_n == _children_capacity) {
29529 : 0 : _children_capacity *= 2;
29530 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29531 [ # # ]: 0 : if (!_new_children) {
29532 : 0 : p->error_indicator = 1;
29533 : : PyErr_NoMemory();
29534 : 0 : p->level--;
29535 : 0 : return NULL;
29536 : : }
29537 : 0 : _children = _new_children;
29538 : : }
29539 : 40 : _children[_n++] = _res;
29540 : 40 : _mark = p->mark;
29541 : : }
29542 : 79 : 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 : 79 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29547 [ - + ]: 79 : if (!_seq) {
29548 : 0 : PyMem_Free(_children);
29549 : 0 : p->error_indicator = 1;
29550 : : PyErr_NoMemory();
29551 : 0 : p->level--;
29552 : 0 : return NULL;
29553 : : }
29554 [ + + ]: 119 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29555 : 79 : PyMem_Free(_children);
29556 : 79 : _PyPegen_insert_memo(p, _start_mark, _loop0_96_type, _seq);
29557 : 79 : p->level--;
29558 : 79 : return _seq;
29559 : : }
29560 : :
29561 : : // _loop0_97: lambda_param_with_default
29562 : : static asdl_seq *
29563 : 58 : _loop0_97_rule(Parser *p)
29564 : : {
29565 [ - + ]: 58 : if (p->level++ == MAXSTACK) {
29566 : 0 : p->error_indicator = 1;
29567 : : PyErr_NoMemory();
29568 : : }
29569 [ - + ]: 58 : if (p->error_indicator) {
29570 : 0 : p->level--;
29571 : 0 : return NULL;
29572 : : }
29573 : 58 : void *_res = NULL;
29574 : 58 : int _mark = p->mark;
29575 : 58 : int _start_mark = p->mark;
29576 : 58 : void **_children = PyMem_Malloc(sizeof(void *));
29577 [ - + ]: 58 : if (!_children) {
29578 : 0 : p->error_indicator = 1;
29579 : : PyErr_NoMemory();
29580 : 0 : p->level--;
29581 : 0 : return NULL;
29582 : : }
29583 : 58 : Py_ssize_t _children_capacity = 1;
29584 : 58 : Py_ssize_t _n = 0;
29585 : : { // lambda_param_with_default
29586 [ - + ]: 58 : if (p->error_indicator) {
29587 : 0 : p->level--;
29588 : 0 : 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 : 58 : while (
29593 [ + + ]: 103 : (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
29594 : : )
29595 : : {
29596 : 45 : _res = lambda_param_with_default_var;
29597 [ - + ]: 45 : if (_n == _children_capacity) {
29598 : 0 : _children_capacity *= 2;
29599 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29600 [ # # ]: 0 : if (!_new_children) {
29601 : 0 : p->error_indicator = 1;
29602 : : PyErr_NoMemory();
29603 : 0 : p->level--;
29604 : 0 : return NULL;
29605 : : }
29606 : 0 : _children = _new_children;
29607 : : }
29608 : 45 : _children[_n++] = _res;
29609 : 45 : _mark = p->mark;
29610 : : }
29611 : 58 : 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 : 58 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29616 [ - + ]: 58 : if (!_seq) {
29617 : 0 : PyMem_Free(_children);
29618 : 0 : p->error_indicator = 1;
29619 : : PyErr_NoMemory();
29620 : 0 : p->level--;
29621 : 0 : return NULL;
29622 : : }
29623 [ + + ]: 103 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29624 : 58 : PyMem_Free(_children);
29625 : 58 : _PyPegen_insert_memo(p, _start_mark, _loop0_97_type, _seq);
29626 : 58 : p->level--;
29627 : 58 : return _seq;
29628 : : }
29629 : :
29630 : : // _loop1_98: lambda_param_no_default
29631 : : static asdl_seq *
29632 : 37139 : _loop1_98_rule(Parser *p)
29633 : : {
29634 [ - + ]: 37139 : if (p->level++ == MAXSTACK) {
29635 : 0 : p->error_indicator = 1;
29636 : : PyErr_NoMemory();
29637 : : }
29638 [ - + ]: 37139 : if (p->error_indicator) {
29639 : 0 : p->level--;
29640 : 0 : return NULL;
29641 : : }
29642 : 37139 : void *_res = NULL;
29643 : 37139 : int _mark = p->mark;
29644 : 37139 : int _start_mark = p->mark;
29645 : 37139 : void **_children = PyMem_Malloc(sizeof(void *));
29646 [ - + ]: 37139 : if (!_children) {
29647 : 0 : p->error_indicator = 1;
29648 : : PyErr_NoMemory();
29649 : 0 : p->level--;
29650 : 0 : return NULL;
29651 : : }
29652 : 37139 : Py_ssize_t _children_capacity = 1;
29653 : 37139 : Py_ssize_t _n = 0;
29654 : : { // lambda_param_no_default
29655 [ - + ]: 37139 : if (p->error_indicator) {
29656 : 0 : p->level--;
29657 : 0 : 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 : 37139 : while (
29662 [ + + ]: 204643 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
29663 : : )
29664 : : {
29665 : 167504 : _res = lambda_param_no_default_var;
29666 [ + + ]: 167504 : if (_n == _children_capacity) {
29667 : 81386 : _children_capacity *= 2;
29668 : 81386 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29669 [ - + ]: 81386 : if (!_new_children) {
29670 : 0 : p->error_indicator = 1;
29671 : : PyErr_NoMemory();
29672 : 0 : p->level--;
29673 : 0 : return NULL;
29674 : : }
29675 : 81386 : _children = _new_children;
29676 : : }
29677 : 167504 : _children[_n++] = _res;
29678 : 167504 : _mark = p->mark;
29679 : : }
29680 : 37139 : 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 [ + + - + ]: 37139 : if (_n == 0 || p->error_indicator) {
29685 : 3143 : PyMem_Free(_children);
29686 : 3143 : p->level--;
29687 : 3143 : return NULL;
29688 : : }
29689 : 33996 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29690 [ - + ]: 33996 : if (!_seq) {
29691 : 0 : PyMem_Free(_children);
29692 : 0 : p->error_indicator = 1;
29693 : : PyErr_NoMemory();
29694 : 0 : p->level--;
29695 : 0 : return NULL;
29696 : : }
29697 [ + + ]: 201500 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29698 : 33996 : PyMem_Free(_children);
29699 : 33996 : _PyPegen_insert_memo(p, _start_mark, _loop1_98_type, _seq);
29700 : 33996 : p->level--;
29701 : 33996 : return _seq;
29702 : : }
29703 : :
29704 : : // _loop0_99: lambda_param_with_default
29705 : : static asdl_seq *
29706 : 33996 : _loop0_99_rule(Parser *p)
29707 : : {
29708 [ - + ]: 33996 : if (p->level++ == MAXSTACK) {
29709 : 0 : p->error_indicator = 1;
29710 : : PyErr_NoMemory();
29711 : : }
29712 [ - + ]: 33996 : if (p->error_indicator) {
29713 : 0 : p->level--;
29714 : 0 : return NULL;
29715 : : }
29716 : 33996 : void *_res = NULL;
29717 : 33996 : int _mark = p->mark;
29718 : 33996 : int _start_mark = p->mark;
29719 : 33996 : void **_children = PyMem_Malloc(sizeof(void *));
29720 [ - + ]: 33996 : if (!_children) {
29721 : 0 : p->error_indicator = 1;
29722 : : PyErr_NoMemory();
29723 : 0 : p->level--;
29724 : 0 : return NULL;
29725 : : }
29726 : 33996 : Py_ssize_t _children_capacity = 1;
29727 : 33996 : Py_ssize_t _n = 0;
29728 : : { // lambda_param_with_default
29729 [ - + ]: 33996 : if (p->error_indicator) {
29730 : 0 : p->level--;
29731 : 0 : 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 : 33996 : while (
29736 [ + + ]: 34098 : (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
29737 : : )
29738 : : {
29739 : 102 : _res = lambda_param_with_default_var;
29740 [ + + ]: 102 : if (_n == _children_capacity) {
29741 : 6 : _children_capacity *= 2;
29742 : 6 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29743 [ - + ]: 6 : if (!_new_children) {
29744 : 0 : p->error_indicator = 1;
29745 : : PyErr_NoMemory();
29746 : 0 : p->level--;
29747 : 0 : return NULL;
29748 : : }
29749 : 6 : _children = _new_children;
29750 : : }
29751 : 102 : _children[_n++] = _res;
29752 : 102 : _mark = p->mark;
29753 : : }
29754 : 33996 : 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 : 33996 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29759 [ - + ]: 33996 : if (!_seq) {
29760 : 0 : PyMem_Free(_children);
29761 : 0 : p->error_indicator = 1;
29762 : : PyErr_NoMemory();
29763 : 0 : p->level--;
29764 : 0 : return NULL;
29765 : : }
29766 [ + + ]: 34098 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29767 : 33996 : PyMem_Free(_children);
29768 : 33996 : _PyPegen_insert_memo(p, _start_mark, _loop0_99_type, _seq);
29769 : 33996 : p->level--;
29770 : 33996 : return _seq;
29771 : : }
29772 : :
29773 : : // _loop1_100: lambda_param_with_default
29774 : : static asdl_seq *
29775 : 3143 : _loop1_100_rule(Parser *p)
29776 : : {
29777 [ - + ]: 3143 : if (p->level++ == MAXSTACK) {
29778 : 0 : p->error_indicator = 1;
29779 : : PyErr_NoMemory();
29780 : : }
29781 [ - + ]: 3143 : if (p->error_indicator) {
29782 : 0 : p->level--;
29783 : 0 : return NULL;
29784 : : }
29785 : 3143 : void *_res = NULL;
29786 : 3143 : int _mark = p->mark;
29787 : 3143 : int _start_mark = p->mark;
29788 : 3143 : void **_children = PyMem_Malloc(sizeof(void *));
29789 [ - + ]: 3143 : if (!_children) {
29790 : 0 : p->error_indicator = 1;
29791 : : PyErr_NoMemory();
29792 : 0 : p->level--;
29793 : 0 : return NULL;
29794 : : }
29795 : 3143 : Py_ssize_t _children_capacity = 1;
29796 : 3143 : Py_ssize_t _n = 0;
29797 : : { // lambda_param_with_default
29798 [ - + ]: 3143 : if (p->error_indicator) {
29799 : 0 : p->level--;
29800 : 0 : 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 : 3143 : while (
29805 [ + + ]: 3293 : (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
29806 : : )
29807 : : {
29808 : 150 : _res = lambda_param_with_default_var;
29809 [ + + ]: 150 : if (_n == _children_capacity) {
29810 : 6 : _children_capacity *= 2;
29811 : 6 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29812 [ - + ]: 6 : if (!_new_children) {
29813 : 0 : p->error_indicator = 1;
29814 : : PyErr_NoMemory();
29815 : 0 : p->level--;
29816 : 0 : return NULL;
29817 : : }
29818 : 6 : _children = _new_children;
29819 : : }
29820 : 150 : _children[_n++] = _res;
29821 : 150 : _mark = p->mark;
29822 : : }
29823 : 3143 : 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 [ + + - + ]: 3143 : if (_n == 0 || p->error_indicator) {
29828 : 2999 : PyMem_Free(_children);
29829 : 2999 : p->level--;
29830 : 2999 : return NULL;
29831 : : }
29832 : 144 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29833 [ - + ]: 144 : if (!_seq) {
29834 : 0 : PyMem_Free(_children);
29835 : 0 : p->error_indicator = 1;
29836 : : PyErr_NoMemory();
29837 : 0 : p->level--;
29838 : 0 : return NULL;
29839 : : }
29840 [ + + ]: 294 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29841 : 144 : PyMem_Free(_children);
29842 : 144 : _PyPegen_insert_memo(p, _start_mark, _loop1_100_type, _seq);
29843 : 144 : p->level--;
29844 : 144 : return _seq;
29845 : : }
29846 : :
29847 : : // _loop1_101: lambda_param_no_default
29848 : : static asdl_seq *
29849 : 37349 : _loop1_101_rule(Parser *p)
29850 : : {
29851 [ - + ]: 37349 : if (p->level++ == MAXSTACK) {
29852 : 0 : p->error_indicator = 1;
29853 : : PyErr_NoMemory();
29854 : : }
29855 [ - + ]: 37349 : if (p->error_indicator) {
29856 : 0 : p->level--;
29857 : 0 : return NULL;
29858 : : }
29859 : 37349 : void *_res = NULL;
29860 : 37349 : int _mark = p->mark;
29861 : 37349 : int _start_mark = p->mark;
29862 : 37349 : void **_children = PyMem_Malloc(sizeof(void *));
29863 [ - + ]: 37349 : if (!_children) {
29864 : 0 : p->error_indicator = 1;
29865 : : PyErr_NoMemory();
29866 : 0 : p->level--;
29867 : 0 : return NULL;
29868 : : }
29869 : 37349 : Py_ssize_t _children_capacity = 1;
29870 : 37349 : Py_ssize_t _n = 0;
29871 : : { // lambda_param_no_default
29872 [ - + ]: 37349 : if (p->error_indicator) {
29873 : 0 : p->level--;
29874 : 0 : 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 : 37349 : while (
29879 [ + + ]: 204986 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
29880 : : )
29881 : : {
29882 : 167637 : _res = lambda_param_no_default_var;
29883 [ + + ]: 167637 : if (_n == _children_capacity) {
29884 : 81401 : _children_capacity *= 2;
29885 : 81401 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29886 [ - + ]: 81401 : if (!_new_children) {
29887 : 0 : p->error_indicator = 1;
29888 : : PyErr_NoMemory();
29889 : 0 : p->level--;
29890 : 0 : return NULL;
29891 : : }
29892 : 81401 : _children = _new_children;
29893 : : }
29894 : 167637 : _children[_n++] = _res;
29895 : 167637 : _mark = p->mark;
29896 : : }
29897 : 37349 : 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 [ + + - + ]: 37349 : if (_n == 0 || p->error_indicator) {
29902 : 3235 : PyMem_Free(_children);
29903 : 3235 : p->level--;
29904 : 3235 : return NULL;
29905 : : }
29906 : 34114 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29907 [ - + ]: 34114 : if (!_seq) {
29908 : 0 : PyMem_Free(_children);
29909 : 0 : p->error_indicator = 1;
29910 : : PyErr_NoMemory();
29911 : 0 : p->level--;
29912 : 0 : return NULL;
29913 : : }
29914 [ + + ]: 201751 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29915 : 34114 : PyMem_Free(_children);
29916 : 34114 : _PyPegen_insert_memo(p, _start_mark, _loop1_101_type, _seq);
29917 : 34114 : p->level--;
29918 : 34114 : return _seq;
29919 : : }
29920 : :
29921 : : // _loop1_102: lambda_param_no_default
29922 : : static asdl_seq *
29923 : 37273 : _loop1_102_rule(Parser *p)
29924 : : {
29925 [ - + ]: 37273 : if (p->level++ == MAXSTACK) {
29926 : 0 : p->error_indicator = 1;
29927 : : PyErr_NoMemory();
29928 : : }
29929 [ - + ]: 37273 : if (p->error_indicator) {
29930 : 0 : p->level--;
29931 : 0 : return NULL;
29932 : : }
29933 : 37273 : void *_res = NULL;
29934 : 37273 : int _mark = p->mark;
29935 : 37273 : int _start_mark = p->mark;
29936 : 37273 : void **_children = PyMem_Malloc(sizeof(void *));
29937 [ - + ]: 37273 : if (!_children) {
29938 : 0 : p->error_indicator = 1;
29939 : : PyErr_NoMemory();
29940 : 0 : p->level--;
29941 : 0 : return NULL;
29942 : : }
29943 : 37273 : Py_ssize_t _children_capacity = 1;
29944 : 37273 : Py_ssize_t _n = 0;
29945 : : { // lambda_param_no_default
29946 [ - + ]: 37273 : if (p->error_indicator) {
29947 : 0 : p->level--;
29948 : 0 : 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 : 37273 : while (
29953 [ + + ]: 204823 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
29954 : : )
29955 : : {
29956 : 167550 : _res = lambda_param_no_default_var;
29957 [ + + ]: 167550 : if (_n == _children_capacity) {
29958 : 81390 : _children_capacity *= 2;
29959 : 81390 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29960 [ - + ]: 81390 : if (!_new_children) {
29961 : 0 : p->error_indicator = 1;
29962 : : PyErr_NoMemory();
29963 : 0 : p->level--;
29964 : 0 : return NULL;
29965 : : }
29966 : 81390 : _children = _new_children;
29967 : : }
29968 : 167550 : _children[_n++] = _res;
29969 : 167550 : _mark = p->mark;
29970 : : }
29971 : 37273 : 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 [ + + - + ]: 37273 : if (_n == 0 || p->error_indicator) {
29976 : 3235 : PyMem_Free(_children);
29977 : 3235 : p->level--;
29978 : 3235 : return NULL;
29979 : : }
29980 : 34038 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29981 [ - + ]: 34038 : if (!_seq) {
29982 : 0 : PyMem_Free(_children);
29983 : 0 : p->error_indicator = 1;
29984 : : PyErr_NoMemory();
29985 : 0 : p->level--;
29986 : 0 : return NULL;
29987 : : }
29988 [ + + ]: 201588 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29989 : 34038 : PyMem_Free(_children);
29990 : 34038 : _PyPegen_insert_memo(p, _start_mark, _loop1_102_type, _seq);
29991 : 34038 : p->level--;
29992 : 34038 : return _seq;
29993 : : }
29994 : :
29995 : : // _loop0_103: lambda_param_no_default
29996 : : static asdl_seq *
29997 : 37312 : _loop0_103_rule(Parser *p)
29998 : : {
29999 [ - + ]: 37312 : if (p->level++ == MAXSTACK) {
30000 : 0 : p->error_indicator = 1;
30001 : : PyErr_NoMemory();
30002 : : }
30003 [ - + ]: 37312 : if (p->error_indicator) {
30004 : 0 : p->level--;
30005 : 0 : return NULL;
30006 : : }
30007 : 37312 : void *_res = NULL;
30008 : 37312 : int _mark = p->mark;
30009 : 37312 : int _start_mark = p->mark;
30010 : 37312 : void **_children = PyMem_Malloc(sizeof(void *));
30011 [ - + ]: 37312 : if (!_children) {
30012 : 0 : p->error_indicator = 1;
30013 : : PyErr_NoMemory();
30014 : 0 : p->level--;
30015 : 0 : return NULL;
30016 : : }
30017 : 37312 : Py_ssize_t _children_capacity = 1;
30018 : 37312 : Py_ssize_t _n = 0;
30019 : : { // lambda_param_no_default
30020 [ - + ]: 37312 : if (p->error_indicator) {
30021 : 0 : p->level--;
30022 : 0 : 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 : 37312 : while (
30027 [ + + ]: 204845 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
30028 : : )
30029 : : {
30030 : 167533 : _res = lambda_param_no_default_var;
30031 [ + + ]: 167533 : if (_n == _children_capacity) {
30032 : 81386 : _children_capacity *= 2;
30033 : 81386 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30034 [ - + ]: 81386 : if (!_new_children) {
30035 : 0 : p->error_indicator = 1;
30036 : : PyErr_NoMemory();
30037 : 0 : p->level--;
30038 : 0 : return NULL;
30039 : : }
30040 : 81386 : _children = _new_children;
30041 : : }
30042 : 167533 : _children[_n++] = _res;
30043 : 167533 : _mark = p->mark;
30044 : : }
30045 : 37312 : 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 : 37312 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30050 [ - + ]: 37312 : if (!_seq) {
30051 : 0 : PyMem_Free(_children);
30052 : 0 : p->error_indicator = 1;
30053 : : PyErr_NoMemory();
30054 : 0 : p->level--;
30055 : 0 : return NULL;
30056 : : }
30057 [ + + ]: 204845 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30058 : 37312 : PyMem_Free(_children);
30059 : 37312 : _PyPegen_insert_memo(p, _start_mark, _loop0_103_type, _seq);
30060 : 37312 : p->level--;
30061 : 37312 : return _seq;
30062 : : }
30063 : :
30064 : : // _loop1_104: lambda_param_with_default
30065 : : static asdl_seq *
30066 : 37312 : _loop1_104_rule(Parser *p)
30067 : : {
30068 [ - + ]: 37312 : if (p->level++ == MAXSTACK) {
30069 : 0 : p->error_indicator = 1;
30070 : : PyErr_NoMemory();
30071 : : }
30072 [ - + ]: 37312 : if (p->error_indicator) {
30073 : 0 : p->level--;
30074 : 0 : return NULL;
30075 : : }
30076 : 37312 : void *_res = NULL;
30077 : 37312 : int _mark = p->mark;
30078 : 37312 : int _start_mark = p->mark;
30079 : 37312 : void **_children = PyMem_Malloc(sizeof(void *));
30080 [ - + ]: 37312 : if (!_children) {
30081 : 0 : p->error_indicator = 1;
30082 : : PyErr_NoMemory();
30083 : 0 : p->level--;
30084 : 0 : return NULL;
30085 : : }
30086 : 37312 : Py_ssize_t _children_capacity = 1;
30087 : 37312 : Py_ssize_t _n = 0;
30088 : : { // lambda_param_with_default
30089 [ - + ]: 37312 : if (p->error_indicator) {
30090 : 0 : p->level--;
30091 : 0 : 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 : 37312 : while (
30096 [ + + ]: 37673 : (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
30097 : : )
30098 : : {
30099 : 361 : _res = lambda_param_with_default_var;
30100 [ + + ]: 361 : if (_n == _children_capacity) {
30101 : 48 : _children_capacity *= 2;
30102 : 48 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30103 [ - + ]: 48 : if (!_new_children) {
30104 : 0 : p->error_indicator = 1;
30105 : : PyErr_NoMemory();
30106 : 0 : p->level--;
30107 : 0 : return NULL;
30108 : : }
30109 : 48 : _children = _new_children;
30110 : : }
30111 : 361 : _children[_n++] = _res;
30112 : 361 : _mark = p->mark;
30113 : : }
30114 : 37312 : 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 [ + + + + ]: 37312 : if (_n == 0 || p->error_indicator) {
30119 : 37000 : PyMem_Free(_children);
30120 : 37000 : p->level--;
30121 : 37000 : return NULL;
30122 : : }
30123 : 312 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30124 [ - + ]: 312 : if (!_seq) {
30125 : 0 : PyMem_Free(_children);
30126 : 0 : p->error_indicator = 1;
30127 : : PyErr_NoMemory();
30128 : 0 : p->level--;
30129 : 0 : return NULL;
30130 : : }
30131 [ + + ]: 672 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30132 : 312 : PyMem_Free(_children);
30133 : 312 : _PyPegen_insert_memo(p, _start_mark, _loop1_104_type, _seq);
30134 : 312 : p->level--;
30135 : 312 : return _seq;
30136 : : }
30137 : :
30138 : : // _loop0_105: lambda_param_no_default
30139 : : static asdl_seq *
30140 : 37255 : _loop0_105_rule(Parser *p)
30141 : : {
30142 [ - + ]: 37255 : if (p->level++ == MAXSTACK) {
30143 : 0 : p->error_indicator = 1;
30144 : : PyErr_NoMemory();
30145 : : }
30146 [ - + ]: 37255 : if (p->error_indicator) {
30147 : 0 : p->level--;
30148 : 0 : return NULL;
30149 : : }
30150 : 37255 : void *_res = NULL;
30151 : 37255 : int _mark = p->mark;
30152 : 37255 : int _start_mark = p->mark;
30153 : 37255 : void **_children = PyMem_Malloc(sizeof(void *));
30154 [ - + ]: 37255 : if (!_children) {
30155 : 0 : p->error_indicator = 1;
30156 : : PyErr_NoMemory();
30157 : 0 : p->level--;
30158 : 0 : return NULL;
30159 : : }
30160 : 37255 : Py_ssize_t _children_capacity = 1;
30161 : 37255 : Py_ssize_t _n = 0;
30162 : : { // lambda_param_no_default
30163 [ - + ]: 37255 : if (p->error_indicator) {
30164 : 0 : p->level--;
30165 : 0 : 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 : 37255 : while (
30170 [ + + ]: 204787 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
30171 : : )
30172 : : {
30173 : 167532 : _res = lambda_param_no_default_var;
30174 [ + + ]: 167532 : if (_n == _children_capacity) {
30175 : 81386 : _children_capacity *= 2;
30176 : 81386 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30177 [ - + ]: 81386 : if (!_new_children) {
30178 : 0 : p->error_indicator = 1;
30179 : : PyErr_NoMemory();
30180 : 0 : p->level--;
30181 : 0 : return NULL;
30182 : : }
30183 : 81386 : _children = _new_children;
30184 : : }
30185 : 167532 : _children[_n++] = _res;
30186 : 167532 : _mark = p->mark;
30187 : : }
30188 : 37255 : 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 : 37255 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30193 [ - + ]: 37255 : if (!_seq) {
30194 : 0 : PyMem_Free(_children);
30195 : 0 : p->error_indicator = 1;
30196 : : PyErr_NoMemory();
30197 : 0 : p->level--;
30198 : 0 : return NULL;
30199 : : }
30200 [ + + ]: 204787 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30201 : 37255 : PyMem_Free(_children);
30202 : 37255 : _PyPegen_insert_memo(p, _start_mark, _loop0_105_type, _seq);
30203 : 37255 : p->level--;
30204 : 37255 : return _seq;
30205 : : }
30206 : :
30207 : : // _loop1_106: lambda_param_with_default
30208 : : static asdl_seq *
30209 : 37255 : _loop1_106_rule(Parser *p)
30210 : : {
30211 [ - + ]: 37255 : if (p->level++ == MAXSTACK) {
30212 : 0 : p->error_indicator = 1;
30213 : : PyErr_NoMemory();
30214 : : }
30215 [ - + ]: 37255 : if (p->error_indicator) {
30216 : 0 : p->level--;
30217 : 0 : return NULL;
30218 : : }
30219 : 37255 : void *_res = NULL;
30220 : 37255 : int _mark = p->mark;
30221 : 37255 : int _start_mark = p->mark;
30222 : 37255 : void **_children = PyMem_Malloc(sizeof(void *));
30223 [ - + ]: 37255 : if (!_children) {
30224 : 0 : p->error_indicator = 1;
30225 : : PyErr_NoMemory();
30226 : 0 : p->level--;
30227 : 0 : return NULL;
30228 : : }
30229 : 37255 : Py_ssize_t _children_capacity = 1;
30230 : 37255 : Py_ssize_t _n = 0;
30231 : : { // lambda_param_with_default
30232 [ - + ]: 37255 : if (p->error_indicator) {
30233 : 0 : p->level--;
30234 : 0 : 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 : 37255 : while (
30239 [ + + ]: 37524 : (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
30240 : : )
30241 : : {
30242 : 269 : _res = lambda_param_with_default_var;
30243 [ + + ]: 269 : if (_n == _children_capacity) {
30244 : 12 : _children_capacity *= 2;
30245 : 12 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30246 [ - + ]: 12 : if (!_new_children) {
30247 : 0 : p->error_indicator = 1;
30248 : : PyErr_NoMemory();
30249 : 0 : p->level--;
30250 : 0 : return NULL;
30251 : : }
30252 : 12 : _children = _new_children;
30253 : : }
30254 : 269 : _children[_n++] = _res;
30255 : 269 : _mark = p->mark;
30256 : : }
30257 : 37255 : 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 [ + + - + ]: 37255 : if (_n == 0 || p->error_indicator) {
30262 : 36998 : PyMem_Free(_children);
30263 : 36998 : p->level--;
30264 : 36998 : return NULL;
30265 : : }
30266 : 257 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30267 [ - + ]: 257 : if (!_seq) {
30268 : 0 : PyMem_Free(_children);
30269 : 0 : p->error_indicator = 1;
30270 : : PyErr_NoMemory();
30271 : 0 : p->level--;
30272 : 0 : return NULL;
30273 : : }
30274 [ + + ]: 526 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30275 : 257 : PyMem_Free(_children);
30276 : 257 : _PyPegen_insert_memo(p, _start_mark, _loop1_106_type, _seq);
30277 : 257 : p->level--;
30278 : 257 : return _seq;
30279 : : }
30280 : :
30281 : : // _loop0_107: lambda_param_maybe_default
30282 : : static asdl_seq *
30283 : 295 : _loop0_107_rule(Parser *p)
30284 : : {
30285 [ - + ]: 295 : if (p->level++ == MAXSTACK) {
30286 : 0 : p->error_indicator = 1;
30287 : : PyErr_NoMemory();
30288 : : }
30289 [ - + ]: 295 : if (p->error_indicator) {
30290 : 0 : p->level--;
30291 : 0 : return NULL;
30292 : : }
30293 : 295 : void *_res = NULL;
30294 : 295 : int _mark = p->mark;
30295 : 295 : int _start_mark = p->mark;
30296 : 295 : void **_children = PyMem_Malloc(sizeof(void *));
30297 [ - + ]: 295 : if (!_children) {
30298 : 0 : p->error_indicator = 1;
30299 : : PyErr_NoMemory();
30300 : 0 : p->level--;
30301 : 0 : return NULL;
30302 : : }
30303 : 295 : Py_ssize_t _children_capacity = 1;
30304 : 295 : Py_ssize_t _n = 0;
30305 : : { // lambda_param_maybe_default
30306 [ - + ]: 295 : if (p->error_indicator) {
30307 : 0 : p->level--;
30308 : 0 : 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 : 295 : while (
30313 [ + + ]: 370 : (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
30314 : : )
30315 : : {
30316 : 75 : _res = lambda_param_maybe_default_var;
30317 [ + + ]: 75 : if (_n == _children_capacity) {
30318 : 21 : _children_capacity *= 2;
30319 : 21 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30320 [ - + ]: 21 : if (!_new_children) {
30321 : 0 : p->error_indicator = 1;
30322 : : PyErr_NoMemory();
30323 : 0 : p->level--;
30324 : 0 : return NULL;
30325 : : }
30326 : 21 : _children = _new_children;
30327 : : }
30328 : 75 : _children[_n++] = _res;
30329 : 75 : _mark = p->mark;
30330 : : }
30331 : 295 : 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 : 295 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30336 [ - + ]: 295 : if (!_seq) {
30337 : 0 : PyMem_Free(_children);
30338 : 0 : p->error_indicator = 1;
30339 : : PyErr_NoMemory();
30340 : 0 : p->level--;
30341 : 0 : return NULL;
30342 : : }
30343 [ + + ]: 370 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30344 : 295 : PyMem_Free(_children);
30345 : 295 : _PyPegen_insert_memo(p, _start_mark, _loop0_107_type, _seq);
30346 : 295 : p->level--;
30347 : 295 : return _seq;
30348 : : }
30349 : :
30350 : : // _loop1_108: lambda_param_maybe_default
30351 : : static asdl_seq *
30352 : 103 : _loop1_108_rule(Parser *p)
30353 : : {
30354 [ - + ]: 103 : if (p->level++ == MAXSTACK) {
30355 : 0 : p->error_indicator = 1;
30356 : : PyErr_NoMemory();
30357 : : }
30358 [ - + ]: 103 : if (p->error_indicator) {
30359 : 0 : p->level--;
30360 : 0 : return NULL;
30361 : : }
30362 : 103 : void *_res = NULL;
30363 : 103 : int _mark = p->mark;
30364 : 103 : int _start_mark = p->mark;
30365 : 103 : void **_children = PyMem_Malloc(sizeof(void *));
30366 [ - + ]: 103 : if (!_children) {
30367 : 0 : p->error_indicator = 1;
30368 : : PyErr_NoMemory();
30369 : 0 : p->level--;
30370 : 0 : return NULL;
30371 : : }
30372 : 103 : Py_ssize_t _children_capacity = 1;
30373 : 103 : Py_ssize_t _n = 0;
30374 : : { // lambda_param_maybe_default
30375 [ - + ]: 103 : if (p->error_indicator) {
30376 : 0 : p->level--;
30377 : 0 : 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 : 103 : while (
30382 [ + + ]: 244 : (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
30383 : : )
30384 : : {
30385 : 141 : _res = lambda_param_maybe_default_var;
30386 [ + + ]: 141 : if (_n == _children_capacity) {
30387 : 39 : _children_capacity *= 2;
30388 : 39 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30389 [ - + ]: 39 : if (!_new_children) {
30390 : 0 : p->error_indicator = 1;
30391 : : PyErr_NoMemory();
30392 : 0 : p->level--;
30393 : 0 : return NULL;
30394 : : }
30395 : 39 : _children = _new_children;
30396 : : }
30397 : 141 : _children[_n++] = _res;
30398 : 141 : _mark = p->mark;
30399 : : }
30400 : 103 : 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 [ + + - + ]: 103 : if (_n == 0 || p->error_indicator) {
30405 : 1 : PyMem_Free(_children);
30406 : 1 : p->level--;
30407 : 1 : return NULL;
30408 : : }
30409 : 102 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30410 [ - + ]: 102 : if (!_seq) {
30411 : 0 : PyMem_Free(_children);
30412 : 0 : p->error_indicator = 1;
30413 : : PyErr_NoMemory();
30414 : 0 : p->level--;
30415 : 0 : return NULL;
30416 : : }
30417 [ + + ]: 243 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30418 : 102 : PyMem_Free(_children);
30419 : 102 : _PyPegen_insert_memo(p, _start_mark, _loop1_108_type, _seq);
30420 : 102 : p->level--;
30421 : 102 : return _seq;
30422 : : }
30423 : :
30424 : : // _loop1_109: STRING
30425 : : static asdl_seq *
30426 : 1604162 : _loop1_109_rule(Parser *p)
30427 : : {
30428 [ - + ]: 1604162 : if (p->level++ == MAXSTACK) {
30429 : 0 : p->error_indicator = 1;
30430 : : PyErr_NoMemory();
30431 : : }
30432 [ - + ]: 1604162 : if (p->error_indicator) {
30433 : 0 : p->level--;
30434 : 0 : return NULL;
30435 : : }
30436 : 1604162 : void *_res = NULL;
30437 : 1604162 : int _mark = p->mark;
30438 : 1604162 : int _start_mark = p->mark;
30439 : 1604162 : void **_children = PyMem_Malloc(sizeof(void *));
30440 [ - + ]: 1604162 : if (!_children) {
30441 : 0 : p->error_indicator = 1;
30442 : : PyErr_NoMemory();
30443 : 0 : p->level--;
30444 : 0 : return NULL;
30445 : : }
30446 : 1604162 : Py_ssize_t _children_capacity = 1;
30447 : 1604162 : Py_ssize_t _n = 0;
30448 : : { // STRING
30449 [ - + ]: 1604162 : if (p->error_indicator) {
30450 : 0 : p->level--;
30451 : 0 : 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 : 1604162 : while (
30456 [ + + ]: 3290023 : (string_var = _PyPegen_string_token(p)) // STRING
30457 : : )
30458 : : {
30459 : 1685861 : _res = string_var;
30460 [ + + ]: 1685861 : if (_n == _children_capacity) {
30461 : 25992 : _children_capacity *= 2;
30462 : 25992 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30463 [ - + ]: 25992 : if (!_new_children) {
30464 : 0 : p->error_indicator = 1;
30465 : : PyErr_NoMemory();
30466 : 0 : p->level--;
30467 : 0 : return NULL;
30468 : : }
30469 : 25992 : _children = _new_children;
30470 : : }
30471 : 1685861 : _children[_n++] = _res;
30472 : 1685861 : _mark = p->mark;
30473 : : }
30474 : 1604162 : 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 [ + + + + ]: 1604162 : if (_n == 0 || p->error_indicator) {
30479 : 3345 : PyMem_Free(_children);
30480 : 3345 : p->level--;
30481 : 3345 : return NULL;
30482 : : }
30483 : 1600817 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30484 [ - + ]: 1600817 : if (!_seq) {
30485 : 0 : PyMem_Free(_children);
30486 : 0 : p->error_indicator = 1;
30487 : : PyErr_NoMemory();
30488 : 0 : p->level--;
30489 : 0 : return NULL;
30490 : : }
30491 [ + + ]: 3286676 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30492 : 1600817 : PyMem_Free(_children);
30493 : 1600817 : _PyPegen_insert_memo(p, _start_mark, _loop1_109_type, _seq);
30494 : 1600817 : p->level--;
30495 : 1600817 : return _seq;
30496 : : }
30497 : :
30498 : : // _tmp_110: star_named_expression ',' star_named_expressions?
30499 : : static void *
30500 : 863752 : _tmp_110_rule(Parser *p)
30501 : : {
30502 [ - + ]: 863752 : if (p->level++ == MAXSTACK) {
30503 : 0 : p->error_indicator = 1;
30504 : : PyErr_NoMemory();
30505 : : }
30506 [ - + ]: 863752 : if (p->error_indicator) {
30507 : 0 : p->level--;
30508 : 0 : return NULL;
30509 : : }
30510 : 863752 : void * _res = NULL;
30511 : 863752 : int _mark = p->mark;
30512 : : { // star_named_expression ',' star_named_expressions?
30513 [ - + ]: 863752 : if (p->error_indicator) {
30514 : 0 : p->level--;
30515 : 0 : 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 [ + + ]: 863752 : if (
30522 : 863752 : (y = star_named_expression_rule(p)) // star_named_expression
30523 [ + + ]: 841478 : &&
30524 : 841478 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
30525 : 548260 : &&
30526 [ + + ]: 548260 : (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions?
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 : 548243 : _res = _PyPegen_seq_insert_in_front ( p , y , z );
30531 [ - + - - ]: 548243 : if (_res == NULL && PyErr_Occurred()) {
30532 : 0 : p->error_indicator = 1;
30533 : 0 : p->level--;
30534 : 0 : return NULL;
30535 : : }
30536 : 548243 : goto done;
30537 : : }
30538 : 315509 : 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 : 315509 : _res = NULL;
30543 : 863752 : done:
30544 : 863752 : p->level--;
30545 : 863752 : return _res;
30546 : : }
30547 : :
30548 : : // _loop0_112: ',' double_starred_kvpair
30549 : : static asdl_seq *
30550 : 65085 : _loop0_112_rule(Parser *p)
30551 : : {
30552 [ - + ]: 65085 : if (p->level++ == MAXSTACK) {
30553 : 0 : p->error_indicator = 1;
30554 : : PyErr_NoMemory();
30555 : : }
30556 [ - + ]: 65085 : if (p->error_indicator) {
30557 : 0 : p->level--;
30558 : 0 : return NULL;
30559 : : }
30560 : 65085 : void *_res = NULL;
30561 : 65085 : int _mark = p->mark;
30562 : 65085 : int _start_mark = p->mark;
30563 : 65085 : void **_children = PyMem_Malloc(sizeof(void *));
30564 [ - + ]: 65085 : if (!_children) {
30565 : 0 : p->error_indicator = 1;
30566 : : PyErr_NoMemory();
30567 : 0 : p->level--;
30568 : 0 : return NULL;
30569 : : }
30570 : 65085 : Py_ssize_t _children_capacity = 1;
30571 : 65085 : Py_ssize_t _n = 0;
30572 : : { // ',' double_starred_kvpair
30573 [ - + ]: 65085 : if (p->error_indicator) {
30574 : 0 : p->level--;
30575 : 0 : 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 : 65085 : while (
30581 : 1524449 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
30582 [ + + + + ]: 3006287 : &&
30583 : 1481838 : (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
30584 : : )
30585 : : {
30586 : 1459364 : _res = elem;
30587 [ - + - - ]: 1459364 : if (_res == NULL && PyErr_Occurred()) {
30588 : 0 : p->error_indicator = 1;
30589 : 0 : PyMem_Free(_children);
30590 : 0 : p->level--;
30591 : 0 : return NULL;
30592 : : }
30593 [ + + ]: 1459364 : if (_n == _children_capacity) {
30594 : 109440 : _children_capacity *= 2;
30595 : 109440 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30596 [ - + ]: 109440 : if (!_new_children) {
30597 : 0 : p->error_indicator = 1;
30598 : : PyErr_NoMemory();
30599 : 0 : p->level--;
30600 : 0 : return NULL;
30601 : : }
30602 : 109440 : _children = _new_children;
30603 : : }
30604 : 1459364 : _children[_n++] = _res;
30605 : 1459364 : _mark = p->mark;
30606 : : }
30607 : 65085 : 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 : 65085 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30612 [ - + ]: 65085 : if (!_seq) {
30613 : 0 : PyMem_Free(_children);
30614 : 0 : p->error_indicator = 1;
30615 : : PyErr_NoMemory();
30616 : 0 : p->level--;
30617 : 0 : return NULL;
30618 : : }
30619 [ + + ]: 1524449 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30620 : 65085 : PyMem_Free(_children);
30621 : 65085 : _PyPegen_insert_memo(p, _start_mark, _loop0_112_type, _seq);
30622 : 65085 : p->level--;
30623 : 65085 : return _seq;
30624 : : }
30625 : :
30626 : : // _gather_111: double_starred_kvpair _loop0_112
30627 : : static asdl_seq *
30628 : 112968 : _gather_111_rule(Parser *p)
30629 : : {
30630 [ - + ]: 112968 : if (p->level++ == MAXSTACK) {
30631 : 0 : p->error_indicator = 1;
30632 : : PyErr_NoMemory();
30633 : : }
30634 [ - + ]: 112968 : if (p->error_indicator) {
30635 : 0 : p->level--;
30636 : 0 : return NULL;
30637 : : }
30638 : 112968 : asdl_seq * _res = NULL;
30639 : 112968 : int _mark = p->mark;
30640 : : { // double_starred_kvpair _loop0_112
30641 [ - + ]: 112968 : if (p->error_indicator) {
30642 : 0 : p->level--;
30643 : 0 : 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 [ + + ]: 112968 : if (
30649 : 112968 : (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
30650 [ + - ]: 65085 : &&
30651 : 65085 : (seq = _loop0_112_rule(p)) // _loop0_112
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 : 65085 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
30656 : 65085 : goto done;
30657 : : }
30658 : 47883 : 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 : 47883 : _res = NULL;
30663 : 112968 : done:
30664 : 112968 : p->level--;
30665 : 112968 : return _res;
30666 : : }
30667 : :
30668 : : // _loop1_113: for_if_clause
30669 : : static asdl_seq *
30670 : 2124538 : _loop1_113_rule(Parser *p)
30671 : : {
30672 [ - + ]: 2124538 : if (p->level++ == MAXSTACK) {
30673 : 0 : p->error_indicator = 1;
30674 : : PyErr_NoMemory();
30675 : : }
30676 [ - + ]: 2124538 : if (p->error_indicator) {
30677 : 0 : p->level--;
30678 : 0 : return NULL;
30679 : : }
30680 : 2124538 : void *_res = NULL;
30681 : 2124538 : int _mark = p->mark;
30682 : 2124538 : int _start_mark = p->mark;
30683 : 2124538 : void **_children = PyMem_Malloc(sizeof(void *));
30684 [ - + ]: 2124538 : if (!_children) {
30685 : 0 : p->error_indicator = 1;
30686 : : PyErr_NoMemory();
30687 : 0 : p->level--;
30688 : 0 : return NULL;
30689 : : }
30690 : 2124538 : Py_ssize_t _children_capacity = 1;
30691 : 2124538 : Py_ssize_t _n = 0;
30692 : : { // for_if_clause
30693 [ - + ]: 2124538 : if (p->error_indicator) {
30694 : 0 : p->level--;
30695 : 0 : 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 : 2124538 : while (
30700 [ + + ]: 2176116 : (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause
30701 : : )
30702 : : {
30703 : 51578 : _res = for_if_clause_var;
30704 [ + + ]: 51578 : if (_n == _children_capacity) {
30705 : 1950 : _children_capacity *= 2;
30706 : 1950 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30707 [ - + ]: 1950 : if (!_new_children) {
30708 : 0 : p->error_indicator = 1;
30709 : : PyErr_NoMemory();
30710 : 0 : p->level--;
30711 : 0 : return NULL;
30712 : : }
30713 : 1950 : _children = _new_children;
30714 : : }
30715 : 51578 : _children[_n++] = _res;
30716 : 51578 : _mark = p->mark;
30717 : : }
30718 : 2124538 : 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 [ + + - + ]: 2124538 : if (_n == 0 || p->error_indicator) {
30723 : 2074910 : PyMem_Free(_children);
30724 : 2074910 : p->level--;
30725 : 2074910 : return NULL;
30726 : : }
30727 : 49628 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30728 [ - + ]: 49628 : if (!_seq) {
30729 : 0 : PyMem_Free(_children);
30730 : 0 : p->error_indicator = 1;
30731 : : PyErr_NoMemory();
30732 : 0 : p->level--;
30733 : 0 : return NULL;
30734 : : }
30735 [ + + ]: 101206 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30736 : 49628 : PyMem_Free(_children);
30737 : 49628 : _PyPegen_insert_memo(p, _start_mark, _loop1_113_type, _seq);
30738 : 49628 : p->level--;
30739 : 49628 : return _seq;
30740 : : }
30741 : :
30742 : : // _loop0_114: ('if' disjunction)
30743 : : static asdl_seq *
30744 : 508 : _loop0_114_rule(Parser *p)
30745 : : {
30746 [ - + ]: 508 : if (p->level++ == MAXSTACK) {
30747 : 0 : p->error_indicator = 1;
30748 : : PyErr_NoMemory();
30749 : : }
30750 [ - + ]: 508 : if (p->error_indicator) {
30751 : 0 : p->level--;
30752 : 0 : return NULL;
30753 : : }
30754 : 508 : void *_res = NULL;
30755 : 508 : int _mark = p->mark;
30756 : 508 : int _start_mark = p->mark;
30757 : 508 : void **_children = PyMem_Malloc(sizeof(void *));
30758 [ - + ]: 508 : if (!_children) {
30759 : 0 : p->error_indicator = 1;
30760 : : PyErr_NoMemory();
30761 : 0 : p->level--;
30762 : 0 : return NULL;
30763 : : }
30764 : 508 : Py_ssize_t _children_capacity = 1;
30765 : 508 : Py_ssize_t _n = 0;
30766 : : { // ('if' disjunction)
30767 [ - + ]: 508 : if (p->error_indicator) {
30768 : 0 : p->level--;
30769 : 0 : 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 : 508 : while (
30774 [ + + ]: 568 : (_tmp_228_var = _tmp_228_rule(p)) // 'if' disjunction
30775 : : )
30776 : : {
30777 : 60 : _res = _tmp_228_var;
30778 [ - + ]: 60 : if (_n == _children_capacity) {
30779 : 0 : _children_capacity *= 2;
30780 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30781 [ # # ]: 0 : if (!_new_children) {
30782 : 0 : p->error_indicator = 1;
30783 : : PyErr_NoMemory();
30784 : 0 : p->level--;
30785 : 0 : return NULL;
30786 : : }
30787 : 0 : _children = _new_children;
30788 : : }
30789 : 60 : _children[_n++] = _res;
30790 : 60 : _mark = p->mark;
30791 : : }
30792 : 508 : 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 : 508 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30797 [ - + ]: 508 : if (!_seq) {
30798 : 0 : PyMem_Free(_children);
30799 : 0 : p->error_indicator = 1;
30800 : : PyErr_NoMemory();
30801 : 0 : p->level--;
30802 : 0 : return NULL;
30803 : : }
30804 [ + + ]: 568 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30805 : 508 : PyMem_Free(_children);
30806 : 508 : _PyPegen_insert_memo(p, _start_mark, _loop0_114_type, _seq);
30807 : 508 : p->level--;
30808 : 508 : return _seq;
30809 : : }
30810 : :
30811 : : // _loop0_115: ('if' disjunction)
30812 : : static asdl_seq *
30813 : 51072 : _loop0_115_rule(Parser *p)
30814 : : {
30815 [ - + ]: 51072 : if (p->level++ == MAXSTACK) {
30816 : 0 : p->error_indicator = 1;
30817 : : PyErr_NoMemory();
30818 : : }
30819 [ - + ]: 51072 : if (p->error_indicator) {
30820 : 0 : p->level--;
30821 : 0 : return NULL;
30822 : : }
30823 : 51072 : void *_res = NULL;
30824 : 51072 : int _mark = p->mark;
30825 : 51072 : int _start_mark = p->mark;
30826 : 51072 : void **_children = PyMem_Malloc(sizeof(void *));
30827 [ - + ]: 51072 : if (!_children) {
30828 : 0 : p->error_indicator = 1;
30829 : : PyErr_NoMemory();
30830 : 0 : p->level--;
30831 : 0 : return NULL;
30832 : : }
30833 : 51072 : Py_ssize_t _children_capacity = 1;
30834 : 51072 : Py_ssize_t _n = 0;
30835 : : { // ('if' disjunction)
30836 [ - + ]: 51072 : if (p->error_indicator) {
30837 : 0 : p->level--;
30838 : 0 : 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 : 51072 : while (
30843 [ + + ]: 63504 : (_tmp_229_var = _tmp_229_rule(p)) // 'if' disjunction
30844 : : )
30845 : : {
30846 : 12432 : _res = _tmp_229_var;
30847 [ + + ]: 12432 : if (_n == _children_capacity) {
30848 : 22 : _children_capacity *= 2;
30849 : 22 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30850 [ - + ]: 22 : if (!_new_children) {
30851 : 0 : p->error_indicator = 1;
30852 : : PyErr_NoMemory();
30853 : 0 : p->level--;
30854 : 0 : return NULL;
30855 : : }
30856 : 22 : _children = _new_children;
30857 : : }
30858 : 12432 : _children[_n++] = _res;
30859 : 12432 : _mark = p->mark;
30860 : : }
30861 : 51072 : 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 : 51072 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30866 [ - + ]: 51072 : if (!_seq) {
30867 : 0 : PyMem_Free(_children);
30868 : 0 : p->error_indicator = 1;
30869 : : PyErr_NoMemory();
30870 : 0 : p->level--;
30871 : 0 : return NULL;
30872 : : }
30873 [ + + ]: 63504 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30874 : 51072 : PyMem_Free(_children);
30875 : 51072 : _PyPegen_insert_memo(p, _start_mark, _loop0_115_type, _seq);
30876 : 51072 : p->level--;
30877 : 51072 : return _seq;
30878 : : }
30879 : :
30880 : : // _tmp_116: assignment_expression | expression !':='
30881 : : static void *
30882 : 3090425 : _tmp_116_rule(Parser *p)
30883 : : {
30884 [ - + ]: 3090425 : if (p->level++ == MAXSTACK) {
30885 : 0 : p->error_indicator = 1;
30886 : : PyErr_NoMemory();
30887 : : }
30888 [ - + ]: 3090425 : if (p->error_indicator) {
30889 : 0 : p->level--;
30890 : 0 : return NULL;
30891 : : }
30892 : 3090425 : void * _res = NULL;
30893 : 3090425 : int _mark = p->mark;
30894 : : { // assignment_expression
30895 [ - + ]: 3090425 : if (p->error_indicator) {
30896 : 0 : p->level--;
30897 : 0 : 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 [ + + ]: 3090425 : if (
30902 : 3090425 : (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
30903 : : )
30904 : : {
30905 : : D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
30906 : 58 : _res = assignment_expression_var;
30907 : 58 : goto done;
30908 : : }
30909 : 3090367 : 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 [ + + ]: 3090367 : if (p->error_indicator) {
30915 : 27 : p->level--;
30916 : 27 : 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 [ + + ]: 3090340 : if (
30921 : 3090340 : (expression_var = expression_rule(p)) // expression
30922 [ + + ]: 2089685 : &&
30923 : 2089685 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
30924 : : )
30925 : : {
30926 : : D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
30927 : 2089679 : _res = expression_var;
30928 : 2089679 : goto done;
30929 : : }
30930 : 1000661 : 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 : 1000661 : _res = NULL;
30935 : 3090398 : done:
30936 : 3090398 : p->level--;
30937 : 3090398 : return _res;
30938 : : }
30939 : :
30940 : : // _loop0_118: ',' (starred_expression | (assignment_expression | expression !':=') !'=')
30941 : : static asdl_seq *
30942 : 1344264 : _loop0_118_rule(Parser *p)
30943 : : {
30944 [ - + ]: 1344264 : if (p->level++ == MAXSTACK) {
30945 : 0 : p->error_indicator = 1;
30946 : : PyErr_NoMemory();
30947 : : }
30948 [ - + ]: 1344264 : if (p->error_indicator) {
30949 : 0 : p->level--;
30950 : 0 : return NULL;
30951 : : }
30952 : 1344264 : void *_res = NULL;
30953 : 1344264 : int _mark = p->mark;
30954 : 1344264 : int _start_mark = p->mark;
30955 : 1344264 : void **_children = PyMem_Malloc(sizeof(void *));
30956 [ - + ]: 1344264 : if (!_children) {
30957 : 0 : p->error_indicator = 1;
30958 : : PyErr_NoMemory();
30959 : 0 : p->level--;
30960 : 0 : return NULL;
30961 : : }
30962 : 1344264 : Py_ssize_t _children_capacity = 1;
30963 : 1344264 : Py_ssize_t _n = 0;
30964 : : { // ',' (starred_expression | (assignment_expression | expression !':=') !'=')
30965 [ - + ]: 1344264 : if (p->error_indicator) {
30966 : 0 : p->level--;
30967 : 0 : 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 : 1344264 : while (
30973 : 2095148 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
30974 [ + + + + ]: 2918541 : &&
30975 : 823393 : (elem = _tmp_230_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'='
30976 : : )
30977 : : {
30978 : 750884 : _res = elem;
30979 [ - + - - ]: 750884 : if (_res == NULL && PyErr_Occurred()) {
30980 : 0 : p->error_indicator = 1;
30981 : 0 : PyMem_Free(_children);
30982 : 0 : p->level--;
30983 : 0 : return NULL;
30984 : : }
30985 [ + + ]: 750884 : if (_n == _children_capacity) {
30986 : 165708 : _children_capacity *= 2;
30987 : 165708 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30988 [ - + ]: 165708 : if (!_new_children) {
30989 : 0 : p->error_indicator = 1;
30990 : : PyErr_NoMemory();
30991 : 0 : p->level--;
30992 : 0 : return NULL;
30993 : : }
30994 : 165708 : _children = _new_children;
30995 : : }
30996 : 750884 : _children[_n++] = _res;
30997 : 750884 : _mark = p->mark;
30998 : : }
30999 : 1344264 : 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 : 1344264 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31004 [ - + ]: 1344264 : if (!_seq) {
31005 : 0 : PyMem_Free(_children);
31006 : 0 : p->error_indicator = 1;
31007 : : PyErr_NoMemory();
31008 : 0 : p->level--;
31009 : 0 : return NULL;
31010 : : }
31011 [ + + ]: 2095148 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31012 : 1344264 : PyMem_Free(_children);
31013 : 1344264 : _PyPegen_insert_memo(p, _start_mark, _loop0_118_type, _seq);
31014 : 1344264 : p->level--;
31015 : 1344264 : return _seq;
31016 : : }
31017 : :
31018 : : // _gather_117:
31019 : : // | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118
31020 : : static asdl_seq *
31021 : 1928538 : _gather_117_rule(Parser *p)
31022 : : {
31023 [ - + ]: 1928538 : if (p->level++ == MAXSTACK) {
31024 : 0 : p->error_indicator = 1;
31025 : : PyErr_NoMemory();
31026 : : }
31027 [ - + ]: 1928538 : if (p->error_indicator) {
31028 : 0 : p->level--;
31029 : 0 : return NULL;
31030 : : }
31031 : 1928538 : asdl_seq * _res = NULL;
31032 : 1928538 : int _mark = p->mark;
31033 : : { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118
31034 [ - + ]: 1928538 : if (p->error_indicator) {
31035 : 0 : p->level--;
31036 : 0 : 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 [ + + ]: 1928538 : if (
31042 : 1928538 : (elem = _tmp_230_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'='
31043 [ + - ]: 1344264 : &&
31044 : 1344264 : (seq = _loop0_118_rule(p)) // _loop0_118
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 : 1344264 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31049 : 1344264 : goto done;
31050 : : }
31051 : 584274 : 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 : 584274 : _res = NULL;
31056 : 1928538 : done:
31057 : 1928538 : p->level--;
31058 : 1928538 : return _res;
31059 : : }
31060 : :
31061 : : // _tmp_119: ',' kwargs
31062 : : static void *
31063 : 1344264 : _tmp_119_rule(Parser *p)
31064 : : {
31065 [ - + ]: 1344264 : if (p->level++ == MAXSTACK) {
31066 : 0 : p->error_indicator = 1;
31067 : : PyErr_NoMemory();
31068 : : }
31069 [ + + ]: 1344264 : if (p->error_indicator) {
31070 : 14 : p->level--;
31071 : 14 : return NULL;
31072 : : }
31073 : 1344250 : void * _res = NULL;
31074 : 1344250 : int _mark = p->mark;
31075 : : { // ',' kwargs
31076 [ - + ]: 1344250 : if (p->error_indicator) {
31077 : 0 : p->level--;
31078 : 0 : 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 [ + + ]: 1344250 : if (
31084 : 1344250 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31085 [ + + ]: 72495 : &&
31086 : 72495 : (k = kwargs_rule(p)) // kwargs
31087 : : )
31088 : : {
31089 : : D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs"));
31090 : 67393 : _res = k;
31091 [ - + - - ]: 67393 : if (_res == NULL && PyErr_Occurred()) {
31092 : 0 : p->error_indicator = 1;
31093 : 0 : p->level--;
31094 : 0 : return NULL;
31095 : : }
31096 : 67393 : goto done;
31097 : : }
31098 : 1276857 : 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 : 1276857 : _res = NULL;
31103 : 1344250 : done:
31104 : 1344250 : p->level--;
31105 : 1344250 : return _res;
31106 : : }
31107 : :
31108 : : // _loop0_121: ',' kwarg_or_starred
31109 : : static asdl_seq *
31110 : 98713 : _loop0_121_rule(Parser *p)
31111 : : {
31112 [ - + ]: 98713 : if (p->level++ == MAXSTACK) {
31113 : 0 : p->error_indicator = 1;
31114 : : PyErr_NoMemory();
31115 : : }
31116 [ - + ]: 98713 : if (p->error_indicator) {
31117 : 0 : p->level--;
31118 : 0 : return NULL;
31119 : : }
31120 : 98713 : void *_res = NULL;
31121 : 98713 : int _mark = p->mark;
31122 : 98713 : int _start_mark = p->mark;
31123 : 98713 : void **_children = PyMem_Malloc(sizeof(void *));
31124 [ - + ]: 98713 : if (!_children) {
31125 : 0 : p->error_indicator = 1;
31126 : : PyErr_NoMemory();
31127 : 0 : p->level--;
31128 : 0 : return NULL;
31129 : : }
31130 : 98713 : Py_ssize_t _children_capacity = 1;
31131 : 98713 : Py_ssize_t _n = 0;
31132 : : { // ',' kwarg_or_starred
31133 [ - + ]: 98713 : if (p->error_indicator) {
31134 : 0 : p->level--;
31135 : 0 : 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 : 98713 : while (
31141 : 175247 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31142 [ + + + + ]: 260348 : &&
31143 : 85101 : (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
31144 : : )
31145 : : {
31146 : 76534 : _res = elem;
31147 [ - + - - ]: 76534 : if (_res == NULL && PyErr_Occurred()) {
31148 : 0 : p->error_indicator = 1;
31149 : 0 : PyMem_Free(_children);
31150 : 0 : p->level--;
31151 : 0 : return NULL;
31152 : : }
31153 [ + + ]: 76534 : if (_n == _children_capacity) {
31154 : 29841 : _children_capacity *= 2;
31155 : 29841 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31156 [ - + ]: 29841 : if (!_new_children) {
31157 : 0 : p->error_indicator = 1;
31158 : : PyErr_NoMemory();
31159 : 0 : p->level--;
31160 : 0 : return NULL;
31161 : : }
31162 : 29841 : _children = _new_children;
31163 : : }
31164 : 76534 : _children[_n++] = _res;
31165 : 76534 : _mark = p->mark;
31166 : : }
31167 : 98713 : 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 : 98713 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31172 [ - + ]: 98713 : if (!_seq) {
31173 : 0 : PyMem_Free(_children);
31174 : 0 : p->error_indicator = 1;
31175 : : PyErr_NoMemory();
31176 : 0 : p->level--;
31177 : 0 : return NULL;
31178 : : }
31179 [ + + ]: 175247 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31180 : 98713 : PyMem_Free(_children);
31181 : 98713 : _PyPegen_insert_memo(p, _start_mark, _loop0_121_type, _seq);
31182 : 98713 : p->level--;
31183 : 98713 : return _seq;
31184 : : }
31185 : :
31186 : : // _gather_120: kwarg_or_starred _loop0_121
31187 : : static asdl_seq *
31188 : 656767 : _gather_120_rule(Parser *p)
31189 : : {
31190 [ - + ]: 656767 : if (p->level++ == MAXSTACK) {
31191 : 0 : p->error_indicator = 1;
31192 : : PyErr_NoMemory();
31193 : : }
31194 [ - + ]: 656767 : if (p->error_indicator) {
31195 : 0 : p->level--;
31196 : 0 : return NULL;
31197 : : }
31198 : 656767 : asdl_seq * _res = NULL;
31199 : 656767 : int _mark = p->mark;
31200 : : { // kwarg_or_starred _loop0_121
31201 [ - + ]: 656767 : if (p->error_indicator) {
31202 : 0 : p->level--;
31203 : 0 : 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 [ + + ]: 656767 : if (
31209 : 656767 : (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
31210 [ + - ]: 98713 : &&
31211 : 98713 : (seq = _loop0_121_rule(p)) // _loop0_121
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 : 98713 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31216 : 98713 : goto done;
31217 : : }
31218 : 558054 : 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 : 558054 : _res = NULL;
31223 : 656767 : done:
31224 : 656767 : p->level--;
31225 : 656767 : return _res;
31226 : : }
31227 : :
31228 : : // _loop0_123: ',' kwarg_or_double_starred
31229 : : static asdl_seq *
31230 : 1044 : _loop0_123_rule(Parser *p)
31231 : : {
31232 [ - + ]: 1044 : if (p->level++ == MAXSTACK) {
31233 : 0 : p->error_indicator = 1;
31234 : : PyErr_NoMemory();
31235 : : }
31236 [ - + ]: 1044 : if (p->error_indicator) {
31237 : 0 : p->level--;
31238 : 0 : return NULL;
31239 : : }
31240 : 1044 : void *_res = NULL;
31241 : 1044 : int _mark = p->mark;
31242 : 1044 : int _start_mark = p->mark;
31243 : 1044 : void **_children = PyMem_Malloc(sizeof(void *));
31244 [ - + ]: 1044 : if (!_children) {
31245 : 0 : p->error_indicator = 1;
31246 : : PyErr_NoMemory();
31247 : 0 : p->level--;
31248 : 0 : return NULL;
31249 : : }
31250 : 1044 : Py_ssize_t _children_capacity = 1;
31251 : 1044 : Py_ssize_t _n = 0;
31252 : : { // ',' kwarg_or_double_starred
31253 [ - + ]: 1044 : if (p->error_indicator) {
31254 : 0 : p->level--;
31255 : 0 : 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 : 1044 : while (
31261 : 1060 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31262 [ + + + + ]: 1089 : &&
31263 : 29 : (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
31264 : : )
31265 : : {
31266 : 16 : _res = elem;
31267 [ - + - - ]: 16 : if (_res == NULL && PyErr_Occurred()) {
31268 : 0 : p->error_indicator = 1;
31269 : 0 : PyMem_Free(_children);
31270 : 0 : p->level--;
31271 : 0 : return NULL;
31272 : : }
31273 [ - + ]: 16 : if (_n == _children_capacity) {
31274 : 0 : _children_capacity *= 2;
31275 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31276 [ # # ]: 0 : if (!_new_children) {
31277 : 0 : p->error_indicator = 1;
31278 : : PyErr_NoMemory();
31279 : 0 : p->level--;
31280 : 0 : return NULL;
31281 : : }
31282 : 0 : _children = _new_children;
31283 : : }
31284 : 16 : _children[_n++] = _res;
31285 : 16 : _mark = p->mark;
31286 : : }
31287 : 1044 : 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 : 1044 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31292 [ - + ]: 1044 : if (!_seq) {
31293 : 0 : PyMem_Free(_children);
31294 : 0 : p->error_indicator = 1;
31295 : : PyErr_NoMemory();
31296 : 0 : p->level--;
31297 : 0 : return NULL;
31298 : : }
31299 [ + + ]: 1060 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31300 : 1044 : PyMem_Free(_children);
31301 : 1044 : _PyPegen_insert_memo(p, _start_mark, _loop0_123_type, _seq);
31302 : 1044 : p->level--;
31303 : 1044 : return _seq;
31304 : : }
31305 : :
31306 : : // _gather_122: kwarg_or_double_starred _loop0_123
31307 : : static asdl_seq *
31308 : 8567 : _gather_122_rule(Parser *p)
31309 : : {
31310 [ - + ]: 8567 : if (p->level++ == MAXSTACK) {
31311 : 0 : p->error_indicator = 1;
31312 : : PyErr_NoMemory();
31313 : : }
31314 [ - + ]: 8567 : if (p->error_indicator) {
31315 : 0 : p->level--;
31316 : 0 : return NULL;
31317 : : }
31318 : 8567 : asdl_seq * _res = NULL;
31319 : 8567 : int _mark = p->mark;
31320 : : { // kwarg_or_double_starred _loop0_123
31321 [ - + ]: 8567 : if (p->error_indicator) {
31322 : 0 : p->level--;
31323 : 0 : 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 [ + + ]: 8567 : if (
31329 : 8567 : (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
31330 [ + - ]: 1044 : &&
31331 : 1044 : (seq = _loop0_123_rule(p)) // _loop0_123
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 : 1044 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31336 : 1044 : goto done;
31337 : : }
31338 : 7523 : 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 : 7523 : _res = NULL;
31343 : 8567 : done:
31344 : 8567 : p->level--;
31345 : 8567 : return _res;
31346 : : }
31347 : :
31348 : : // _loop0_125: ',' kwarg_or_starred
31349 : : static asdl_seq *
31350 : 97669 : _loop0_125_rule(Parser *p)
31351 : : {
31352 [ - + ]: 97669 : if (p->level++ == MAXSTACK) {
31353 : 0 : p->error_indicator = 1;
31354 : : PyErr_NoMemory();
31355 : : }
31356 [ - + ]: 97669 : if (p->error_indicator) {
31357 : 0 : p->level--;
31358 : 0 : return NULL;
31359 : : }
31360 : 97669 : void *_res = NULL;
31361 : 97669 : int _mark = p->mark;
31362 : 97669 : int _start_mark = p->mark;
31363 : 97669 : void **_children = PyMem_Malloc(sizeof(void *));
31364 [ - + ]: 97669 : if (!_children) {
31365 : 0 : p->error_indicator = 1;
31366 : : PyErr_NoMemory();
31367 : 0 : p->level--;
31368 : 0 : return NULL;
31369 : : }
31370 : 97669 : Py_ssize_t _children_capacity = 1;
31371 : 97669 : Py_ssize_t _n = 0;
31372 : : { // ',' kwarg_or_starred
31373 [ - + ]: 97669 : if (p->error_indicator) {
31374 : 0 : p->level--;
31375 : 0 : 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 : 97669 : while (
31381 : 172788 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31382 [ + + + + ]: 255430 : &&
31383 : 82642 : (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
31384 : : )
31385 : : {
31386 : 75119 : _res = elem;
31387 [ - + - - ]: 75119 : if (_res == NULL && PyErr_Occurred()) {
31388 : 0 : p->error_indicator = 1;
31389 : 0 : PyMem_Free(_children);
31390 : 0 : p->level--;
31391 : 0 : return NULL;
31392 : : }
31393 [ + + ]: 75119 : if (_n == _children_capacity) {
31394 : 29202 : _children_capacity *= 2;
31395 : 29202 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31396 [ - + ]: 29202 : if (!_new_children) {
31397 : 0 : p->error_indicator = 1;
31398 : : PyErr_NoMemory();
31399 : 0 : p->level--;
31400 : 0 : return NULL;
31401 : : }
31402 : 29202 : _children = _new_children;
31403 : : }
31404 : 75119 : _children[_n++] = _res;
31405 : 75119 : _mark = p->mark;
31406 : : }
31407 : 97669 : 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 : 97669 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31412 [ - + ]: 97669 : if (!_seq) {
31413 : 0 : PyMem_Free(_children);
31414 : 0 : p->error_indicator = 1;
31415 : : PyErr_NoMemory();
31416 : 0 : p->level--;
31417 : 0 : return NULL;
31418 : : }
31419 [ + + ]: 172788 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31420 : 97669 : PyMem_Free(_children);
31421 : 97669 : _PyPegen_insert_memo(p, _start_mark, _loop0_125_type, _seq);
31422 : 97669 : p->level--;
31423 : 97669 : return _seq;
31424 : : }
31425 : :
31426 : : // _gather_124: kwarg_or_starred _loop0_125
31427 : : static asdl_seq *
31428 : 655709 : _gather_124_rule(Parser *p)
31429 : : {
31430 [ - + ]: 655709 : if (p->level++ == MAXSTACK) {
31431 : 0 : p->error_indicator = 1;
31432 : : PyErr_NoMemory();
31433 : : }
31434 [ - + ]: 655709 : if (p->error_indicator) {
31435 : 0 : p->level--;
31436 : 0 : return NULL;
31437 : : }
31438 : 655709 : asdl_seq * _res = NULL;
31439 : 655709 : int _mark = p->mark;
31440 : : { // kwarg_or_starred _loop0_125
31441 [ - + ]: 655709 : if (p->error_indicator) {
31442 : 0 : p->level--;
31443 : 0 : 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 [ + + ]: 655709 : if (
31449 : 655709 : (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
31450 [ + - ]: 97669 : &&
31451 : 97669 : (seq = _loop0_125_rule(p)) // _loop0_125
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 : 97669 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31456 : 97669 : goto done;
31457 : : }
31458 : 558040 : 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 : 558040 : _res = NULL;
31463 : 655709 : done:
31464 : 655709 : p->level--;
31465 : 655709 : return _res;
31466 : : }
31467 : :
31468 : : // _loop0_127: ',' kwarg_or_double_starred
31469 : : static asdl_seq *
31470 : 7424 : _loop0_127_rule(Parser *p)
31471 : : {
31472 [ - + ]: 7424 : if (p->level++ == MAXSTACK) {
31473 : 0 : p->error_indicator = 1;
31474 : : PyErr_NoMemory();
31475 : : }
31476 [ - + ]: 7424 : if (p->error_indicator) {
31477 : 0 : p->level--;
31478 : 0 : return NULL;
31479 : : }
31480 : 7424 : void *_res = NULL;
31481 : 7424 : int _mark = p->mark;
31482 : 7424 : int _start_mark = p->mark;
31483 : 7424 : void **_children = PyMem_Malloc(sizeof(void *));
31484 [ - + ]: 7424 : if (!_children) {
31485 : 0 : p->error_indicator = 1;
31486 : : PyErr_NoMemory();
31487 : 0 : p->level--;
31488 : 0 : return NULL;
31489 : : }
31490 : 7424 : Py_ssize_t _children_capacity = 1;
31491 : 7424 : Py_ssize_t _n = 0;
31492 : : { // ',' kwarg_or_double_starred
31493 [ - + ]: 7424 : if (p->error_indicator) {
31494 : 0 : p->level--;
31495 : 0 : 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 : 7424 : while (
31501 : 7472 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31502 [ + + + + ]: 7534 : &&
31503 : 62 : (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
31504 : : )
31505 : : {
31506 : 48 : _res = elem;
31507 [ - + - - ]: 48 : if (_res == NULL && PyErr_Occurred()) {
31508 : 0 : p->error_indicator = 1;
31509 : 0 : PyMem_Free(_children);
31510 : 0 : p->level--;
31511 : 0 : return NULL;
31512 : : }
31513 [ + + ]: 48 : if (_n == _children_capacity) {
31514 : 13 : _children_capacity *= 2;
31515 : 13 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31516 [ - + ]: 13 : if (!_new_children) {
31517 : 0 : p->error_indicator = 1;
31518 : : PyErr_NoMemory();
31519 : 0 : p->level--;
31520 : 0 : return NULL;
31521 : : }
31522 : 13 : _children = _new_children;
31523 : : }
31524 : 48 : _children[_n++] = _res;
31525 : 48 : _mark = p->mark;
31526 : : }
31527 : 7424 : 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 : 7424 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31532 [ - + ]: 7424 : if (!_seq) {
31533 : 0 : PyMem_Free(_children);
31534 : 0 : p->error_indicator = 1;
31535 : : PyErr_NoMemory();
31536 : 0 : p->level--;
31537 : 0 : return NULL;
31538 : : }
31539 [ + + ]: 7472 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31540 : 7424 : PyMem_Free(_children);
31541 : 7424 : _PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq);
31542 : 7424 : p->level--;
31543 : 7424 : return _seq;
31544 : : }
31545 : :
31546 : : // _gather_126: kwarg_or_double_starred _loop0_127
31547 : : static asdl_seq *
31548 : 558040 : _gather_126_rule(Parser *p)
31549 : : {
31550 [ - + ]: 558040 : if (p->level++ == MAXSTACK) {
31551 : 0 : p->error_indicator = 1;
31552 : : PyErr_NoMemory();
31553 : : }
31554 [ - + ]: 558040 : if (p->error_indicator) {
31555 : 0 : p->level--;
31556 : 0 : return NULL;
31557 : : }
31558 : 558040 : asdl_seq * _res = NULL;
31559 : 558040 : int _mark = p->mark;
31560 : : { // kwarg_or_double_starred _loop0_127
31561 [ - + ]: 558040 : if (p->error_indicator) {
31562 : 0 : p->level--;
31563 : 0 : 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 [ + + ]: 558040 : if (
31569 : 558040 : (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
31570 [ + - ]: 7424 : &&
31571 : 7424 : (seq = _loop0_127_rule(p)) // _loop0_127
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 : 7424 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31576 : 7424 : goto done;
31577 : : }
31578 : 550616 : 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 : 550616 : _res = NULL;
31583 : 558040 : done:
31584 : 558040 : p->level--;
31585 : 558040 : return _res;
31586 : : }
31587 : :
31588 : : // _loop0_128: (',' star_target)
31589 : : static asdl_seq *
31590 : 56752 : _loop0_128_rule(Parser *p)
31591 : : {
31592 [ - + ]: 56752 : if (p->level++ == MAXSTACK) {
31593 : 0 : p->error_indicator = 1;
31594 : : PyErr_NoMemory();
31595 : : }
31596 [ - + ]: 56752 : if (p->error_indicator) {
31597 : 0 : p->level--;
31598 : 0 : return NULL;
31599 : : }
31600 : 56752 : void *_res = NULL;
31601 : 56752 : int _mark = p->mark;
31602 : 56752 : int _start_mark = p->mark;
31603 : 56752 : void **_children = PyMem_Malloc(sizeof(void *));
31604 [ - + ]: 56752 : if (!_children) {
31605 : 0 : p->error_indicator = 1;
31606 : : PyErr_NoMemory();
31607 : 0 : p->level--;
31608 : 0 : return NULL;
31609 : : }
31610 : 56752 : Py_ssize_t _children_capacity = 1;
31611 : 56752 : Py_ssize_t _n = 0;
31612 : : { // (',' star_target)
31613 [ - + ]: 56752 : if (p->error_indicator) {
31614 : 0 : p->level--;
31615 : 0 : 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 : 56752 : while (
31620 [ + + ]: 135571 : (_tmp_231_var = _tmp_231_rule(p)) // ',' star_target
31621 : : )
31622 : : {
31623 : 78819 : _res = _tmp_231_var;
31624 [ + + ]: 78819 : if (_n == _children_capacity) {
31625 : 17309 : _children_capacity *= 2;
31626 : 17309 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31627 [ - + ]: 17309 : if (!_new_children) {
31628 : 0 : p->error_indicator = 1;
31629 : : PyErr_NoMemory();
31630 : 0 : p->level--;
31631 : 0 : return NULL;
31632 : : }
31633 : 17309 : _children = _new_children;
31634 : : }
31635 : 78819 : _children[_n++] = _res;
31636 : 78819 : _mark = p->mark;
31637 : : }
31638 : 56752 : 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 : 56752 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31643 [ - + ]: 56752 : if (!_seq) {
31644 : 0 : PyMem_Free(_children);
31645 : 0 : p->error_indicator = 1;
31646 : : PyErr_NoMemory();
31647 : 0 : p->level--;
31648 : 0 : return NULL;
31649 : : }
31650 [ + + ]: 135571 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31651 : 56752 : PyMem_Free(_children);
31652 : 56752 : _PyPegen_insert_memo(p, _start_mark, _loop0_128_type, _seq);
31653 : 56752 : p->level--;
31654 : 56752 : return _seq;
31655 : : }
31656 : :
31657 : : // _loop0_130: ',' star_target
31658 : : static asdl_seq *
31659 : 12099 : _loop0_130_rule(Parser *p)
31660 : : {
31661 [ - + ]: 12099 : if (p->level++ == MAXSTACK) {
31662 : 0 : p->error_indicator = 1;
31663 : : PyErr_NoMemory();
31664 : : }
31665 [ - + ]: 12099 : if (p->error_indicator) {
31666 : 0 : p->level--;
31667 : 0 : return NULL;
31668 : : }
31669 : 12099 : void *_res = NULL;
31670 : 12099 : int _mark = p->mark;
31671 : 12099 : int _start_mark = p->mark;
31672 : 12099 : void **_children = PyMem_Malloc(sizeof(void *));
31673 [ - + ]: 12099 : if (!_children) {
31674 : 0 : p->error_indicator = 1;
31675 : : PyErr_NoMemory();
31676 : 0 : p->level--;
31677 : 0 : return NULL;
31678 : : }
31679 : 12099 : Py_ssize_t _children_capacity = 1;
31680 : 12099 : Py_ssize_t _n = 0;
31681 : : { // ',' star_target
31682 [ - + ]: 12099 : if (p->error_indicator) {
31683 : 0 : p->level--;
31684 : 0 : 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 : 12099 : while (
31690 : 16028 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31691 [ + + + + ]: 20485 : &&
31692 : 4457 : (elem = star_target_rule(p)) // star_target
31693 : : )
31694 : : {
31695 : 3929 : _res = elem;
31696 [ - + - - ]: 3929 : if (_res == NULL && PyErr_Occurred()) {
31697 : 0 : p->error_indicator = 1;
31698 : 0 : PyMem_Free(_children);
31699 : 0 : p->level--;
31700 : 0 : return NULL;
31701 : : }
31702 [ + + ]: 3929 : if (_n == _children_capacity) {
31703 : 1283 : _children_capacity *= 2;
31704 : 1283 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31705 [ - + ]: 1283 : if (!_new_children) {
31706 : 0 : p->error_indicator = 1;
31707 : : PyErr_NoMemory();
31708 : 0 : p->level--;
31709 : 0 : return NULL;
31710 : : }
31711 : 1283 : _children = _new_children;
31712 : : }
31713 : 3929 : _children[_n++] = _res;
31714 : 3929 : _mark = p->mark;
31715 : : }
31716 : 12099 : 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 : 12099 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31721 [ - + ]: 12099 : if (!_seq) {
31722 : 0 : PyMem_Free(_children);
31723 : 0 : p->error_indicator = 1;
31724 : : PyErr_NoMemory();
31725 : 0 : p->level--;
31726 : 0 : return NULL;
31727 : : }
31728 [ + + ]: 16028 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31729 : 12099 : PyMem_Free(_children);
31730 : 12099 : _PyPegen_insert_memo(p, _start_mark, _loop0_130_type, _seq);
31731 : 12099 : p->level--;
31732 : 12099 : return _seq;
31733 : : }
31734 : :
31735 : : // _gather_129: star_target _loop0_130
31736 : : static asdl_seq *
31737 : 42591 : _gather_129_rule(Parser *p)
31738 : : {
31739 [ - + ]: 42591 : if (p->level++ == MAXSTACK) {
31740 : 0 : p->error_indicator = 1;
31741 : : PyErr_NoMemory();
31742 : : }
31743 [ - + ]: 42591 : if (p->error_indicator) {
31744 : 0 : p->level--;
31745 : 0 : return NULL;
31746 : : }
31747 : 42591 : asdl_seq * _res = NULL;
31748 : 42591 : int _mark = p->mark;
31749 : : { // star_target _loop0_130
31750 [ - + ]: 42591 : if (p->error_indicator) {
31751 : 0 : p->level--;
31752 : 0 : 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 [ + + ]: 42591 : if (
31758 : 42591 : (elem = star_target_rule(p)) // star_target
31759 [ + - ]: 12099 : &&
31760 : 12099 : (seq = _loop0_130_rule(p)) // _loop0_130
31761 : : )
31762 : : {
31763 : : D(fprintf(stderr, "%*c+ _gather_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_130"));
31764 : 12099 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31765 : 12099 : goto done;
31766 : : }
31767 : 30492 : 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 : 30492 : _res = NULL;
31772 : 42591 : done:
31773 : 42591 : p->level--;
31774 : 42591 : return _res;
31775 : : }
31776 : :
31777 : : // _loop1_131: (',' star_target)
31778 : : static asdl_seq *
31779 : 16500 : _loop1_131_rule(Parser *p)
31780 : : {
31781 [ - + ]: 16500 : if (p->level++ == MAXSTACK) {
31782 : 0 : p->error_indicator = 1;
31783 : : PyErr_NoMemory();
31784 : : }
31785 [ - + ]: 16500 : if (p->error_indicator) {
31786 : 0 : p->level--;
31787 : 0 : return NULL;
31788 : : }
31789 : 16500 : void *_res = NULL;
31790 : 16500 : int _mark = p->mark;
31791 : 16500 : int _start_mark = p->mark;
31792 : 16500 : void **_children = PyMem_Malloc(sizeof(void *));
31793 [ - + ]: 16500 : if (!_children) {
31794 : 0 : p->error_indicator = 1;
31795 : : PyErr_NoMemory();
31796 : 0 : p->level--;
31797 : 0 : return NULL;
31798 : : }
31799 : 16500 : Py_ssize_t _children_capacity = 1;
31800 : 16500 : Py_ssize_t _n = 0;
31801 : : { // (',' star_target)
31802 [ - + ]: 16500 : if (p->error_indicator) {
31803 : 0 : p->level--;
31804 : 0 : 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 : 16500 : while (
31809 [ + + ]: 32920 : (_tmp_232_var = _tmp_232_rule(p)) // ',' star_target
31810 : : )
31811 : : {
31812 : 16420 : _res = _tmp_232_var;
31813 [ + + ]: 16420 : if (_n == _children_capacity) {
31814 : 3868 : _children_capacity *= 2;
31815 : 3868 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31816 [ - + ]: 3868 : if (!_new_children) {
31817 : 0 : p->error_indicator = 1;
31818 : : PyErr_NoMemory();
31819 : 0 : p->level--;
31820 : 0 : return NULL;
31821 : : }
31822 : 3868 : _children = _new_children;
31823 : : }
31824 : 16420 : _children[_n++] = _res;
31825 : 16420 : _mark = p->mark;
31826 : : }
31827 : 16500 : 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 [ + + - + ]: 16500 : if (_n == 0 || p->error_indicator) {
31832 : 8909 : PyMem_Free(_children);
31833 : 8909 : p->level--;
31834 : 8909 : return NULL;
31835 : : }
31836 : 7591 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31837 [ - + ]: 7591 : if (!_seq) {
31838 : 0 : PyMem_Free(_children);
31839 : 0 : p->error_indicator = 1;
31840 : : PyErr_NoMemory();
31841 : 0 : p->level--;
31842 : 0 : return NULL;
31843 : : }
31844 [ + + ]: 24011 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31845 : 7591 : PyMem_Free(_children);
31846 : 7591 : _PyPegen_insert_memo(p, _start_mark, _loop1_131_type, _seq);
31847 : 7591 : p->level--;
31848 : 7591 : return _seq;
31849 : : }
31850 : :
31851 : : // _tmp_132: !'*' star_target
31852 : : static void *
31853 : 733 : _tmp_132_rule(Parser *p)
31854 : : {
31855 [ - + ]: 733 : if (p->level++ == MAXSTACK) {
31856 : 0 : p->error_indicator = 1;
31857 : : PyErr_NoMemory();
31858 : : }
31859 [ - + ]: 733 : if (p->error_indicator) {
31860 : 0 : p->level--;
31861 : 0 : return NULL;
31862 : : }
31863 : 733 : void * _res = NULL;
31864 : 733 : int _mark = p->mark;
31865 : : { // !'*' star_target
31866 [ - + ]: 733 : if (p->error_indicator) {
31867 : 0 : p->level--;
31868 : 0 : 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 [ + - ]: 733 : if (
31873 : 733 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*'
31874 [ + + ]: 733 : &&
31875 : 733 : (star_target_var = star_target_rule(p)) // star_target
31876 : : )
31877 : : {
31878 : : D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target"));
31879 : 697 : _res = star_target_var;
31880 : 697 : goto done;
31881 : : }
31882 : 36 : 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 : 36 : _res = NULL;
31887 : 733 : done:
31888 : 733 : p->level--;
31889 : 733 : return _res;
31890 : : }
31891 : :
31892 : : // _loop0_134: ',' del_target
31893 : : static asdl_seq *
31894 : 8864 : _loop0_134_rule(Parser *p)
31895 : : {
31896 [ - + ]: 8864 : if (p->level++ == MAXSTACK) {
31897 : 0 : p->error_indicator = 1;
31898 : : PyErr_NoMemory();
31899 : : }
31900 [ - + ]: 8864 : if (p->error_indicator) {
31901 : 0 : p->level--;
31902 : 0 : return NULL;
31903 : : }
31904 : 8864 : void *_res = NULL;
31905 : 8864 : int _mark = p->mark;
31906 : 8864 : int _start_mark = p->mark;
31907 : 8864 : void **_children = PyMem_Malloc(sizeof(void *));
31908 [ - + ]: 8864 : if (!_children) {
31909 : 0 : p->error_indicator = 1;
31910 : : PyErr_NoMemory();
31911 : 0 : p->level--;
31912 : 0 : return NULL;
31913 : : }
31914 : 8864 : Py_ssize_t _children_capacity = 1;
31915 : 8864 : Py_ssize_t _n = 0;
31916 : : { // ',' del_target
31917 [ - + ]: 8864 : if (p->error_indicator) {
31918 : 0 : p->level--;
31919 : 0 : 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 : 8864 : while (
31925 : 10616 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31926 [ + + + + ]: 12381 : &&
31927 : 1765 : (elem = del_target_rule(p)) // del_target
31928 : : )
31929 : : {
31930 : 1752 : _res = elem;
31931 [ - + - - ]: 1752 : if (_res == NULL && PyErr_Occurred()) {
31932 : 0 : p->error_indicator = 1;
31933 : 0 : PyMem_Free(_children);
31934 : 0 : p->level--;
31935 : 0 : return NULL;
31936 : : }
31937 [ + + ]: 1752 : if (_n == _children_capacity) {
31938 : 546 : _children_capacity *= 2;
31939 : 546 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31940 [ - + ]: 546 : if (!_new_children) {
31941 : 0 : p->error_indicator = 1;
31942 : : PyErr_NoMemory();
31943 : 0 : p->level--;
31944 : 0 : return NULL;
31945 : : }
31946 : 546 : _children = _new_children;
31947 : : }
31948 : 1752 : _children[_n++] = _res;
31949 : 1752 : _mark = p->mark;
31950 : : }
31951 : 8864 : 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 : 8864 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31956 [ - + ]: 8864 : if (!_seq) {
31957 : 0 : PyMem_Free(_children);
31958 : 0 : p->error_indicator = 1;
31959 : : PyErr_NoMemory();
31960 : 0 : p->level--;
31961 : 0 : return NULL;
31962 : : }
31963 [ + + ]: 10616 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31964 : 8864 : PyMem_Free(_children);
31965 : 8864 : _PyPegen_insert_memo(p, _start_mark, _loop0_134_type, _seq);
31966 : 8864 : p->level--;
31967 : 8864 : return _seq;
31968 : : }
31969 : :
31970 : : // _gather_133: del_target _loop0_134
31971 : : static asdl_seq *
31972 : 8930 : _gather_133_rule(Parser *p)
31973 : : {
31974 [ - + ]: 8930 : if (p->level++ == MAXSTACK) {
31975 : 0 : p->error_indicator = 1;
31976 : : PyErr_NoMemory();
31977 : : }
31978 [ - + ]: 8930 : if (p->error_indicator) {
31979 : 0 : p->level--;
31980 : 0 : return NULL;
31981 : : }
31982 : 8930 : asdl_seq * _res = NULL;
31983 : 8930 : int _mark = p->mark;
31984 : : { // del_target _loop0_134
31985 [ - + ]: 8930 : if (p->error_indicator) {
31986 : 0 : p->level--;
31987 : 0 : 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 [ + + ]: 8930 : if (
31993 : 8930 : (elem = del_target_rule(p)) // del_target
31994 [ + - ]: 8864 : &&
31995 : 8864 : (seq = _loop0_134_rule(p)) // _loop0_134
31996 : : )
31997 : : {
31998 : : D(fprintf(stderr, "%*c+ _gather_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_134"));
31999 : 8864 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
32000 : 8864 : goto done;
32001 : : }
32002 : 66 : 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 : 66 : _res = NULL;
32007 : 8930 : done:
32008 : 8930 : p->level--;
32009 : 8930 : return _res;
32010 : : }
32011 : :
32012 : : // _loop0_136: ',' expression
32013 : : static asdl_seq *
32014 : 10 : _loop0_136_rule(Parser *p)
32015 : : {
32016 [ - + ]: 10 : if (p->level++ == MAXSTACK) {
32017 : 0 : p->error_indicator = 1;
32018 : : PyErr_NoMemory();
32019 : : }
32020 [ - + ]: 10 : if (p->error_indicator) {
32021 : 0 : p->level--;
32022 : 0 : return NULL;
32023 : : }
32024 : 10 : void *_res = NULL;
32025 : 10 : int _mark = p->mark;
32026 : 10 : int _start_mark = p->mark;
32027 : 10 : void **_children = PyMem_Malloc(sizeof(void *));
32028 [ - + ]: 10 : if (!_children) {
32029 : 0 : p->error_indicator = 1;
32030 : : PyErr_NoMemory();
32031 : 0 : p->level--;
32032 : 0 : return NULL;
32033 : : }
32034 : 10 : Py_ssize_t _children_capacity = 1;
32035 : 10 : Py_ssize_t _n = 0;
32036 : : { // ',' expression
32037 [ - + ]: 10 : if (p->error_indicator) {
32038 : 0 : p->level--;
32039 : 0 : 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 : 10 : while (
32045 : 14 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
32046 [ + + + + ]: 23 : &&
32047 : 9 : (elem = expression_rule(p)) // expression
32048 : : )
32049 : : {
32050 : 4 : _res = elem;
32051 [ - + - - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
32052 : 0 : p->error_indicator = 1;
32053 : 0 : PyMem_Free(_children);
32054 : 0 : p->level--;
32055 : 0 : return NULL;
32056 : : }
32057 [ - + ]: 4 : if (_n == _children_capacity) {
32058 : 0 : _children_capacity *= 2;
32059 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32060 [ # # ]: 0 : if (!_new_children) {
32061 : 0 : p->error_indicator = 1;
32062 : : PyErr_NoMemory();
32063 : 0 : p->level--;
32064 : 0 : return NULL;
32065 : : }
32066 : 0 : _children = _new_children;
32067 : : }
32068 : 4 : _children[_n++] = _res;
32069 : 4 : _mark = p->mark;
32070 : : }
32071 : 10 : 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 : 10 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32076 [ - + ]: 10 : if (!_seq) {
32077 : 0 : PyMem_Free(_children);
32078 : 0 : p->error_indicator = 1;
32079 : : PyErr_NoMemory();
32080 : 0 : p->level--;
32081 : 0 : return NULL;
32082 : : }
32083 [ + + ]: 14 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32084 : 10 : PyMem_Free(_children);
32085 : 10 : _PyPegen_insert_memo(p, _start_mark, _loop0_136_type, _seq);
32086 : 10 : p->level--;
32087 : 10 : return _seq;
32088 : : }
32089 : :
32090 : : // _gather_135: expression _loop0_136
32091 : : static asdl_seq *
32092 : 18 : _gather_135_rule(Parser *p)
32093 : : {
32094 [ - + ]: 18 : if (p->level++ == MAXSTACK) {
32095 : 0 : p->error_indicator = 1;
32096 : : PyErr_NoMemory();
32097 : : }
32098 [ - + ]: 18 : if (p->error_indicator) {
32099 : 0 : p->level--;
32100 : 0 : return NULL;
32101 : : }
32102 : 18 : asdl_seq * _res = NULL;
32103 : 18 : int _mark = p->mark;
32104 : : { // expression _loop0_136
32105 [ - + ]: 18 : if (p->error_indicator) {
32106 : 0 : p->level--;
32107 : 0 : 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 [ + + ]: 18 : if (
32113 : 18 : (elem = expression_rule(p)) // expression
32114 [ + - ]: 10 : &&
32115 : 10 : (seq = _loop0_136_rule(p)) // _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 : 10 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
32120 : 10 : goto done;
32121 : : }
32122 : 8 : 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 : 8 : _res = NULL;
32127 : 18 : done:
32128 : 18 : p->level--;
32129 : 18 : return _res;
32130 : : }
32131 : :
32132 : : // _loop0_138: ',' expression
32133 : : static asdl_seq *
32134 : 9 : _loop0_138_rule(Parser *p)
32135 : : {
32136 [ - + ]: 9 : if (p->level++ == MAXSTACK) {
32137 : 0 : p->error_indicator = 1;
32138 : : PyErr_NoMemory();
32139 : : }
32140 [ - + ]: 9 : if (p->error_indicator) {
32141 : 0 : p->level--;
32142 : 0 : return NULL;
32143 : : }
32144 : 9 : void *_res = NULL;
32145 : 9 : int _mark = p->mark;
32146 : 9 : int _start_mark = p->mark;
32147 : 9 : void **_children = PyMem_Malloc(sizeof(void *));
32148 [ - + ]: 9 : if (!_children) {
32149 : 0 : p->error_indicator = 1;
32150 : : PyErr_NoMemory();
32151 : 0 : p->level--;
32152 : 0 : return NULL;
32153 : : }
32154 : 9 : Py_ssize_t _children_capacity = 1;
32155 : 9 : Py_ssize_t _n = 0;
32156 : : { // ',' expression
32157 [ - + ]: 9 : if (p->error_indicator) {
32158 : 0 : p->level--;
32159 : 0 : 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 : 9 : while (
32165 : 13 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
32166 [ + + + + ]: 21 : &&
32167 : 8 : (elem = expression_rule(p)) // expression
32168 : : )
32169 : : {
32170 : 4 : _res = elem;
32171 [ - + - - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
32172 : 0 : p->error_indicator = 1;
32173 : 0 : PyMem_Free(_children);
32174 : 0 : p->level--;
32175 : 0 : return NULL;
32176 : : }
32177 [ - + ]: 4 : if (_n == _children_capacity) {
32178 : 0 : _children_capacity *= 2;
32179 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32180 [ # # ]: 0 : if (!_new_children) {
32181 : 0 : p->error_indicator = 1;
32182 : : PyErr_NoMemory();
32183 : 0 : p->level--;
32184 : 0 : return NULL;
32185 : : }
32186 : 0 : _children = _new_children;
32187 : : }
32188 : 4 : _children[_n++] = _res;
32189 : 4 : _mark = p->mark;
32190 : : }
32191 : 9 : 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 : 9 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32196 [ - + ]: 9 : if (!_seq) {
32197 : 0 : PyMem_Free(_children);
32198 : 0 : p->error_indicator = 1;
32199 : : PyErr_NoMemory();
32200 : 0 : p->level--;
32201 : 0 : return NULL;
32202 : : }
32203 [ + + ]: 13 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32204 : 9 : PyMem_Free(_children);
32205 : 9 : _PyPegen_insert_memo(p, _start_mark, _loop0_138_type, _seq);
32206 : 9 : p->level--;
32207 : 9 : return _seq;
32208 : : }
32209 : :
32210 : : // _gather_137: expression _loop0_138
32211 : : static asdl_seq *
32212 : 17 : _gather_137_rule(Parser *p)
32213 : : {
32214 [ - + ]: 17 : if (p->level++ == MAXSTACK) {
32215 : 0 : p->error_indicator = 1;
32216 : : PyErr_NoMemory();
32217 : : }
32218 [ - + ]: 17 : if (p->error_indicator) {
32219 : 0 : p->level--;
32220 : 0 : return NULL;
32221 : : }
32222 : 17 : asdl_seq * _res = NULL;
32223 : 17 : int _mark = p->mark;
32224 : : { // expression _loop0_138
32225 [ - + ]: 17 : if (p->error_indicator) {
32226 : 0 : p->level--;
32227 : 0 : 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 [ + + ]: 17 : if (
32233 : 17 : (elem = expression_rule(p)) // expression
32234 [ + - ]: 9 : &&
32235 : 9 : (seq = _loop0_138_rule(p)) // _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 : 9 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
32240 : 9 : goto done;
32241 : : }
32242 : 8 : 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 : 8 : _res = NULL;
32247 : 17 : done:
32248 : 17 : p->level--;
32249 : 17 : return _res;
32250 : : }
32251 : :
32252 : : // _loop0_140: ',' expression
32253 : : static asdl_seq *
32254 : 7 : _loop0_140_rule(Parser *p)
32255 : : {
32256 [ - + ]: 7 : if (p->level++ == MAXSTACK) {
32257 : 0 : p->error_indicator = 1;
32258 : : PyErr_NoMemory();
32259 : : }
32260 [ - + ]: 7 : if (p->error_indicator) {
32261 : 0 : p->level--;
32262 : 0 : return NULL;
32263 : : }
32264 : 7 : void *_res = NULL;
32265 : 7 : int _mark = p->mark;
32266 : 7 : int _start_mark = p->mark;
32267 : 7 : void **_children = PyMem_Malloc(sizeof(void *));
32268 [ - + ]: 7 : if (!_children) {
32269 : 0 : p->error_indicator = 1;
32270 : : PyErr_NoMemory();
32271 : 0 : p->level--;
32272 : 0 : return NULL;
32273 : : }
32274 : 7 : Py_ssize_t _children_capacity = 1;
32275 : 7 : Py_ssize_t _n = 0;
32276 : : { // ',' expression
32277 [ - + ]: 7 : if (p->error_indicator) {
32278 : 0 : p->level--;
32279 : 0 : 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 : 7 : while (
32285 : 11 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
32286 [ + + + + ]: 17 : &&
32287 : 6 : (elem = expression_rule(p)) // expression
32288 : : )
32289 : : {
32290 : 4 : _res = elem;
32291 [ - + - - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
32292 : 0 : p->error_indicator = 1;
32293 : 0 : PyMem_Free(_children);
32294 : 0 : p->level--;
32295 : 0 : return NULL;
32296 : : }
32297 [ - + ]: 4 : if (_n == _children_capacity) {
32298 : 0 : _children_capacity *= 2;
32299 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32300 [ # # ]: 0 : if (!_new_children) {
32301 : 0 : p->error_indicator = 1;
32302 : : PyErr_NoMemory();
32303 : 0 : p->level--;
32304 : 0 : return NULL;
32305 : : }
32306 : 0 : _children = _new_children;
32307 : : }
32308 : 4 : _children[_n++] = _res;
32309 : 4 : _mark = p->mark;
32310 : : }
32311 : 7 : 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 : 7 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32316 [ - + ]: 7 : if (!_seq) {
32317 : 0 : PyMem_Free(_children);
32318 : 0 : p->error_indicator = 1;
32319 : : PyErr_NoMemory();
32320 : 0 : p->level--;
32321 : 0 : return NULL;
32322 : : }
32323 [ + + ]: 11 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32324 : 7 : PyMem_Free(_children);
32325 : 7 : _PyPegen_insert_memo(p, _start_mark, _loop0_140_type, _seq);
32326 : 7 : p->level--;
32327 : 7 : return _seq;
32328 : : }
32329 : :
32330 : : // _gather_139: expression _loop0_140
32331 : : static asdl_seq *
32332 : 15 : _gather_139_rule(Parser *p)
32333 : : {
32334 [ - + ]: 15 : if (p->level++ == MAXSTACK) {
32335 : 0 : p->error_indicator = 1;
32336 : : PyErr_NoMemory();
32337 : : }
32338 [ - + ]: 15 : if (p->error_indicator) {
32339 : 0 : p->level--;
32340 : 0 : return NULL;
32341 : : }
32342 : 15 : asdl_seq * _res = NULL;
32343 : 15 : int _mark = p->mark;
32344 : : { // expression _loop0_140
32345 [ - + ]: 15 : if (p->error_indicator) {
32346 : 0 : p->level--;
32347 : 0 : 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 [ + + ]: 15 : if (
32353 : 15 : (elem = expression_rule(p)) // expression
32354 [ + - ]: 7 : &&
32355 : 7 : (seq = _loop0_140_rule(p)) // _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 : 7 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
32360 : 7 : goto done;
32361 : : }
32362 : 8 : 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 : 8 : _res = NULL;
32367 : 15 : done:
32368 : 15 : p->level--;
32369 : 15 : return _res;
32370 : : }
32371 : :
32372 : : // _loop0_142: ',' expression
32373 : : static asdl_seq *
32374 : 5 : _loop0_142_rule(Parser *p)
32375 : : {
32376 [ - + ]: 5 : if (p->level++ == MAXSTACK) {
32377 : 0 : p->error_indicator = 1;
32378 : : PyErr_NoMemory();
32379 : : }
32380 [ - + ]: 5 : if (p->error_indicator) {
32381 : 0 : p->level--;
32382 : 0 : return NULL;
32383 : : }
32384 : 5 : void *_res = NULL;
32385 : 5 : int _mark = p->mark;
32386 : 5 : int _start_mark = p->mark;
32387 : 5 : void **_children = PyMem_Malloc(sizeof(void *));
32388 [ - + ]: 5 : if (!_children) {
32389 : 0 : p->error_indicator = 1;
32390 : : PyErr_NoMemory();
32391 : 0 : p->level--;
32392 : 0 : return NULL;
32393 : : }
32394 : 5 : Py_ssize_t _children_capacity = 1;
32395 : 5 : Py_ssize_t _n = 0;
32396 : : { // ',' expression
32397 [ - + ]: 5 : if (p->error_indicator) {
32398 : 0 : p->level--;
32399 : 0 : 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 : 5 : while (
32405 : 9 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
32406 [ + + + - ]: 13 : &&
32407 : 4 : (elem = expression_rule(p)) // expression
32408 : : )
32409 : : {
32410 : 4 : _res = elem;
32411 [ - + - - ]: 4 : if (_res == NULL && PyErr_Occurred()) {
32412 : 0 : p->error_indicator = 1;
32413 : 0 : PyMem_Free(_children);
32414 : 0 : p->level--;
32415 : 0 : return NULL;
32416 : : }
32417 [ - + ]: 4 : if (_n == _children_capacity) {
32418 : 0 : _children_capacity *= 2;
32419 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32420 [ # # ]: 0 : if (!_new_children) {
32421 : 0 : p->error_indicator = 1;
32422 : : PyErr_NoMemory();
32423 : 0 : p->level--;
32424 : 0 : return NULL;
32425 : : }
32426 : 0 : _children = _new_children;
32427 : : }
32428 : 4 : _children[_n++] = _res;
32429 : 4 : _mark = p->mark;
32430 : : }
32431 : 5 : 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 : 5 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32436 [ - + ]: 5 : if (!_seq) {
32437 : 0 : PyMem_Free(_children);
32438 : 0 : p->error_indicator = 1;
32439 : : PyErr_NoMemory();
32440 : 0 : p->level--;
32441 : 0 : return NULL;
32442 : : }
32443 [ + + ]: 9 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32444 : 5 : PyMem_Free(_children);
32445 : 5 : _PyPegen_insert_memo(p, _start_mark, _loop0_142_type, _seq);
32446 : 5 : p->level--;
32447 : 5 : return _seq;
32448 : : }
32449 : :
32450 : : // _gather_141: expression _loop0_142
32451 : : static asdl_seq *
32452 : 8 : _gather_141_rule(Parser *p)
32453 : : {
32454 [ - + ]: 8 : if (p->level++ == MAXSTACK) {
32455 : 0 : p->error_indicator = 1;
32456 : : PyErr_NoMemory();
32457 : : }
32458 [ - + ]: 8 : if (p->error_indicator) {
32459 : 0 : p->level--;
32460 : 0 : return NULL;
32461 : : }
32462 : 8 : asdl_seq * _res = NULL;
32463 : 8 : int _mark = p->mark;
32464 : : { // expression _loop0_142
32465 [ - + ]: 8 : if (p->error_indicator) {
32466 : 0 : p->level--;
32467 : 0 : 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 [ + + ]: 8 : if (
32473 : 8 : (elem = expression_rule(p)) // expression
32474 [ + - ]: 5 : &&
32475 : 5 : (seq = _loop0_142_rule(p)) // _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 : 5 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
32480 : 5 : goto done;
32481 : : }
32482 : 3 : 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 : 3 : _res = NULL;
32487 : 8 : done:
32488 : 8 : p->level--;
32489 : 8 : return _res;
32490 : : }
32491 : :
32492 : : // _tmp_143: NEWLINE INDENT
32493 : : static void *
32494 : 27 : _tmp_143_rule(Parser *p)
32495 : : {
32496 [ - + ]: 27 : if (p->level++ == MAXSTACK) {
32497 : 0 : p->error_indicator = 1;
32498 : : PyErr_NoMemory();
32499 : : }
32500 [ - + ]: 27 : if (p->error_indicator) {
32501 : 0 : p->level--;
32502 : 0 : return NULL;
32503 : : }
32504 : 27 : void * _res = NULL;
32505 : 27 : int _mark = p->mark;
32506 : : { // NEWLINE INDENT
32507 [ - + ]: 27 : if (p->error_indicator) {
32508 : 0 : p->level--;
32509 : 0 : 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 [ + - ]: 27 : if (
32515 : 27 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
32516 [ + - ]: 27 : &&
32517 : 27 : (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 : 27 : _res = _PyPegen_dummy_name(p, newline_var, indent_var);
32522 : 27 : goto done;
32523 : : }
32524 : 0 : 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 : 0 : _res = NULL;
32529 : 27 : done:
32530 : 27 : p->level--;
32531 : 27 : return _res;
32532 : : }
32533 : :
32534 : : // _tmp_144: args | expression for_if_clauses
32535 : : static void *
32536 : 11 : _tmp_144_rule(Parser *p)
32537 : : {
32538 [ - + ]: 11 : if (p->level++ == MAXSTACK) {
32539 : 0 : p->error_indicator = 1;
32540 : : PyErr_NoMemory();
32541 : : }
32542 [ - + ]: 11 : if (p->error_indicator) {
32543 : 0 : p->level--;
32544 : 0 : return NULL;
32545 : : }
32546 : 11 : void * _res = NULL;
32547 : 11 : int _mark = p->mark;
32548 : : { // args
32549 [ - + ]: 11 : if (p->error_indicator) {
32550 : 0 : p->level--;
32551 : 0 : 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 [ + + ]: 11 : if (
32556 : 11 : (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 : 9 : _res = args_var;
32561 : 9 : goto done;
32562 : : }
32563 : 2 : 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 [ + + ]: 2 : if (p->error_indicator) {
32569 : 1 : p->level--;
32570 : 1 : 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 [ - + ]: 1 : if (
32576 : 1 : (expression_var = expression_rule(p)) // expression
32577 [ # # ]: 0 : &&
32578 : 0 : (for_if_clauses_var = for_if_clauses_rule(p)) // 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 : 0 : _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var);
32583 : 0 : goto done;
32584 : : }
32585 : 1 : 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 : 1 : _res = NULL;
32590 : 10 : done:
32591 : 10 : p->level--;
32592 : 10 : return _res;
32593 : : }
32594 : :
32595 : : // _tmp_145: 'True' | 'False' | 'None'
32596 : : static void *
32597 : 1130 : _tmp_145_rule(Parser *p)
32598 : : {
32599 [ - + ]: 1130 : if (p->level++ == MAXSTACK) {
32600 : 0 : p->error_indicator = 1;
32601 : : PyErr_NoMemory();
32602 : : }
32603 [ - + ]: 1130 : if (p->error_indicator) {
32604 : 0 : p->level--;
32605 : 0 : return NULL;
32606 : : }
32607 : 1130 : void * _res = NULL;
32608 : 1130 : int _mark = p->mark;
32609 : : { // 'True'
32610 [ - + ]: 1130 : if (p->error_indicator) {
32611 : 0 : p->level--;
32612 : 0 : return NULL;
32613 : : }
32614 : : D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
32615 : : Token * _keyword;
32616 [ + + ]: 1130 : if (
32617 : 1130 : (_keyword = _PyPegen_expect_token(p, 600)) // token='True'
32618 : : )
32619 : : {
32620 : : D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
32621 : 1 : _res = _keyword;
32622 : 1 : goto done;
32623 : : }
32624 : 1129 : 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 [ - + ]: 1129 : if (p->error_indicator) {
32630 : 0 : p->level--;
32631 : 0 : return NULL;
32632 : : }
32633 : : D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
32634 : : Token * _keyword;
32635 [ + + ]: 1129 : if (
32636 : 1129 : (_keyword = _PyPegen_expect_token(p, 602)) // token='False'
32637 : : )
32638 : : {
32639 : : D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
32640 : 1 : _res = _keyword;
32641 : 1 : goto done;
32642 : : }
32643 : 1128 : 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 [ - + ]: 1128 : if (p->error_indicator) {
32649 : 0 : p->level--;
32650 : 0 : return NULL;
32651 : : }
32652 : : D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
32653 : : Token * _keyword;
32654 [ + + ]: 1128 : if (
32655 : 1128 : (_keyword = _PyPegen_expect_token(p, 601)) // token='None'
32656 : : )
32657 : : {
32658 : : D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
32659 : 2 : _res = _keyword;
32660 : 2 : goto done;
32661 : : }
32662 : 1126 : 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 : 1126 : _res = NULL;
32667 : 1130 : done:
32668 : 1130 : p->level--;
32669 : 1130 : return _res;
32670 : : }
32671 : :
32672 : : // _tmp_146: NAME '='
32673 : : static void *
32674 : 1125 : _tmp_146_rule(Parser *p)
32675 : : {
32676 [ - + ]: 1125 : if (p->level++ == MAXSTACK) {
32677 : 0 : p->error_indicator = 1;
32678 : : PyErr_NoMemory();
32679 : : }
32680 [ - + ]: 1125 : if (p->error_indicator) {
32681 : 0 : p->level--;
32682 : 0 : return NULL;
32683 : : }
32684 : 1125 : void * _res = NULL;
32685 : 1125 : int _mark = p->mark;
32686 : : { // NAME '='
32687 [ - + ]: 1125 : if (p->error_indicator) {
32688 : 0 : p->level--;
32689 : 0 : 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 [ + + ]: 1125 : if (
32695 : 1125 : (name_var = _PyPegen_name_token(p)) // NAME
32696 [ + + ]: 276 : &&
32697 : 276 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
32698 : : )
32699 : : {
32700 : : D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='"));
32701 : 167 : _res = _PyPegen_dummy_name(p, name_var, _literal);
32702 : 167 : goto done;
32703 : : }
32704 : 958 : 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 : 958 : _res = NULL;
32709 : 1125 : done:
32710 : 1125 : p->level--;
32711 : 1125 : return _res;
32712 : : }
32713 : :
32714 : : // _tmp_147: NAME STRING | SOFT_KEYWORD
32715 : : static void *
32716 : 2706 : _tmp_147_rule(Parser *p)
32717 : : {
32718 [ - + ]: 2706 : if (p->level++ == MAXSTACK) {
32719 : 0 : p->error_indicator = 1;
32720 : : PyErr_NoMemory();
32721 : : }
32722 [ - + ]: 2706 : if (p->error_indicator) {
32723 : 0 : p->level--;
32724 : 0 : return NULL;
32725 : : }
32726 : 2706 : void * _res = NULL;
32727 : 2706 : int _mark = p->mark;
32728 : : { // NAME STRING
32729 [ - + ]: 2706 : if (p->error_indicator) {
32730 : 0 : p->level--;
32731 : 0 : 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 [ + + ]: 2706 : if (
32737 : 2706 : (name_var = _PyPegen_name_token(p)) // NAME
32738 [ + + ]: 704 : &&
32739 : 704 : (string_var = _PyPegen_string_token(p)) // STRING
32740 : : )
32741 : : {
32742 : : D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING"));
32743 : 63 : _res = _PyPegen_dummy_name(p, name_var, string_var);
32744 : 63 : goto done;
32745 : : }
32746 : 2643 : 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 [ - + ]: 2643 : if (p->error_indicator) {
32752 : 0 : p->level--;
32753 : 0 : 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 [ + + ]: 2643 : if (
32758 : 2643 : (soft_keyword_var = _PyPegen_soft_keyword_token(p)) // SOFT_KEYWORD
32759 : : )
32760 : : {
32761 : : D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD"));
32762 : 31 : _res = soft_keyword_var;
32763 : 31 : goto done;
32764 : : }
32765 : 2612 : 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 : 2612 : _res = NULL;
32770 : 2706 : done:
32771 : 2706 : p->level--;
32772 : 2706 : return _res;
32773 : : }
32774 : :
32775 : : // _tmp_148: 'else' | ':'
32776 : : static void *
32777 : 7 : _tmp_148_rule(Parser *p)
32778 : : {
32779 [ - + ]: 7 : if (p->level++ == MAXSTACK) {
32780 : 0 : p->error_indicator = 1;
32781 : : PyErr_NoMemory();
32782 : : }
32783 [ - + ]: 7 : if (p->error_indicator) {
32784 : 0 : p->level--;
32785 : 0 : return NULL;
32786 : : }
32787 : 7 : void * _res = NULL;
32788 : 7 : int _mark = p->mark;
32789 : : { // 'else'
32790 [ - + ]: 7 : if (p->error_indicator) {
32791 : 0 : p->level--;
32792 : 0 : return NULL;
32793 : : }
32794 : : D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'"));
32795 : : Token * _keyword;
32796 [ + + ]: 7 : if (
32797 : 7 : (_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 : 2 : _res = _keyword;
32802 : 2 : goto done;
32803 : : }
32804 : 5 : 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 [ - + ]: 5 : if (p->error_indicator) {
32810 : 0 : p->level--;
32811 : 0 : return NULL;
32812 : : }
32813 : : D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
32814 : : Token * _literal;
32815 [ + + ]: 5 : if (
32816 : 5 : (_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 : 1 : _res = _literal;
32821 : 1 : goto done;
32822 : : }
32823 : 4 : 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 : 4 : _res = NULL;
32828 : 7 : done:
32829 : 7 : p->level--;
32830 : 7 : return _res;
32831 : : }
32832 : :
32833 : : // _tmp_149: '=' | ':='
32834 : : static void *
32835 : 11 : _tmp_149_rule(Parser *p)
32836 : : {
32837 [ - + ]: 11 : if (p->level++ == MAXSTACK) {
32838 : 0 : p->error_indicator = 1;
32839 : : PyErr_NoMemory();
32840 : : }
32841 [ - + ]: 11 : if (p->error_indicator) {
32842 : 0 : p->level--;
32843 : 0 : return NULL;
32844 : : }
32845 : 11 : void * _res = NULL;
32846 : 11 : int _mark = p->mark;
32847 : : { // '='
32848 [ - + ]: 11 : if (p->error_indicator) {
32849 : 0 : p->level--;
32850 : 0 : return NULL;
32851 : : }
32852 : : D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
32853 : : Token * _literal;
32854 [ + + ]: 11 : if (
32855 : 11 : (_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 : 3 : _res = _literal;
32860 : 3 : goto done;
32861 : : }
32862 : 8 : 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 [ - + ]: 8 : if (p->error_indicator) {
32868 : 0 : p->level--;
32869 : 0 : return NULL;
32870 : : }
32871 : : D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='"));
32872 : : Token * _literal;
32873 [ - + ]: 8 : if (
32874 : 8 : (_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 : 0 : _res = _literal;
32879 : 0 : goto done;
32880 : : }
32881 : 8 : 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 : 8 : _res = NULL;
32886 : 11 : done:
32887 : 11 : p->level--;
32888 : 11 : return _res;
32889 : : }
32890 : :
32891 : : // _tmp_150: list | tuple | genexp | 'True' | 'None' | 'False'
32892 : : static void *
32893 : 1239 : _tmp_150_rule(Parser *p)
32894 : : {
32895 [ - + ]: 1239 : if (p->level++ == MAXSTACK) {
32896 : 0 : p->error_indicator = 1;
32897 : : PyErr_NoMemory();
32898 : : }
32899 [ - + ]: 1239 : if (p->error_indicator) {
32900 : 0 : p->level--;
32901 : 0 : return NULL;
32902 : : }
32903 : 1239 : void * _res = NULL;
32904 : 1239 : int _mark = p->mark;
32905 : : { // list
32906 [ - + ]: 1239 : if (p->error_indicator) {
32907 : 0 : p->level--;
32908 : 0 : 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 [ + + ]: 1239 : if (
32913 : 1239 : (list_var = list_rule(p)) // list
32914 : : )
32915 : : {
32916 : : D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
32917 : 5 : _res = list_var;
32918 : 5 : goto done;
32919 : : }
32920 : 1234 : 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 [ - + ]: 1234 : if (p->error_indicator) {
32926 : 0 : p->level--;
32927 : 0 : 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 [ + + ]: 1234 : if (
32932 : 1234 : (tuple_var = tuple_rule(p)) // tuple
32933 : : )
32934 : : {
32935 : : D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
32936 : 17 : _res = tuple_var;
32937 : 17 : goto done;
32938 : : }
32939 : 1217 : 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 [ - + ]: 1217 : if (p->error_indicator) {
32945 : 0 : p->level--;
32946 : 0 : 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 [ + + ]: 1217 : if (
32951 : 1217 : (genexp_var = genexp_rule(p)) // genexp
32952 : : )
32953 : : {
32954 : : D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"));
32955 : 4 : _res = genexp_var;
32956 : 4 : goto done;
32957 : : }
32958 : 1213 : 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 [ - + ]: 1213 : if (p->error_indicator) {
32964 : 0 : p->level--;
32965 : 0 : return NULL;
32966 : : }
32967 : : D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
32968 : : Token * _keyword;
32969 [ + + ]: 1213 : if (
32970 : 1213 : (_keyword = _PyPegen_expect_token(p, 600)) // token='True'
32971 : : )
32972 : : {
32973 : : D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
32974 : 27 : _res = _keyword;
32975 : 27 : goto done;
32976 : : }
32977 : 1186 : 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 [ - + ]: 1186 : if (p->error_indicator) {
32983 : 0 : p->level--;
32984 : 0 : return NULL;
32985 : : }
32986 : : D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
32987 : : Token * _keyword;
32988 [ + + ]: 1186 : if (
32989 : 1186 : (_keyword = _PyPegen_expect_token(p, 601)) // token='None'
32990 : : )
32991 : : {
32992 : : D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
32993 : 12 : _res = _keyword;
32994 : 12 : goto done;
32995 : : }
32996 : 1174 : 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 [ - + ]: 1174 : if (p->error_indicator) {
33002 : 0 : p->level--;
33003 : 0 : return NULL;
33004 : : }
33005 : : D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
33006 : : Token * _keyword;
33007 [ + + ]: 1174 : if (
33008 : 1174 : (_keyword = _PyPegen_expect_token(p, 602)) // token='False'
33009 : : )
33010 : : {
33011 : : D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
33012 : 1 : _res = _keyword;
33013 : 1 : goto done;
33014 : : }
33015 : 1173 : 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 : 1173 : _res = NULL;
33020 : 1239 : done:
33021 : 1239 : p->level--;
33022 : 1239 : return _res;
33023 : : }
33024 : :
33025 : : // _tmp_151: '=' | ':='
33026 : : static void *
33027 : 34 : _tmp_151_rule(Parser *p)
33028 : : {
33029 [ - + ]: 34 : if (p->level++ == MAXSTACK) {
33030 : 0 : p->error_indicator = 1;
33031 : : PyErr_NoMemory();
33032 : : }
33033 [ - + ]: 34 : if (p->error_indicator) {
33034 : 0 : p->level--;
33035 : 0 : return NULL;
33036 : : }
33037 : 34 : void * _res = NULL;
33038 : 34 : int _mark = p->mark;
33039 : : { // '='
33040 [ - + ]: 34 : if (p->error_indicator) {
33041 : 0 : p->level--;
33042 : 0 : return NULL;
33043 : : }
33044 : : D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
33045 : : Token * _literal;
33046 [ + + ]: 34 : if (
33047 : 34 : (_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 : 3 : _res = _literal;
33052 : 3 : goto done;
33053 : : }
33054 : 31 : 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 [ - + ]: 31 : if (p->error_indicator) {
33060 : 0 : p->level--;
33061 : 0 : return NULL;
33062 : : }
33063 : : D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='"));
33064 : : Token * _literal;
33065 [ - + ]: 31 : if (
33066 : 31 : (_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 : 0 : _res = _literal;
33071 : 0 : goto done;
33072 : : }
33073 : 31 : 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 : 31 : _res = NULL;
33078 : 34 : done:
33079 : 34 : p->level--;
33080 : 34 : return _res;
33081 : : }
33082 : :
33083 : : // _loop0_152: star_named_expressions
33084 : : static asdl_seq *
33085 : 5 : _loop0_152_rule(Parser *p)
33086 : : {
33087 [ - + ]: 5 : if (p->level++ == MAXSTACK) {
33088 : 0 : p->error_indicator = 1;
33089 : : PyErr_NoMemory();
33090 : : }
33091 [ - + ]: 5 : if (p->error_indicator) {
33092 : 0 : p->level--;
33093 : 0 : return NULL;
33094 : : }
33095 : 5 : void *_res = NULL;
33096 : 5 : int _mark = p->mark;
33097 : 5 : int _start_mark = p->mark;
33098 : 5 : void **_children = PyMem_Malloc(sizeof(void *));
33099 [ - + ]: 5 : if (!_children) {
33100 : 0 : p->error_indicator = 1;
33101 : : PyErr_NoMemory();
33102 : 0 : p->level--;
33103 : 0 : return NULL;
33104 : : }
33105 : 5 : Py_ssize_t _children_capacity = 1;
33106 : 5 : Py_ssize_t _n = 0;
33107 : : { // star_named_expressions
33108 [ - + ]: 5 : if (p->error_indicator) {
33109 : 0 : p->level--;
33110 : 0 : 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 : 5 : while (
33115 [ + + ]: 8 : (star_named_expressions_var = star_named_expressions_rule(p)) // star_named_expressions
33116 : : )
33117 : : {
33118 : 3 : _res = star_named_expressions_var;
33119 [ - + ]: 3 : if (_n == _children_capacity) {
33120 : 0 : _children_capacity *= 2;
33121 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33122 [ # # ]: 0 : if (!_new_children) {
33123 : 0 : p->error_indicator = 1;
33124 : : PyErr_NoMemory();
33125 : 0 : p->level--;
33126 : 0 : return NULL;
33127 : : }
33128 : 0 : _children = _new_children;
33129 : : }
33130 : 3 : _children[_n++] = _res;
33131 : 3 : _mark = p->mark;
33132 : : }
33133 : 5 : 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 : 5 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33138 [ - + ]: 5 : if (!_seq) {
33139 : 0 : PyMem_Free(_children);
33140 : 0 : p->error_indicator = 1;
33141 : : PyErr_NoMemory();
33142 : 0 : p->level--;
33143 : 0 : return NULL;
33144 : : }
33145 [ + + ]: 8 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33146 : 5 : PyMem_Free(_children);
33147 : 5 : _PyPegen_insert_memo(p, _start_mark, _loop0_152_type, _seq);
33148 : 5 : p->level--;
33149 : 5 : return _seq;
33150 : : }
33151 : :
33152 : : // _loop0_153: (star_targets '=')
33153 : : static asdl_seq *
33154 : 796 : _loop0_153_rule(Parser *p)
33155 : : {
33156 [ - + ]: 796 : if (p->level++ == MAXSTACK) {
33157 : 0 : p->error_indicator = 1;
33158 : : PyErr_NoMemory();
33159 : : }
33160 [ - + ]: 796 : if (p->error_indicator) {
33161 : 0 : p->level--;
33162 : 0 : return NULL;
33163 : : }
33164 : 796 : void *_res = NULL;
33165 : 796 : int _mark = p->mark;
33166 : 796 : int _start_mark = p->mark;
33167 : 796 : void **_children = PyMem_Malloc(sizeof(void *));
33168 [ - + ]: 796 : if (!_children) {
33169 : 0 : p->error_indicator = 1;
33170 : : PyErr_NoMemory();
33171 : 0 : p->level--;
33172 : 0 : return NULL;
33173 : : }
33174 : 796 : Py_ssize_t _children_capacity = 1;
33175 : 796 : Py_ssize_t _n = 0;
33176 : : { // (star_targets '=')
33177 [ - + ]: 796 : if (p->error_indicator) {
33178 : 0 : p->level--;
33179 : 0 : 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 : 796 : while (
33184 [ + + ]: 803 : (_tmp_233_var = _tmp_233_rule(p)) // star_targets '='
33185 : : )
33186 : : {
33187 : 7 : _res = _tmp_233_var;
33188 [ + + ]: 7 : if (_n == _children_capacity) {
33189 : 3 : _children_capacity *= 2;
33190 : 3 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33191 [ - + ]: 3 : if (!_new_children) {
33192 : 0 : p->error_indicator = 1;
33193 : : PyErr_NoMemory();
33194 : 0 : p->level--;
33195 : 0 : return NULL;
33196 : : }
33197 : 3 : _children = _new_children;
33198 : : }
33199 : 7 : _children[_n++] = _res;
33200 : 7 : _mark = p->mark;
33201 : : }
33202 : 796 : 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 : 796 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33207 [ - + ]: 796 : if (!_seq) {
33208 : 0 : PyMem_Free(_children);
33209 : 0 : p->error_indicator = 1;
33210 : : PyErr_NoMemory();
33211 : 0 : p->level--;
33212 : 0 : return NULL;
33213 : : }
33214 [ + + ]: 803 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33215 : 796 : PyMem_Free(_children);
33216 : 796 : _PyPegen_insert_memo(p, _start_mark, _loop0_153_type, _seq);
33217 : 796 : p->level--;
33218 : 796 : return _seq;
33219 : : }
33220 : :
33221 : : // _loop0_154: (star_targets '=')
33222 : : static asdl_seq *
33223 : 774 : _loop0_154_rule(Parser *p)
33224 : : {
33225 [ - + ]: 774 : if (p->level++ == MAXSTACK) {
33226 : 0 : p->error_indicator = 1;
33227 : : PyErr_NoMemory();
33228 : : }
33229 [ - + ]: 774 : if (p->error_indicator) {
33230 : 0 : p->level--;
33231 : 0 : return NULL;
33232 : : }
33233 : 774 : void *_res = NULL;
33234 : 774 : int _mark = p->mark;
33235 : 774 : int _start_mark = p->mark;
33236 : 774 : void **_children = PyMem_Malloc(sizeof(void *));
33237 [ - + ]: 774 : if (!_children) {
33238 : 0 : p->error_indicator = 1;
33239 : : PyErr_NoMemory();
33240 : 0 : p->level--;
33241 : 0 : return NULL;
33242 : : }
33243 : 774 : Py_ssize_t _children_capacity = 1;
33244 : 774 : Py_ssize_t _n = 0;
33245 : : { // (star_targets '=')
33246 [ - + ]: 774 : if (p->error_indicator) {
33247 : 0 : p->level--;
33248 : 0 : 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 : 774 : while (
33253 [ + + ]: 779 : (_tmp_234_var = _tmp_234_rule(p)) // star_targets '='
33254 : : )
33255 : : {
33256 : 5 : _res = _tmp_234_var;
33257 [ + + ]: 5 : if (_n == _children_capacity) {
33258 : 2 : _children_capacity *= 2;
33259 : 2 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33260 [ - + ]: 2 : if (!_new_children) {
33261 : 0 : p->error_indicator = 1;
33262 : : PyErr_NoMemory();
33263 : 0 : p->level--;
33264 : 0 : return NULL;
33265 : : }
33266 : 2 : _children = _new_children;
33267 : : }
33268 : 5 : _children[_n++] = _res;
33269 : 5 : _mark = p->mark;
33270 : : }
33271 : 774 : 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 : 774 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33276 [ - + ]: 774 : if (!_seq) {
33277 : 0 : PyMem_Free(_children);
33278 : 0 : p->error_indicator = 1;
33279 : : PyErr_NoMemory();
33280 : 0 : p->level--;
33281 : 0 : return NULL;
33282 : : }
33283 [ + + ]: 779 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33284 : 774 : PyMem_Free(_children);
33285 : 774 : _PyPegen_insert_memo(p, _start_mark, _loop0_154_type, _seq);
33286 : 774 : p->level--;
33287 : 774 : return _seq;
33288 : : }
33289 : :
33290 : : // _tmp_155: yield_expr | star_expressions
33291 : : static void *
33292 : 14 : _tmp_155_rule(Parser *p)
33293 : : {
33294 [ - + ]: 14 : if (p->level++ == MAXSTACK) {
33295 : 0 : p->error_indicator = 1;
33296 : : PyErr_NoMemory();
33297 : : }
33298 [ - + ]: 14 : if (p->error_indicator) {
33299 : 0 : p->level--;
33300 : 0 : return NULL;
33301 : : }
33302 : 14 : void * _res = NULL;
33303 : 14 : int _mark = p->mark;
33304 : : { // yield_expr
33305 [ - + ]: 14 : if (p->error_indicator) {
33306 : 0 : p->level--;
33307 : 0 : 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 [ - + ]: 14 : if (
33312 : 14 : (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 : 0 : _res = yield_expr_var;
33317 : 0 : goto done;
33318 : : }
33319 : 14 : 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 [ - + ]: 14 : if (p->error_indicator) {
33325 : 0 : p->level--;
33326 : 0 : 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 [ + - ]: 14 : if (
33331 : 14 : (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 : 14 : _res = star_expressions_var;
33336 : 14 : goto done;
33337 : : }
33338 : 0 : 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 : 0 : _res = NULL;
33343 : 14 : done:
33344 : 14 : p->level--;
33345 : 14 : return _res;
33346 : : }
33347 : :
33348 : : // _tmp_156: '[' | '(' | '{'
33349 : : static void *
33350 : 2906 : _tmp_156_rule(Parser *p)
33351 : : {
33352 [ - + ]: 2906 : if (p->level++ == MAXSTACK) {
33353 : 0 : p->error_indicator = 1;
33354 : : PyErr_NoMemory();
33355 : : }
33356 [ - + ]: 2906 : if (p->error_indicator) {
33357 : 0 : p->level--;
33358 : 0 : return NULL;
33359 : : }
33360 : 2906 : void * _res = NULL;
33361 : 2906 : int _mark = p->mark;
33362 : : { // '['
33363 [ - + ]: 2906 : if (p->error_indicator) {
33364 : 0 : p->level--;
33365 : 0 : return NULL;
33366 : : }
33367 : : D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
33368 : : Token * _literal;
33369 [ + + ]: 2906 : if (
33370 : 2906 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
33371 : : )
33372 : : {
33373 : : D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
33374 : 71 : _res = _literal;
33375 : 71 : goto done;
33376 : : }
33377 : 2835 : 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 [ - + ]: 2835 : if (p->error_indicator) {
33383 : 0 : p->level--;
33384 : 0 : return NULL;
33385 : : }
33386 : : D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
33387 : : Token * _literal;
33388 [ + + ]: 2835 : if (
33389 : 2835 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
33390 : : )
33391 : : {
33392 : : D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
33393 : 272 : _res = _literal;
33394 : 272 : goto done;
33395 : : }
33396 : 2563 : 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 [ - + ]: 2563 : if (p->error_indicator) {
33402 : 0 : p->level--;
33403 : 0 : return NULL;
33404 : : }
33405 : : D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));
33406 : : Token * _literal;
33407 [ + + ]: 2563 : if (
33408 : 2563 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
33409 : : )
33410 : : {
33411 : : D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));
33412 : 79 : _res = _literal;
33413 : 79 : goto done;
33414 : : }
33415 : 2484 : 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 : 2484 : _res = NULL;
33420 : 2906 : done:
33421 : 2906 : p->level--;
33422 : 2906 : return _res;
33423 : : }
33424 : :
33425 : : // _tmp_157: '[' | '{'
33426 : : static void *
33427 : 2900 : _tmp_157_rule(Parser *p)
33428 : : {
33429 [ - + ]: 2900 : if (p->level++ == MAXSTACK) {
33430 : 0 : p->error_indicator = 1;
33431 : : PyErr_NoMemory();
33432 : : }
33433 [ - + ]: 2900 : if (p->error_indicator) {
33434 : 0 : p->level--;
33435 : 0 : return NULL;
33436 : : }
33437 : 2900 : void * _res = NULL;
33438 : 2900 : int _mark = p->mark;
33439 : : { // '['
33440 [ - + ]: 2900 : if (p->error_indicator) {
33441 : 0 : p->level--;
33442 : 0 : return NULL;
33443 : : }
33444 : : D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
33445 : : Token * _literal;
33446 [ + + ]: 2900 : if (
33447 : 2900 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
33448 : : )
33449 : : {
33450 : : D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
33451 : 66 : _res = _literal;
33452 : 66 : goto done;
33453 : : }
33454 : 2834 : 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 [ - + ]: 2834 : if (p->error_indicator) {
33460 : 0 : p->level--;
33461 : 0 : return NULL;
33462 : : }
33463 : : D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));
33464 : : Token * _literal;
33465 [ + + ]: 2834 : if (
33466 : 2834 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
33467 : : )
33468 : : {
33469 : : D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));
33470 : 79 : _res = _literal;
33471 : 79 : goto done;
33472 : : }
33473 : 2755 : 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 : 2755 : _res = NULL;
33478 : 2900 : done:
33479 : 2900 : p->level--;
33480 : 2900 : return _res;
33481 : : }
33482 : :
33483 : : // _tmp_158: '[' | '{'
33484 : : static void *
33485 : 2896 : _tmp_158_rule(Parser *p)
33486 : : {
33487 [ - + ]: 2896 : if (p->level++ == MAXSTACK) {
33488 : 0 : p->error_indicator = 1;
33489 : : PyErr_NoMemory();
33490 : : }
33491 [ - + ]: 2896 : if (p->error_indicator) {
33492 : 0 : p->level--;
33493 : 0 : return NULL;
33494 : : }
33495 : 2896 : void * _res = NULL;
33496 : 2896 : int _mark = p->mark;
33497 : : { // '['
33498 [ - + ]: 2896 : if (p->error_indicator) {
33499 : 0 : p->level--;
33500 : 0 : return NULL;
33501 : : }
33502 : : D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
33503 : : Token * _literal;
33504 [ + + ]: 2896 : if (
33505 : 2896 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
33506 : : )
33507 : : {
33508 : : D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
33509 : 63 : _res = _literal;
33510 : 63 : goto done;
33511 : : }
33512 : 2833 : 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 [ - + ]: 2833 : if (p->error_indicator) {
33518 : 0 : p->level--;
33519 : 0 : return NULL;
33520 : : }
33521 : : D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));
33522 : : Token * _literal;
33523 [ + + ]: 2833 : if (
33524 : 2833 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
33525 : : )
33526 : : {
33527 : : D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));
33528 : 78 : _res = _literal;
33529 : 78 : goto done;
33530 : : }
33531 : 2755 : 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 : 2755 : _res = NULL;
33536 : 2896 : done:
33537 : 2896 : p->level--;
33538 : 2896 : return _res;
33539 : : }
33540 : :
33541 : : // _loop0_159: param_no_default
33542 : : static asdl_seq *
33543 : 302 : _loop0_159_rule(Parser *p)
33544 : : {
33545 [ - + ]: 302 : if (p->level++ == MAXSTACK) {
33546 : 0 : p->error_indicator = 1;
33547 : : PyErr_NoMemory();
33548 : : }
33549 [ - + ]: 302 : if (p->error_indicator) {
33550 : 0 : p->level--;
33551 : 0 : return NULL;
33552 : : }
33553 : 302 : void *_res = NULL;
33554 : 302 : int _mark = p->mark;
33555 : 302 : int _start_mark = p->mark;
33556 : 302 : void **_children = PyMem_Malloc(sizeof(void *));
33557 [ - + ]: 302 : if (!_children) {
33558 : 0 : p->error_indicator = 1;
33559 : : PyErr_NoMemory();
33560 : 0 : p->level--;
33561 : 0 : return NULL;
33562 : : }
33563 : 302 : Py_ssize_t _children_capacity = 1;
33564 : 302 : Py_ssize_t _n = 0;
33565 : : { // param_no_default
33566 [ - + ]: 302 : if (p->error_indicator) {
33567 : 0 : p->level--;
33568 : 0 : 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 : 302 : while (
33573 [ + + ]: 367 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
33574 : : )
33575 : : {
33576 : 65 : _res = param_no_default_var;
33577 [ + + ]: 65 : if (_n == _children_capacity) {
33578 : 6 : _children_capacity *= 2;
33579 : 6 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33580 [ - + ]: 6 : if (!_new_children) {
33581 : 0 : p->error_indicator = 1;
33582 : : PyErr_NoMemory();
33583 : 0 : p->level--;
33584 : 0 : return NULL;
33585 : : }
33586 : 6 : _children = _new_children;
33587 : : }
33588 : 65 : _children[_n++] = _res;
33589 : 65 : _mark = p->mark;
33590 : : }
33591 : 302 : 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 : 302 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33596 [ - + ]: 302 : if (!_seq) {
33597 : 0 : PyMem_Free(_children);
33598 : 0 : p->error_indicator = 1;
33599 : : PyErr_NoMemory();
33600 : 0 : p->level--;
33601 : 0 : return NULL;
33602 : : }
33603 [ + + ]: 367 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33604 : 302 : PyMem_Free(_children);
33605 : 302 : _PyPegen_insert_memo(p, _start_mark, _loop0_159_type, _seq);
33606 : 302 : p->level--;
33607 : 302 : return _seq;
33608 : : }
33609 : :
33610 : : // _loop0_160: param_no_default
33611 : : static asdl_seq *
33612 : 284 : _loop0_160_rule(Parser *p)
33613 : : {
33614 [ - + ]: 284 : if (p->level++ == MAXSTACK) {
33615 : 0 : p->error_indicator = 1;
33616 : : PyErr_NoMemory();
33617 : : }
33618 [ - + ]: 284 : if (p->error_indicator) {
33619 : 0 : p->level--;
33620 : 0 : return NULL;
33621 : : }
33622 : 284 : void *_res = NULL;
33623 : 284 : int _mark = p->mark;
33624 : 284 : int _start_mark = p->mark;
33625 : 284 : void **_children = PyMem_Malloc(sizeof(void *));
33626 [ - + ]: 284 : if (!_children) {
33627 : 0 : p->error_indicator = 1;
33628 : : PyErr_NoMemory();
33629 : 0 : p->level--;
33630 : 0 : return NULL;
33631 : : }
33632 : 284 : Py_ssize_t _children_capacity = 1;
33633 : 284 : Py_ssize_t _n = 0;
33634 : : { // param_no_default
33635 [ - + ]: 284 : if (p->error_indicator) {
33636 : 0 : p->level--;
33637 : 0 : 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 : 284 : while (
33642 [ + + ]: 344 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
33643 : : )
33644 : : {
33645 : 60 : _res = param_no_default_var;
33646 [ + + ]: 60 : if (_n == _children_capacity) {
33647 : 6 : _children_capacity *= 2;
33648 : 6 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33649 [ - + ]: 6 : if (!_new_children) {
33650 : 0 : p->error_indicator = 1;
33651 : : PyErr_NoMemory();
33652 : 0 : p->level--;
33653 : 0 : return NULL;
33654 : : }
33655 : 6 : _children = _new_children;
33656 : : }
33657 : 60 : _children[_n++] = _res;
33658 : 60 : _mark = p->mark;
33659 : : }
33660 : 284 : 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 : 284 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33665 [ - + ]: 284 : if (!_seq) {
33666 : 0 : PyMem_Free(_children);
33667 : 0 : p->error_indicator = 1;
33668 : : PyErr_NoMemory();
33669 : 0 : p->level--;
33670 : 0 : return NULL;
33671 : : }
33672 [ + + ]: 344 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33673 : 284 : PyMem_Free(_children);
33674 : 284 : _PyPegen_insert_memo(p, _start_mark, _loop0_160_type, _seq);
33675 : 284 : p->level--;
33676 : 284 : return _seq;
33677 : : }
33678 : :
33679 : : // _loop1_161: param_no_default
33680 : : static asdl_seq *
33681 : 4 : _loop1_161_rule(Parser *p)
33682 : : {
33683 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
33684 : 0 : p->error_indicator = 1;
33685 : : PyErr_NoMemory();
33686 : : }
33687 [ - + ]: 4 : if (p->error_indicator) {
33688 : 0 : p->level--;
33689 : 0 : return NULL;
33690 : : }
33691 : 4 : void *_res = NULL;
33692 : 4 : int _mark = p->mark;
33693 : 4 : int _start_mark = p->mark;
33694 : 4 : void **_children = PyMem_Malloc(sizeof(void *));
33695 [ - + ]: 4 : if (!_children) {
33696 : 0 : p->error_indicator = 1;
33697 : : PyErr_NoMemory();
33698 : 0 : p->level--;
33699 : 0 : return NULL;
33700 : : }
33701 : 4 : Py_ssize_t _children_capacity = 1;
33702 : 4 : Py_ssize_t _n = 0;
33703 : : { // param_no_default
33704 [ - + ]: 4 : if (p->error_indicator) {
33705 : 0 : p->level--;
33706 : 0 : 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 : 4 : while (
33711 [ + + ]: 16 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
33712 : : )
33713 : : {
33714 : 12 : _res = param_no_default_var;
33715 [ + + ]: 12 : if (_n == _children_capacity) {
33716 : 7 : _children_capacity *= 2;
33717 : 7 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33718 [ - + ]: 7 : if (!_new_children) {
33719 : 0 : p->error_indicator = 1;
33720 : : PyErr_NoMemory();
33721 : 0 : p->level--;
33722 : 0 : return NULL;
33723 : : }
33724 : 7 : _children = _new_children;
33725 : : }
33726 : 12 : _children[_n++] = _res;
33727 : 12 : _mark = p->mark;
33728 : : }
33729 : 4 : 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 [ + - - + ]: 4 : if (_n == 0 || p->error_indicator) {
33734 : 0 : PyMem_Free(_children);
33735 : 0 : p->level--;
33736 : 0 : return NULL;
33737 : : }
33738 : 4 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33739 [ - + ]: 4 : if (!_seq) {
33740 : 0 : PyMem_Free(_children);
33741 : 0 : p->error_indicator = 1;
33742 : : PyErr_NoMemory();
33743 : 0 : p->level--;
33744 : 0 : return NULL;
33745 : : }
33746 [ + + ]: 16 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33747 : 4 : PyMem_Free(_children);
33748 : 4 : _PyPegen_insert_memo(p, _start_mark, _loop1_161_type, _seq);
33749 : 4 : p->level--;
33750 : 4 : return _seq;
33751 : : }
33752 : :
33753 : : // _tmp_162: slash_no_default | slash_with_default
33754 : : static void *
33755 : 275 : _tmp_162_rule(Parser *p)
33756 : : {
33757 [ - + ]: 275 : if (p->level++ == MAXSTACK) {
33758 : 0 : p->error_indicator = 1;
33759 : : PyErr_NoMemory();
33760 : : }
33761 [ - + ]: 275 : if (p->error_indicator) {
33762 : 0 : p->level--;
33763 : 0 : return NULL;
33764 : : }
33765 : 275 : void * _res = NULL;
33766 : 275 : int _mark = p->mark;
33767 : : { // slash_no_default
33768 [ - + ]: 275 : if (p->error_indicator) {
33769 : 0 : p->level--;
33770 : 0 : 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 [ + + ]: 275 : if (
33775 : 275 : (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default
33776 : : )
33777 : : {
33778 : : D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default"));
33779 : 12 : _res = slash_no_default_var;
33780 : 12 : goto done;
33781 : : }
33782 : 263 : 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 [ - + ]: 263 : if (p->error_indicator) {
33788 : 0 : p->level--;
33789 : 0 : 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 [ + + ]: 263 : if (
33794 : 263 : (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default
33795 : : )
33796 : : {
33797 : : D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
33798 : 2 : _res = slash_with_default_var;
33799 : 2 : goto done;
33800 : : }
33801 : 261 : 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 : 261 : _res = NULL;
33806 : 275 : done:
33807 : 275 : p->level--;
33808 : 275 : return _res;
33809 : : }
33810 : :
33811 : : // _loop0_163: param_maybe_default
33812 : : static asdl_seq *
33813 : 14 : _loop0_163_rule(Parser *p)
33814 : : {
33815 [ - + ]: 14 : if (p->level++ == MAXSTACK) {
33816 : 0 : p->error_indicator = 1;
33817 : : PyErr_NoMemory();
33818 : : }
33819 [ - + ]: 14 : if (p->error_indicator) {
33820 : 0 : p->level--;
33821 : 0 : return NULL;
33822 : : }
33823 : 14 : void *_res = NULL;
33824 : 14 : int _mark = p->mark;
33825 : 14 : int _start_mark = p->mark;
33826 : 14 : void **_children = PyMem_Malloc(sizeof(void *));
33827 [ - + ]: 14 : if (!_children) {
33828 : 0 : p->error_indicator = 1;
33829 : : PyErr_NoMemory();
33830 : 0 : p->level--;
33831 : 0 : return NULL;
33832 : : }
33833 : 14 : Py_ssize_t _children_capacity = 1;
33834 : 14 : Py_ssize_t _n = 0;
33835 : : { // param_maybe_default
33836 [ - + ]: 14 : if (p->error_indicator) {
33837 : 0 : p->level--;
33838 : 0 : 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 : 14 : while (
33843 [ + + ]: 25 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
33844 : : )
33845 : : {
33846 : 11 : _res = param_maybe_default_var;
33847 [ - + ]: 11 : if (_n == _children_capacity) {
33848 : 0 : _children_capacity *= 2;
33849 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33850 [ # # ]: 0 : if (!_new_children) {
33851 : 0 : p->error_indicator = 1;
33852 : : PyErr_NoMemory();
33853 : 0 : p->level--;
33854 : 0 : return NULL;
33855 : : }
33856 : 0 : _children = _new_children;
33857 : : }
33858 : 11 : _children[_n++] = _res;
33859 : 11 : _mark = p->mark;
33860 : : }
33861 : 14 : 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 : 14 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33866 [ - + ]: 14 : if (!_seq) {
33867 : 0 : PyMem_Free(_children);
33868 : 0 : p->error_indicator = 1;
33869 : : PyErr_NoMemory();
33870 : 0 : p->level--;
33871 : 0 : return NULL;
33872 : : }
33873 [ + + ]: 25 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33874 : 14 : PyMem_Free(_children);
33875 : 14 : _PyPegen_insert_memo(p, _start_mark, _loop0_163_type, _seq);
33876 : 14 : p->level--;
33877 : 14 : return _seq;
33878 : : }
33879 : :
33880 : : // _tmp_164: slash_no_default | slash_with_default
33881 : : static void *
33882 : 265 : _tmp_164_rule(Parser *p)
33883 : : {
33884 [ - + ]: 265 : if (p->level++ == MAXSTACK) {
33885 : 0 : p->error_indicator = 1;
33886 : : PyErr_NoMemory();
33887 : : }
33888 [ - + ]: 265 : if (p->error_indicator) {
33889 : 0 : p->level--;
33890 : 0 : return NULL;
33891 : : }
33892 : 265 : void * _res = NULL;
33893 : 265 : int _mark = p->mark;
33894 : : { // slash_no_default
33895 [ - + ]: 265 : if (p->error_indicator) {
33896 : 0 : p->level--;
33897 : 0 : 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 [ + + ]: 265 : if (
33902 : 265 : (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default
33903 : : )
33904 : : {
33905 : : D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default"));
33906 : 3 : _res = slash_no_default_var;
33907 : 3 : goto done;
33908 : : }
33909 : 262 : 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 [ - + ]: 262 : if (p->error_indicator) {
33915 : 0 : p->level--;
33916 : 0 : 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 [ + + ]: 262 : if (
33921 : 262 : (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default
33922 : : )
33923 : : {
33924 : : D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
33925 : 1 : _res = slash_with_default_var;
33926 : 1 : goto done;
33927 : : }
33928 : 261 : 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 : 261 : _res = NULL;
33933 : 265 : done:
33934 : 265 : p->level--;
33935 : 265 : return _res;
33936 : : }
33937 : :
33938 : : // _loop0_165: param_maybe_default
33939 : : static asdl_seq *
33940 : 265 : _loop0_165_rule(Parser *p)
33941 : : {
33942 [ - + ]: 265 : if (p->level++ == MAXSTACK) {
33943 : 0 : p->error_indicator = 1;
33944 : : PyErr_NoMemory();
33945 : : }
33946 [ - + ]: 265 : if (p->error_indicator) {
33947 : 0 : p->level--;
33948 : 0 : return NULL;
33949 : : }
33950 : 265 : void *_res = NULL;
33951 : 265 : int _mark = p->mark;
33952 : 265 : int _start_mark = p->mark;
33953 : 265 : void **_children = PyMem_Malloc(sizeof(void *));
33954 [ - + ]: 265 : if (!_children) {
33955 : 0 : p->error_indicator = 1;
33956 : : PyErr_NoMemory();
33957 : 0 : p->level--;
33958 : 0 : return NULL;
33959 : : }
33960 : 265 : Py_ssize_t _children_capacity = 1;
33961 : 265 : Py_ssize_t _n = 0;
33962 : : { // param_maybe_default
33963 [ - + ]: 265 : if (p->error_indicator) {
33964 : 0 : p->level--;
33965 : 0 : 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 : 265 : while (
33970 [ + + ]: 314 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
33971 : : )
33972 : : {
33973 : 49 : _res = param_maybe_default_var;
33974 [ + + ]: 49 : if (_n == _children_capacity) {
33975 : 4 : _children_capacity *= 2;
33976 : 4 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33977 [ - + ]: 4 : if (!_new_children) {
33978 : 0 : p->error_indicator = 1;
33979 : : PyErr_NoMemory();
33980 : 0 : p->level--;
33981 : 0 : return NULL;
33982 : : }
33983 : 4 : _children = _new_children;
33984 : : }
33985 : 49 : _children[_n++] = _res;
33986 : 49 : _mark = p->mark;
33987 : : }
33988 : 265 : 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 : 265 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33993 [ - + ]: 265 : if (!_seq) {
33994 : 0 : PyMem_Free(_children);
33995 : 0 : p->error_indicator = 1;
33996 : : PyErr_NoMemory();
33997 : 0 : p->level--;
33998 : 0 : return NULL;
33999 : : }
34000 [ + + ]: 314 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34001 : 265 : PyMem_Free(_children);
34002 : 265 : _PyPegen_insert_memo(p, _start_mark, _loop0_165_type, _seq);
34003 : 265 : p->level--;
34004 : 265 : return _seq;
34005 : : }
34006 : :
34007 : : // _tmp_166: ',' | param_no_default
34008 : : static void *
34009 : 41 : _tmp_166_rule(Parser *p)
34010 : : {
34011 [ - + ]: 41 : if (p->level++ == MAXSTACK) {
34012 : 0 : p->error_indicator = 1;
34013 : : PyErr_NoMemory();
34014 : : }
34015 [ - + ]: 41 : if (p->error_indicator) {
34016 : 0 : p->level--;
34017 : 0 : return NULL;
34018 : : }
34019 : 41 : void * _res = NULL;
34020 : 41 : int _mark = p->mark;
34021 : : { // ','
34022 [ - + ]: 41 : if (p->error_indicator) {
34023 : 0 : p->level--;
34024 : 0 : return NULL;
34025 : : }
34026 : : D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
34027 : : Token * _literal;
34028 [ + + ]: 41 : if (
34029 : 41 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
34030 : : )
34031 : : {
34032 : : D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
34033 : 15 : _res = _literal;
34034 : 15 : goto done;
34035 : : }
34036 : 26 : 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 [ - + ]: 26 : if (p->error_indicator) {
34042 : 0 : p->level--;
34043 : 0 : 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 [ + + ]: 26 : if (
34048 : 26 : (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 : 18 : _res = param_no_default_var;
34053 : 18 : goto done;
34054 : : }
34055 : 8 : 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 : 8 : _res = NULL;
34060 : 41 : done:
34061 : 41 : p->level--;
34062 : 41 : return _res;
34063 : : }
34064 : :
34065 : : // _loop0_167: param_maybe_default
34066 : : static asdl_seq *
34067 : 33 : _loop0_167_rule(Parser *p)
34068 : : {
34069 [ - + ]: 33 : if (p->level++ == MAXSTACK) {
34070 : 0 : p->error_indicator = 1;
34071 : : PyErr_NoMemory();
34072 : : }
34073 [ - + ]: 33 : if (p->error_indicator) {
34074 : 0 : p->level--;
34075 : 0 : return NULL;
34076 : : }
34077 : 33 : void *_res = NULL;
34078 : 33 : int _mark = p->mark;
34079 : 33 : int _start_mark = p->mark;
34080 : 33 : void **_children = PyMem_Malloc(sizeof(void *));
34081 [ - + ]: 33 : if (!_children) {
34082 : 0 : p->error_indicator = 1;
34083 : : PyErr_NoMemory();
34084 : 0 : p->level--;
34085 : 0 : return NULL;
34086 : : }
34087 : 33 : Py_ssize_t _children_capacity = 1;
34088 : 33 : Py_ssize_t _n = 0;
34089 : : { // param_maybe_default
34090 [ - + ]: 33 : if (p->error_indicator) {
34091 : 0 : p->level--;
34092 : 0 : 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 : 33 : while (
34097 [ + + ]: 49 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
34098 : : )
34099 : : {
34100 : 16 : _res = param_maybe_default_var;
34101 [ - + ]: 16 : if (_n == _children_capacity) {
34102 : 0 : _children_capacity *= 2;
34103 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34104 [ # # ]: 0 : if (!_new_children) {
34105 : 0 : p->error_indicator = 1;
34106 : : PyErr_NoMemory();
34107 : 0 : p->level--;
34108 : 0 : return NULL;
34109 : : }
34110 : 0 : _children = _new_children;
34111 : : }
34112 : 16 : _children[_n++] = _res;
34113 : 16 : _mark = p->mark;
34114 : : }
34115 : 33 : 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 : 33 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34120 [ - + ]: 33 : if (!_seq) {
34121 : 0 : PyMem_Free(_children);
34122 : 0 : p->error_indicator = 1;
34123 : : PyErr_NoMemory();
34124 : 0 : p->level--;
34125 : 0 : return NULL;
34126 : : }
34127 [ + + ]: 49 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34128 : 33 : PyMem_Free(_children);
34129 : 33 : _PyPegen_insert_memo(p, _start_mark, _loop0_167_type, _seq);
34130 : 33 : p->level--;
34131 : 33 : return _seq;
34132 : : }
34133 : :
34134 : : // _loop1_168: param_maybe_default
34135 : : static asdl_seq *
34136 : 253 : _loop1_168_rule(Parser *p)
34137 : : {
34138 [ - + ]: 253 : if (p->level++ == MAXSTACK) {
34139 : 0 : p->error_indicator = 1;
34140 : : PyErr_NoMemory();
34141 : : }
34142 [ - + ]: 253 : if (p->error_indicator) {
34143 : 0 : p->level--;
34144 : 0 : return NULL;
34145 : : }
34146 : 253 : void *_res = NULL;
34147 : 253 : int _mark = p->mark;
34148 : 253 : int _start_mark = p->mark;
34149 : 253 : void **_children = PyMem_Malloc(sizeof(void *));
34150 [ - + ]: 253 : if (!_children) {
34151 : 0 : p->error_indicator = 1;
34152 : : PyErr_NoMemory();
34153 : 0 : p->level--;
34154 : 0 : return NULL;
34155 : : }
34156 : 253 : Py_ssize_t _children_capacity = 1;
34157 : 253 : Py_ssize_t _n = 0;
34158 : : { // param_maybe_default
34159 [ - + ]: 253 : if (p->error_indicator) {
34160 : 0 : p->level--;
34161 : 0 : 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 : 253 : while (
34166 [ + + ]: 301 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
34167 : : )
34168 : : {
34169 : 48 : _res = param_maybe_default_var;
34170 [ + + ]: 48 : if (_n == _children_capacity) {
34171 : 6 : _children_capacity *= 2;
34172 : 6 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34173 [ - + ]: 6 : if (!_new_children) {
34174 : 0 : p->error_indicator = 1;
34175 : : PyErr_NoMemory();
34176 : 0 : p->level--;
34177 : 0 : return NULL;
34178 : : }
34179 : 6 : _children = _new_children;
34180 : : }
34181 : 48 : _children[_n++] = _res;
34182 : 48 : _mark = p->mark;
34183 : : }
34184 : 253 : 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 [ + + - + ]: 253 : if (_n == 0 || p->error_indicator) {
34189 : 211 : PyMem_Free(_children);
34190 : 211 : p->level--;
34191 : 211 : return NULL;
34192 : : }
34193 : 42 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34194 [ - + ]: 42 : if (!_seq) {
34195 : 0 : PyMem_Free(_children);
34196 : 0 : p->error_indicator = 1;
34197 : : PyErr_NoMemory();
34198 : 0 : p->level--;
34199 : 0 : return NULL;
34200 : : }
34201 [ + + ]: 90 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34202 : 42 : PyMem_Free(_children);
34203 : 42 : _PyPegen_insert_memo(p, _start_mark, _loop1_168_type, _seq);
34204 : 42 : p->level--;
34205 : 42 : return _seq;
34206 : : }
34207 : :
34208 : : // _tmp_169: ')' | ','
34209 : : static void *
34210 : 245 : _tmp_169_rule(Parser *p)
34211 : : {
34212 [ - + ]: 245 : if (p->level++ == MAXSTACK) {
34213 : 0 : p->error_indicator = 1;
34214 : : PyErr_NoMemory();
34215 : : }
34216 [ - + ]: 245 : if (p->error_indicator) {
34217 : 0 : p->level--;
34218 : 0 : return NULL;
34219 : : }
34220 : 245 : void * _res = NULL;
34221 : 245 : int _mark = p->mark;
34222 : : { // ')'
34223 [ - + ]: 245 : if (p->error_indicator) {
34224 : 0 : p->level--;
34225 : 0 : return NULL;
34226 : : }
34227 : : D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
34228 : : Token * _literal;
34229 [ - + ]: 245 : if (
34230 : 245 : (_literal = _PyPegen_expect_token(p, 8)) // token=')'
34231 : : )
34232 : : {
34233 : : D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
34234 : 0 : _res = _literal;
34235 : 0 : goto done;
34236 : : }
34237 : 245 : 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 [ - + ]: 245 : if (p->error_indicator) {
34243 : 0 : p->level--;
34244 : 0 : return NULL;
34245 : : }
34246 : : D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
34247 : : Token * _literal;
34248 [ + + ]: 245 : if (
34249 : 245 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
34250 : : )
34251 : : {
34252 : : D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
34253 : 5 : _res = _literal;
34254 : 5 : goto done;
34255 : : }
34256 : 240 : 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 : 240 : _res = NULL;
34261 : 245 : done:
34262 : 245 : p->level--;
34263 : 245 : return _res;
34264 : : }
34265 : :
34266 : : // _tmp_170: ')' | ',' (')' | '**')
34267 : : static void *
34268 : 29 : _tmp_170_rule(Parser *p)
34269 : : {
34270 [ - + ]: 29 : if (p->level++ == MAXSTACK) {
34271 : 0 : p->error_indicator = 1;
34272 : : PyErr_NoMemory();
34273 : : }
34274 [ - + ]: 29 : if (p->error_indicator) {
34275 : 0 : p->level--;
34276 : 0 : return NULL;
34277 : : }
34278 : 29 : void * _res = NULL;
34279 : 29 : int _mark = p->mark;
34280 : : { // ')'
34281 [ - + ]: 29 : if (p->error_indicator) {
34282 : 0 : p->level--;
34283 : 0 : return NULL;
34284 : : }
34285 : : D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
34286 : : Token * _literal;
34287 [ + + ]: 29 : if (
34288 : 29 : (_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 : 2 : _res = _literal;
34293 : 2 : goto done;
34294 : : }
34295 : 27 : 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 [ - + ]: 27 : if (p->error_indicator) {
34301 : 0 : p->level--;
34302 : 0 : 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 [ + + ]: 27 : if (
34308 : 27 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
34309 [ + + ]: 9 : &&
34310 : 9 : (_tmp_235_var = _tmp_235_rule(p)) // ')' | '**'
34311 : : )
34312 : : {
34313 : : D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')"));
34314 : 1 : _res = _PyPegen_dummy_name(p, _literal, _tmp_235_var);
34315 : 1 : goto done;
34316 : : }
34317 : 26 : 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 : 26 : _res = NULL;
34322 : 29 : done:
34323 : 29 : p->level--;
34324 : 29 : return _res;
34325 : : }
34326 : :
34327 : : // _tmp_171: param_no_default | ','
34328 : : static void *
34329 : 23 : _tmp_171_rule(Parser *p)
34330 : : {
34331 [ - + ]: 23 : if (p->level++ == MAXSTACK) {
34332 : 0 : p->error_indicator = 1;
34333 : : PyErr_NoMemory();
34334 : : }
34335 [ - + ]: 23 : if (p->error_indicator) {
34336 : 0 : p->level--;
34337 : 0 : return NULL;
34338 : : }
34339 : 23 : void * _res = NULL;
34340 : 23 : int _mark = p->mark;
34341 : : { // param_no_default
34342 [ - + ]: 23 : if (p->error_indicator) {
34343 : 0 : p->level--;
34344 : 0 : 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 [ + + ]: 23 : if (
34349 : 23 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
34350 : : )
34351 : : {
34352 : : D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default"));
34353 : 12 : _res = param_no_default_var;
34354 : 12 : goto done;
34355 : : }
34356 : 11 : 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 [ - + ]: 11 : if (p->error_indicator) {
34362 : 0 : p->level--;
34363 : 0 : return NULL;
34364 : : }
34365 : : D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
34366 : : Token * _literal;
34367 [ + + ]: 11 : if (
34368 : 11 : (_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 : 7 : _res = _literal;
34373 : 7 : goto done;
34374 : : }
34375 : 4 : 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 : 4 : _res = NULL;
34380 : 23 : done:
34381 : 23 : p->level--;
34382 : 23 : return _res;
34383 : : }
34384 : :
34385 : : // _loop0_172: param_maybe_default
34386 : : static asdl_seq *
34387 : 19 : _loop0_172_rule(Parser *p)
34388 : : {
34389 [ - + ]: 19 : if (p->level++ == MAXSTACK) {
34390 : 0 : p->error_indicator = 1;
34391 : : PyErr_NoMemory();
34392 : : }
34393 [ - + ]: 19 : if (p->error_indicator) {
34394 : 0 : p->level--;
34395 : 0 : return NULL;
34396 : : }
34397 : 19 : void *_res = NULL;
34398 : 19 : int _mark = p->mark;
34399 : 19 : int _start_mark = p->mark;
34400 : 19 : void **_children = PyMem_Malloc(sizeof(void *));
34401 [ - + ]: 19 : if (!_children) {
34402 : 0 : p->error_indicator = 1;
34403 : : PyErr_NoMemory();
34404 : 0 : p->level--;
34405 : 0 : return NULL;
34406 : : }
34407 : 19 : Py_ssize_t _children_capacity = 1;
34408 : 19 : Py_ssize_t _n = 0;
34409 : : { // param_maybe_default
34410 [ - + ]: 19 : if (p->error_indicator) {
34411 : 0 : p->level--;
34412 : 0 : 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 : 19 : while (
34417 [ + + ]: 27 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
34418 : : )
34419 : : {
34420 : 8 : _res = param_maybe_default_var;
34421 [ - + ]: 8 : if (_n == _children_capacity) {
34422 : 0 : _children_capacity *= 2;
34423 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34424 [ # # ]: 0 : if (!_new_children) {
34425 : 0 : p->error_indicator = 1;
34426 : : PyErr_NoMemory();
34427 : 0 : p->level--;
34428 : 0 : return NULL;
34429 : : }
34430 : 0 : _children = _new_children;
34431 : : }
34432 : 8 : _children[_n++] = _res;
34433 : 8 : _mark = p->mark;
34434 : : }
34435 : 19 : 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 : 19 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34440 [ - + ]: 19 : if (!_seq) {
34441 : 0 : PyMem_Free(_children);
34442 : 0 : p->error_indicator = 1;
34443 : : PyErr_NoMemory();
34444 : 0 : p->level--;
34445 : 0 : return NULL;
34446 : : }
34447 [ + + ]: 27 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34448 : 19 : PyMem_Free(_children);
34449 : 19 : _PyPegen_insert_memo(p, _start_mark, _loop0_172_type, _seq);
34450 : 19 : p->level--;
34451 : 19 : return _seq;
34452 : : }
34453 : :
34454 : : // _tmp_173: param_no_default | ','
34455 : : static void *
34456 : 4 : _tmp_173_rule(Parser *p)
34457 : : {
34458 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
34459 : 0 : p->error_indicator = 1;
34460 : : PyErr_NoMemory();
34461 : : }
34462 [ - + ]: 4 : if (p->error_indicator) {
34463 : 0 : p->level--;
34464 : 0 : return NULL;
34465 : : }
34466 : 4 : void * _res = NULL;
34467 : 4 : int _mark = p->mark;
34468 : : { // param_no_default
34469 [ - + ]: 4 : if (p->error_indicator) {
34470 : 0 : p->level--;
34471 : 0 : 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 [ + - ]: 4 : if (
34476 : 4 : (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 : 4 : _res = param_no_default_var;
34481 : 4 : goto done;
34482 : : }
34483 : 0 : 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 [ # # ]: 0 : if (p->error_indicator) {
34489 : 0 : p->level--;
34490 : 0 : return NULL;
34491 : : }
34492 : : D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
34493 : : Token * _literal;
34494 [ # # ]: 0 : if (
34495 : 0 : (_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 : 0 : _res = _literal;
34500 : 0 : goto done;
34501 : : }
34502 : 0 : 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 : 0 : _res = NULL;
34507 : 4 : done:
34508 : 4 : p->level--;
34509 : 4 : return _res;
34510 : : }
34511 : :
34512 : : // _tmp_174: '*' | '**' | '/'
34513 : : static void *
34514 : 5 : _tmp_174_rule(Parser *p)
34515 : : {
34516 [ - + ]: 5 : if (p->level++ == MAXSTACK) {
34517 : 0 : p->error_indicator = 1;
34518 : : PyErr_NoMemory();
34519 : : }
34520 [ - + ]: 5 : if (p->error_indicator) {
34521 : 0 : p->level--;
34522 : 0 : return NULL;
34523 : : }
34524 : 5 : void * _res = NULL;
34525 : 5 : int _mark = p->mark;
34526 : : { // '*'
34527 [ - + ]: 5 : if (p->error_indicator) {
34528 : 0 : p->level--;
34529 : 0 : return NULL;
34530 : : }
34531 : : D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
34532 : : Token * _literal;
34533 [ + + ]: 5 : if (
34534 : 5 : (_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 : 1 : _res = _literal;
34539 : 1 : goto done;
34540 : : }
34541 : 4 : 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 [ - + ]: 4 : if (p->error_indicator) {
34547 : 0 : p->level--;
34548 : 0 : return NULL;
34549 : : }
34550 : : D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
34551 : : Token * _literal;
34552 [ + + ]: 4 : if (
34553 : 4 : (_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 : 1 : _res = _literal;
34558 : 1 : goto done;
34559 : : }
34560 : 3 : 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 [ - + ]: 3 : if (p->error_indicator) {
34566 : 0 : p->level--;
34567 : 0 : return NULL;
34568 : : }
34569 : : D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'"));
34570 : : Token * _literal;
34571 [ + - ]: 3 : if (
34572 : 3 : (_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 : 3 : _res = _literal;
34577 : 3 : goto done;
34578 : : }
34579 : 0 : 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 : 0 : _res = NULL;
34584 : 5 : done:
34585 : 5 : p->level--;
34586 : 5 : return _res;
34587 : : }
34588 : :
34589 : : // _loop1_175: param_with_default
34590 : : static asdl_seq *
34591 : 288 : _loop1_175_rule(Parser *p)
34592 : : {
34593 [ - + ]: 288 : if (p->level++ == MAXSTACK) {
34594 : 0 : p->error_indicator = 1;
34595 : : PyErr_NoMemory();
34596 : : }
34597 [ - + ]: 288 : if (p->error_indicator) {
34598 : 0 : p->level--;
34599 : 0 : return NULL;
34600 : : }
34601 : 288 : void *_res = NULL;
34602 : 288 : int _mark = p->mark;
34603 : 288 : int _start_mark = p->mark;
34604 : 288 : void **_children = PyMem_Malloc(sizeof(void *));
34605 [ - + ]: 288 : if (!_children) {
34606 : 0 : p->error_indicator = 1;
34607 : : PyErr_NoMemory();
34608 : 0 : p->level--;
34609 : 0 : return NULL;
34610 : : }
34611 : 288 : Py_ssize_t _children_capacity = 1;
34612 : 288 : Py_ssize_t _n = 0;
34613 : : { // param_with_default
34614 [ - + ]: 288 : if (p->error_indicator) {
34615 : 0 : p->level--;
34616 : 0 : 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 : 288 : while (
34621 [ + + ]: 296 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
34622 : : )
34623 : : {
34624 : 8 : _res = param_with_default_var;
34625 [ - + ]: 8 : if (_n == _children_capacity) {
34626 : 0 : _children_capacity *= 2;
34627 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34628 [ # # ]: 0 : if (!_new_children) {
34629 : 0 : p->error_indicator = 1;
34630 : : PyErr_NoMemory();
34631 : 0 : p->level--;
34632 : 0 : return NULL;
34633 : : }
34634 : 0 : _children = _new_children;
34635 : : }
34636 : 8 : _children[_n++] = _res;
34637 : 8 : _mark = p->mark;
34638 : : }
34639 : 288 : 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 [ + + - + ]: 288 : if (_n == 0 || p->error_indicator) {
34644 : 280 : PyMem_Free(_children);
34645 : 280 : p->level--;
34646 : 280 : return NULL;
34647 : : }
34648 : 8 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34649 [ - + ]: 8 : if (!_seq) {
34650 : 0 : PyMem_Free(_children);
34651 : 0 : p->error_indicator = 1;
34652 : : PyErr_NoMemory();
34653 : 0 : p->level--;
34654 : 0 : return NULL;
34655 : : }
34656 [ + + ]: 16 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34657 : 8 : PyMem_Free(_children);
34658 : 8 : _PyPegen_insert_memo(p, _start_mark, _loop1_175_type, _seq);
34659 : 8 : p->level--;
34660 : 8 : return _seq;
34661 : : }
34662 : :
34663 : : // _loop0_176: lambda_param_no_default
34664 : : static asdl_seq *
34665 : 52 : _loop0_176_rule(Parser *p)
34666 : : {
34667 [ - + ]: 52 : if (p->level++ == MAXSTACK) {
34668 : 0 : p->error_indicator = 1;
34669 : : PyErr_NoMemory();
34670 : : }
34671 [ - + ]: 52 : if (p->error_indicator) {
34672 : 0 : p->level--;
34673 : 0 : return NULL;
34674 : : }
34675 : 52 : void *_res = NULL;
34676 : 52 : int _mark = p->mark;
34677 : 52 : int _start_mark = p->mark;
34678 : 52 : void **_children = PyMem_Malloc(sizeof(void *));
34679 [ - + ]: 52 : if (!_children) {
34680 : 0 : p->error_indicator = 1;
34681 : : PyErr_NoMemory();
34682 : 0 : p->level--;
34683 : 0 : return NULL;
34684 : : }
34685 : 52 : Py_ssize_t _children_capacity = 1;
34686 : 52 : Py_ssize_t _n = 0;
34687 : : { // lambda_param_no_default
34688 [ - + ]: 52 : if (p->error_indicator) {
34689 : 0 : p->level--;
34690 : 0 : 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 : 52 : while (
34695 [ + + ]: 80 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
34696 : : )
34697 : : {
34698 : 28 : _res = lambda_param_no_default_var;
34699 [ + + ]: 28 : if (_n == _children_capacity) {
34700 : 2 : _children_capacity *= 2;
34701 : 2 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34702 [ - + ]: 2 : if (!_new_children) {
34703 : 0 : p->error_indicator = 1;
34704 : : PyErr_NoMemory();
34705 : 0 : p->level--;
34706 : 0 : return NULL;
34707 : : }
34708 : 2 : _children = _new_children;
34709 : : }
34710 : 28 : _children[_n++] = _res;
34711 : 28 : _mark = p->mark;
34712 : : }
34713 : 52 : 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 : 52 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34718 [ - + ]: 52 : if (!_seq) {
34719 : 0 : PyMem_Free(_children);
34720 : 0 : p->error_indicator = 1;
34721 : : PyErr_NoMemory();
34722 : 0 : p->level--;
34723 : 0 : return NULL;
34724 : : }
34725 [ + + ]: 80 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34726 : 52 : PyMem_Free(_children);
34727 : 52 : _PyPegen_insert_memo(p, _start_mark, _loop0_176_type, _seq);
34728 : 52 : p->level--;
34729 : 52 : return _seq;
34730 : : }
34731 : :
34732 : : // _loop0_177: lambda_param_no_default
34733 : : static asdl_seq *
34734 : 47 : _loop0_177_rule(Parser *p)
34735 : : {
34736 [ - + ]: 47 : if (p->level++ == MAXSTACK) {
34737 : 0 : p->error_indicator = 1;
34738 : : PyErr_NoMemory();
34739 : : }
34740 [ - + ]: 47 : if (p->error_indicator) {
34741 : 0 : p->level--;
34742 : 0 : return NULL;
34743 : : }
34744 : 47 : void *_res = NULL;
34745 : 47 : int _mark = p->mark;
34746 : 47 : int _start_mark = p->mark;
34747 : 47 : void **_children = PyMem_Malloc(sizeof(void *));
34748 [ - + ]: 47 : if (!_children) {
34749 : 0 : p->error_indicator = 1;
34750 : : PyErr_NoMemory();
34751 : 0 : p->level--;
34752 : 0 : return NULL;
34753 : : }
34754 : 47 : Py_ssize_t _children_capacity = 1;
34755 : 47 : Py_ssize_t _n = 0;
34756 : : { // lambda_param_no_default
34757 [ - + ]: 47 : if (p->error_indicator) {
34758 : 0 : p->level--;
34759 : 0 : 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 : 47 : while (
34764 [ + + ]: 73 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
34765 : : )
34766 : : {
34767 : 26 : _res = lambda_param_no_default_var;
34768 [ + + ]: 26 : if (_n == _children_capacity) {
34769 : 2 : _children_capacity *= 2;
34770 : 2 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34771 [ - + ]: 2 : if (!_new_children) {
34772 : 0 : p->error_indicator = 1;
34773 : : PyErr_NoMemory();
34774 : 0 : p->level--;
34775 : 0 : return NULL;
34776 : : }
34777 : 2 : _children = _new_children;
34778 : : }
34779 : 26 : _children[_n++] = _res;
34780 : 26 : _mark = p->mark;
34781 : : }
34782 : 47 : 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 : 47 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34787 [ - + ]: 47 : if (!_seq) {
34788 : 0 : PyMem_Free(_children);
34789 : 0 : p->error_indicator = 1;
34790 : : PyErr_NoMemory();
34791 : 0 : p->level--;
34792 : 0 : return NULL;
34793 : : }
34794 [ + + ]: 73 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34795 : 47 : PyMem_Free(_children);
34796 : 47 : _PyPegen_insert_memo(p, _start_mark, _loop0_177_type, _seq);
34797 : 47 : p->level--;
34798 : 47 : return _seq;
34799 : : }
34800 : :
34801 : : // _loop0_179: ',' lambda_param
34802 : : static asdl_seq *
34803 : 4 : _loop0_179_rule(Parser *p)
34804 : : {
34805 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
34806 : 0 : p->error_indicator = 1;
34807 : : PyErr_NoMemory();
34808 : : }
34809 [ - + ]: 4 : if (p->error_indicator) {
34810 : 0 : p->level--;
34811 : 0 : return NULL;
34812 : : }
34813 : 4 : void *_res = NULL;
34814 : 4 : int _mark = p->mark;
34815 : 4 : int _start_mark = p->mark;
34816 : 4 : void **_children = PyMem_Malloc(sizeof(void *));
34817 [ - + ]: 4 : if (!_children) {
34818 : 0 : p->error_indicator = 1;
34819 : : PyErr_NoMemory();
34820 : 0 : p->level--;
34821 : 0 : return NULL;
34822 : : }
34823 : 4 : Py_ssize_t _children_capacity = 1;
34824 : 4 : Py_ssize_t _n = 0;
34825 : : { // ',' lambda_param
34826 [ - + ]: 4 : if (p->error_indicator) {
34827 : 0 : p->level--;
34828 : 0 : 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 : 4 : while (
34834 : 12 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
34835 [ + + + - ]: 20 : &&
34836 : 8 : (elem = lambda_param_rule(p)) // lambda_param
34837 : : )
34838 : : {
34839 : 8 : _res = elem;
34840 [ - + - - ]: 8 : if (_res == NULL && PyErr_Occurred()) {
34841 : 0 : p->error_indicator = 1;
34842 : 0 : PyMem_Free(_children);
34843 : 0 : p->level--;
34844 : 0 : return NULL;
34845 : : }
34846 [ + + ]: 8 : if (_n == _children_capacity) {
34847 : 4 : _children_capacity *= 2;
34848 : 4 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34849 [ - + ]: 4 : if (!_new_children) {
34850 : 0 : p->error_indicator = 1;
34851 : : PyErr_NoMemory();
34852 : 0 : p->level--;
34853 : 0 : return NULL;
34854 : : }
34855 : 4 : _children = _new_children;
34856 : : }
34857 : 8 : _children[_n++] = _res;
34858 : 8 : _mark = p->mark;
34859 : : }
34860 : 4 : 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 : 4 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34865 [ - + ]: 4 : if (!_seq) {
34866 : 0 : PyMem_Free(_children);
34867 : 0 : p->error_indicator = 1;
34868 : : PyErr_NoMemory();
34869 : 0 : p->level--;
34870 : 0 : return NULL;
34871 : : }
34872 [ + + ]: 12 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34873 : 4 : PyMem_Free(_children);
34874 : 4 : _PyPegen_insert_memo(p, _start_mark, _loop0_179_type, _seq);
34875 : 4 : p->level--;
34876 : 4 : return _seq;
34877 : : }
34878 : :
34879 : : // _gather_178: lambda_param _loop0_179
34880 : : static asdl_seq *
34881 : 5 : _gather_178_rule(Parser *p)
34882 : : {
34883 [ - + ]: 5 : if (p->level++ == MAXSTACK) {
34884 : 0 : p->error_indicator = 1;
34885 : : PyErr_NoMemory();
34886 : : }
34887 [ - + ]: 5 : if (p->error_indicator) {
34888 : 0 : p->level--;
34889 : 0 : return NULL;
34890 : : }
34891 : 5 : asdl_seq * _res = NULL;
34892 : 5 : int _mark = p->mark;
34893 : : { // lambda_param _loop0_179
34894 [ - + ]: 5 : if (p->error_indicator) {
34895 : 0 : p->level--;
34896 : 0 : 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 [ + + ]: 5 : if (
34902 : 5 : (elem = lambda_param_rule(p)) // lambda_param
34903 [ + - ]: 4 : &&
34904 : 4 : (seq = _loop0_179_rule(p)) // _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 : 4 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
34909 : 4 : goto done;
34910 : : }
34911 : 1 : 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 : 1 : _res = NULL;
34916 : 5 : done:
34917 : 5 : p->level--;
34918 : 5 : return _res;
34919 : : }
34920 : :
34921 : : // _tmp_180: lambda_slash_no_default | lambda_slash_with_default
34922 : : static void *
34923 : 40 : _tmp_180_rule(Parser *p)
34924 : : {
34925 [ - + ]: 40 : if (p->level++ == MAXSTACK) {
34926 : 0 : p->error_indicator = 1;
34927 : : PyErr_NoMemory();
34928 : : }
34929 [ - + ]: 40 : if (p->error_indicator) {
34930 : 0 : p->level--;
34931 : 0 : return NULL;
34932 : : }
34933 : 40 : void * _res = NULL;
34934 : 40 : int _mark = p->mark;
34935 : : { // lambda_slash_no_default
34936 [ - + ]: 40 : if (p->error_indicator) {
34937 : 0 : p->level--;
34938 : 0 : 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 [ + + ]: 40 : if (
34943 : 40 : (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 : 8 : _res = lambda_slash_no_default_var;
34948 : 8 : goto done;
34949 : : }
34950 : 32 : 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 [ - + ]: 32 : if (p->error_indicator) {
34956 : 0 : p->level--;
34957 : 0 : 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 [ + + ]: 32 : if (
34962 : 32 : (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 : 2 : _res = lambda_slash_with_default_var;
34967 : 2 : goto done;
34968 : : }
34969 : 30 : 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 : 30 : _res = NULL;
34974 : 40 : done:
34975 : 40 : p->level--;
34976 : 40 : return _res;
34977 : : }
34978 : :
34979 : : // _loop0_181: lambda_param_maybe_default
34980 : : static asdl_seq *
34981 : 10 : _loop0_181_rule(Parser *p)
34982 : : {
34983 [ - + ]: 10 : if (p->level++ == MAXSTACK) {
34984 : 0 : p->error_indicator = 1;
34985 : : PyErr_NoMemory();
34986 : : }
34987 [ - + ]: 10 : if (p->error_indicator) {
34988 : 0 : p->level--;
34989 : 0 : return NULL;
34990 : : }
34991 : 10 : void *_res = NULL;
34992 : 10 : int _mark = p->mark;
34993 : 10 : int _start_mark = p->mark;
34994 : 10 : void **_children = PyMem_Malloc(sizeof(void *));
34995 [ - + ]: 10 : if (!_children) {
34996 : 0 : p->error_indicator = 1;
34997 : : PyErr_NoMemory();
34998 : 0 : p->level--;
34999 : 0 : return NULL;
35000 : : }
35001 : 10 : Py_ssize_t _children_capacity = 1;
35002 : 10 : Py_ssize_t _n = 0;
35003 : : { // lambda_param_maybe_default
35004 [ - + ]: 10 : if (p->error_indicator) {
35005 : 0 : p->level--;
35006 : 0 : 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 : 10 : while (
35011 [ + + ]: 17 : (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
35012 : : )
35013 : : {
35014 : 7 : _res = lambda_param_maybe_default_var;
35015 [ - + ]: 7 : if (_n == _children_capacity) {
35016 : 0 : _children_capacity *= 2;
35017 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35018 [ # # ]: 0 : if (!_new_children) {
35019 : 0 : p->error_indicator = 1;
35020 : : PyErr_NoMemory();
35021 : 0 : p->level--;
35022 : 0 : return NULL;
35023 : : }
35024 : 0 : _children = _new_children;
35025 : : }
35026 : 7 : _children[_n++] = _res;
35027 : 7 : _mark = p->mark;
35028 : : }
35029 : 10 : 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 : 10 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35034 [ - + ]: 10 : if (!_seq) {
35035 : 0 : PyMem_Free(_children);
35036 : 0 : p->error_indicator = 1;
35037 : : PyErr_NoMemory();
35038 : 0 : p->level--;
35039 : 0 : return NULL;
35040 : : }
35041 [ + + ]: 17 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35042 : 10 : PyMem_Free(_children);
35043 : 10 : _PyPegen_insert_memo(p, _start_mark, _loop0_181_type, _seq);
35044 : 10 : p->level--;
35045 : 10 : return _seq;
35046 : : }
35047 : :
35048 : : // _tmp_182: lambda_slash_no_default | lambda_slash_with_default
35049 : : static void *
35050 : 33 : _tmp_182_rule(Parser *p)
35051 : : {
35052 [ - + ]: 33 : if (p->level++ == MAXSTACK) {
35053 : 0 : p->error_indicator = 1;
35054 : : PyErr_NoMemory();
35055 : : }
35056 [ - + ]: 33 : if (p->error_indicator) {
35057 : 0 : p->level--;
35058 : 0 : return NULL;
35059 : : }
35060 : 33 : void * _res = NULL;
35061 : 33 : int _mark = p->mark;
35062 : : { // lambda_slash_no_default
35063 [ - + ]: 33 : if (p->error_indicator) {
35064 : 0 : p->level--;
35065 : 0 : 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 [ + + ]: 33 : if (
35070 : 33 : (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 : 2 : _res = lambda_slash_no_default_var;
35075 : 2 : goto done;
35076 : : }
35077 : 31 : 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 [ - + ]: 31 : if (p->error_indicator) {
35083 : 0 : p->level--;
35084 : 0 : 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 [ + + ]: 31 : if (
35089 : 31 : (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 : 1 : _res = lambda_slash_with_default_var;
35094 : 1 : goto done;
35095 : : }
35096 : 30 : 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 : 30 : _res = NULL;
35101 : 33 : done:
35102 : 33 : p->level--;
35103 : 33 : return _res;
35104 : : }
35105 : :
35106 : : // _loop0_183: lambda_param_maybe_default
35107 : : static asdl_seq *
35108 : 33 : _loop0_183_rule(Parser *p)
35109 : : {
35110 [ - + ]: 33 : if (p->level++ == MAXSTACK) {
35111 : 0 : p->error_indicator = 1;
35112 : : PyErr_NoMemory();
35113 : : }
35114 [ - + ]: 33 : if (p->error_indicator) {
35115 : 0 : p->level--;
35116 : 0 : return NULL;
35117 : : }
35118 : 33 : void *_res = NULL;
35119 : 33 : int _mark = p->mark;
35120 : 33 : int _start_mark = p->mark;
35121 : 33 : void **_children = PyMem_Malloc(sizeof(void *));
35122 [ - + ]: 33 : if (!_children) {
35123 : 0 : p->error_indicator = 1;
35124 : : PyErr_NoMemory();
35125 : 0 : p->level--;
35126 : 0 : return NULL;
35127 : : }
35128 : 33 : Py_ssize_t _children_capacity = 1;
35129 : 33 : Py_ssize_t _n = 0;
35130 : : { // lambda_param_maybe_default
35131 [ - + ]: 33 : if (p->error_indicator) {
35132 : 0 : p->level--;
35133 : 0 : 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 : 33 : while (
35138 [ + + ]: 51 : (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
35139 : : )
35140 : : {
35141 : 18 : _res = lambda_param_maybe_default_var;
35142 [ - + ]: 18 : if (_n == _children_capacity) {
35143 : 0 : _children_capacity *= 2;
35144 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35145 [ # # ]: 0 : if (!_new_children) {
35146 : 0 : p->error_indicator = 1;
35147 : : PyErr_NoMemory();
35148 : 0 : p->level--;
35149 : 0 : return NULL;
35150 : : }
35151 : 0 : _children = _new_children;
35152 : : }
35153 : 18 : _children[_n++] = _res;
35154 : 18 : _mark = p->mark;
35155 : : }
35156 : 33 : 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 : 33 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35161 [ - + ]: 33 : if (!_seq) {
35162 : 0 : PyMem_Free(_children);
35163 : 0 : p->error_indicator = 1;
35164 : : PyErr_NoMemory();
35165 : 0 : p->level--;
35166 : 0 : return NULL;
35167 : : }
35168 [ + + ]: 51 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35169 : 33 : PyMem_Free(_children);
35170 : 33 : _PyPegen_insert_memo(p, _start_mark, _loop0_183_type, _seq);
35171 : 33 : p->level--;
35172 : 33 : return _seq;
35173 : : }
35174 : :
35175 : : // _tmp_184: ',' | lambda_param_no_default
35176 : : static void *
35177 : 17 : _tmp_184_rule(Parser *p)
35178 : : {
35179 [ - + ]: 17 : if (p->level++ == MAXSTACK) {
35180 : 0 : p->error_indicator = 1;
35181 : : PyErr_NoMemory();
35182 : : }
35183 [ - + ]: 17 : if (p->error_indicator) {
35184 : 0 : p->level--;
35185 : 0 : return NULL;
35186 : : }
35187 : 17 : void * _res = NULL;
35188 : 17 : int _mark = p->mark;
35189 : : { // ','
35190 [ - + ]: 17 : if (p->error_indicator) {
35191 : 0 : p->level--;
35192 : 0 : return NULL;
35193 : : }
35194 : : D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
35195 : : Token * _literal;
35196 [ + + ]: 17 : if (
35197 : 17 : (_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 : 3 : _res = _literal;
35202 : 3 : goto done;
35203 : : }
35204 : 14 : 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 [ - + ]: 14 : if (p->error_indicator) {
35210 : 0 : p->level--;
35211 : 0 : 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 [ + + ]: 14 : if (
35216 : 14 : (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 : 12 : _res = lambda_param_no_default_var;
35221 : 12 : goto done;
35222 : : }
35223 : 2 : 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 : 2 : _res = NULL;
35228 : 17 : done:
35229 : 17 : p->level--;
35230 : 17 : return _res;
35231 : : }
35232 : :
35233 : : // _loop0_185: lambda_param_maybe_default
35234 : : static asdl_seq *
35235 : 15 : _loop0_185_rule(Parser *p)
35236 : : {
35237 [ - + ]: 15 : if (p->level++ == MAXSTACK) {
35238 : 0 : p->error_indicator = 1;
35239 : : PyErr_NoMemory();
35240 : : }
35241 [ - + ]: 15 : if (p->error_indicator) {
35242 : 0 : p->level--;
35243 : 0 : return NULL;
35244 : : }
35245 : 15 : void *_res = NULL;
35246 : 15 : int _mark = p->mark;
35247 : 15 : int _start_mark = p->mark;
35248 : 15 : void **_children = PyMem_Malloc(sizeof(void *));
35249 [ - + ]: 15 : if (!_children) {
35250 : 0 : p->error_indicator = 1;
35251 : : PyErr_NoMemory();
35252 : 0 : p->level--;
35253 : 0 : return NULL;
35254 : : }
35255 : 15 : Py_ssize_t _children_capacity = 1;
35256 : 15 : Py_ssize_t _n = 0;
35257 : : { // lambda_param_maybe_default
35258 [ - + ]: 15 : if (p->error_indicator) {
35259 : 0 : p->level--;
35260 : 0 : 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 : 15 : while (
35265 [ + + ]: 27 : (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
35266 : : )
35267 : : {
35268 : 12 : _res = lambda_param_maybe_default_var;
35269 [ - + ]: 12 : if (_n == _children_capacity) {
35270 : 0 : _children_capacity *= 2;
35271 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35272 [ # # ]: 0 : if (!_new_children) {
35273 : 0 : p->error_indicator = 1;
35274 : : PyErr_NoMemory();
35275 : 0 : p->level--;
35276 : 0 : return NULL;
35277 : : }
35278 : 0 : _children = _new_children;
35279 : : }
35280 : 12 : _children[_n++] = _res;
35281 : 12 : _mark = p->mark;
35282 : : }
35283 : 15 : 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 : 15 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35288 [ - + ]: 15 : if (!_seq) {
35289 : 0 : PyMem_Free(_children);
35290 : 0 : p->error_indicator = 1;
35291 : : PyErr_NoMemory();
35292 : 0 : p->level--;
35293 : 0 : return NULL;
35294 : : }
35295 [ + + ]: 27 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35296 : 15 : PyMem_Free(_children);
35297 : 15 : _PyPegen_insert_memo(p, _start_mark, _loop0_185_type, _seq);
35298 : 15 : p->level--;
35299 : 15 : return _seq;
35300 : : }
35301 : :
35302 : : // _loop1_186: lambda_param_maybe_default
35303 : : static asdl_seq *
35304 : 26 : _loop1_186_rule(Parser *p)
35305 : : {
35306 [ - + ]: 26 : if (p->level++ == MAXSTACK) {
35307 : 0 : p->error_indicator = 1;
35308 : : PyErr_NoMemory();
35309 : : }
35310 [ - + ]: 26 : if (p->error_indicator) {
35311 : 0 : p->level--;
35312 : 0 : return NULL;
35313 : : }
35314 : 26 : void *_res = NULL;
35315 : 26 : int _mark = p->mark;
35316 : 26 : int _start_mark = p->mark;
35317 : 26 : void **_children = PyMem_Malloc(sizeof(void *));
35318 [ - + ]: 26 : if (!_children) {
35319 : 0 : p->error_indicator = 1;
35320 : : PyErr_NoMemory();
35321 : 0 : p->level--;
35322 : 0 : return NULL;
35323 : : }
35324 : 26 : Py_ssize_t _children_capacity = 1;
35325 : 26 : Py_ssize_t _n = 0;
35326 : : { // lambda_param_maybe_default
35327 [ - + ]: 26 : if (p->error_indicator) {
35328 : 0 : p->level--;
35329 : 0 : 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 : 26 : while (
35334 [ + + ]: 44 : (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
35335 : : )
35336 : : {
35337 : 18 : _res = lambda_param_maybe_default_var;
35338 [ + + ]: 18 : if (_n == _children_capacity) {
35339 : 2 : _children_capacity *= 2;
35340 : 2 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35341 [ - + ]: 2 : if (!_new_children) {
35342 : 0 : p->error_indicator = 1;
35343 : : PyErr_NoMemory();
35344 : 0 : p->level--;
35345 : 0 : return NULL;
35346 : : }
35347 : 2 : _children = _new_children;
35348 : : }
35349 : 18 : _children[_n++] = _res;
35350 : 18 : _mark = p->mark;
35351 : : }
35352 : 26 : 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 [ + + - + ]: 26 : if (_n == 0 || p->error_indicator) {
35357 : 10 : PyMem_Free(_children);
35358 : 10 : p->level--;
35359 : 10 : return NULL;
35360 : : }
35361 : 16 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35362 [ - + ]: 16 : if (!_seq) {
35363 : 0 : PyMem_Free(_children);
35364 : 0 : p->error_indicator = 1;
35365 : : PyErr_NoMemory();
35366 : 0 : p->level--;
35367 : 0 : return NULL;
35368 : : }
35369 [ + + ]: 34 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35370 : 16 : PyMem_Free(_children);
35371 : 16 : _PyPegen_insert_memo(p, _start_mark, _loop1_186_type, _seq);
35372 : 16 : p->level--;
35373 : 16 : return _seq;
35374 : : }
35375 : :
35376 : : // _loop1_187: lambda_param_with_default
35377 : : static asdl_seq *
35378 : 47 : _loop1_187_rule(Parser *p)
35379 : : {
35380 [ - + ]: 47 : if (p->level++ == MAXSTACK) {
35381 : 0 : p->error_indicator = 1;
35382 : : PyErr_NoMemory();
35383 : : }
35384 [ - + ]: 47 : if (p->error_indicator) {
35385 : 0 : p->level--;
35386 : 0 : return NULL;
35387 : : }
35388 : 47 : void *_res = NULL;
35389 : 47 : int _mark = p->mark;
35390 : 47 : int _start_mark = p->mark;
35391 : 47 : void **_children = PyMem_Malloc(sizeof(void *));
35392 [ - + ]: 47 : if (!_children) {
35393 : 0 : p->error_indicator = 1;
35394 : : PyErr_NoMemory();
35395 : 0 : p->level--;
35396 : 0 : return NULL;
35397 : : }
35398 : 47 : Py_ssize_t _children_capacity = 1;
35399 : 47 : Py_ssize_t _n = 0;
35400 : : { // lambda_param_with_default
35401 [ - + ]: 47 : if (p->error_indicator) {
35402 : 0 : p->level--;
35403 : 0 : 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 : 47 : while (
35408 [ + + ]: 51 : (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
35409 : : )
35410 : : {
35411 : 4 : _res = lambda_param_with_default_var;
35412 [ - + ]: 4 : if (_n == _children_capacity) {
35413 : 0 : _children_capacity *= 2;
35414 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35415 [ # # ]: 0 : if (!_new_children) {
35416 : 0 : p->error_indicator = 1;
35417 : : PyErr_NoMemory();
35418 : 0 : p->level--;
35419 : 0 : return NULL;
35420 : : }
35421 : 0 : _children = _new_children;
35422 : : }
35423 : 4 : _children[_n++] = _res;
35424 : 4 : _mark = p->mark;
35425 : : }
35426 : 47 : 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 [ + + - + ]: 47 : if (_n == 0 || p->error_indicator) {
35431 : 43 : PyMem_Free(_children);
35432 : 43 : p->level--;
35433 : 43 : return NULL;
35434 : : }
35435 : 4 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35436 [ - + ]: 4 : if (!_seq) {
35437 : 0 : PyMem_Free(_children);
35438 : 0 : p->error_indicator = 1;
35439 : : PyErr_NoMemory();
35440 : 0 : p->level--;
35441 : 0 : return NULL;
35442 : : }
35443 [ + + ]: 8 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35444 : 4 : PyMem_Free(_children);
35445 : 4 : _PyPegen_insert_memo(p, _start_mark, _loop1_187_type, _seq);
35446 : 4 : p->level--;
35447 : 4 : return _seq;
35448 : : }
35449 : :
35450 : : // _tmp_188: ':' | ',' (':' | '**')
35451 : : static void *
35452 : 10 : _tmp_188_rule(Parser *p)
35453 : : {
35454 [ - + ]: 10 : if (p->level++ == MAXSTACK) {
35455 : 0 : p->error_indicator = 1;
35456 : : PyErr_NoMemory();
35457 : : }
35458 [ - + ]: 10 : if (p->error_indicator) {
35459 : 0 : p->level--;
35460 : 0 : return NULL;
35461 : : }
35462 : 10 : void * _res = NULL;
35463 : 10 : int _mark = p->mark;
35464 : : { // ':'
35465 [ - + ]: 10 : if (p->error_indicator) {
35466 : 0 : p->level--;
35467 : 0 : return NULL;
35468 : : }
35469 : : D(fprintf(stderr, "%*c> _tmp_188[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
35470 : : Token * _literal;
35471 [ + + ]: 10 : if (
35472 : 10 : (_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 : 1 : _res = _literal;
35477 : 1 : goto done;
35478 : : }
35479 : 9 : 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 [ - + ]: 9 : if (p->error_indicator) {
35485 : 0 : p->level--;
35486 : 0 : 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 [ - + ]: 9 : if (
35492 : 9 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
35493 [ # # ]: 0 : &&
35494 : 0 : (_tmp_236_var = _tmp_236_rule(p)) // ':' | '**'
35495 : : )
35496 : : {
35497 : : D(fprintf(stderr, "%*c+ _tmp_188[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')"));
35498 : 0 : _res = _PyPegen_dummy_name(p, _literal, _tmp_236_var);
35499 : 0 : goto done;
35500 : : }
35501 : 9 : 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 : 9 : _res = NULL;
35506 : 10 : done:
35507 : 10 : p->level--;
35508 : 10 : return _res;
35509 : : }
35510 : :
35511 : : // _tmp_189: lambda_param_no_default | ','
35512 : : static void *
35513 : 8 : _tmp_189_rule(Parser *p)
35514 : : {
35515 [ - + ]: 8 : if (p->level++ == MAXSTACK) {
35516 : 0 : p->error_indicator = 1;
35517 : : PyErr_NoMemory();
35518 : : }
35519 [ - + ]: 8 : if (p->error_indicator) {
35520 : 0 : p->level--;
35521 : 0 : return NULL;
35522 : : }
35523 : 8 : void * _res = NULL;
35524 : 8 : int _mark = p->mark;
35525 : : { // lambda_param_no_default
35526 [ - + ]: 8 : if (p->error_indicator) {
35527 : 0 : p->level--;
35528 : 0 : 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 [ + - ]: 8 : if (
35533 : 8 : (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 : 8 : _res = lambda_param_no_default_var;
35538 : 8 : goto done;
35539 : : }
35540 : 0 : 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 [ # # ]: 0 : if (p->error_indicator) {
35546 : 0 : p->level--;
35547 : 0 : return NULL;
35548 : : }
35549 : : D(fprintf(stderr, "%*c> _tmp_189[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
35550 : : Token * _literal;
35551 [ # # ]: 0 : if (
35552 : 0 : (_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 : 0 : _res = _literal;
35557 : 0 : goto done;
35558 : : }
35559 : 0 : 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 : 0 : _res = NULL;
35564 : 8 : done:
35565 : 8 : p->level--;
35566 : 8 : return _res;
35567 : : }
35568 : :
35569 : : // _loop0_190: lambda_param_maybe_default
35570 : : static asdl_seq *
35571 : 8 : _loop0_190_rule(Parser *p)
35572 : : {
35573 [ - + ]: 8 : if (p->level++ == MAXSTACK) {
35574 : 0 : p->error_indicator = 1;
35575 : : PyErr_NoMemory();
35576 : : }
35577 [ - + ]: 8 : if (p->error_indicator) {
35578 : 0 : p->level--;
35579 : 0 : return NULL;
35580 : : }
35581 : 8 : void *_res = NULL;
35582 : 8 : int _mark = p->mark;
35583 : 8 : int _start_mark = p->mark;
35584 : 8 : void **_children = PyMem_Malloc(sizeof(void *));
35585 [ - + ]: 8 : if (!_children) {
35586 : 0 : p->error_indicator = 1;
35587 : : PyErr_NoMemory();
35588 : 0 : p->level--;
35589 : 0 : return NULL;
35590 : : }
35591 : 8 : Py_ssize_t _children_capacity = 1;
35592 : 8 : Py_ssize_t _n = 0;
35593 : : { // lambda_param_maybe_default
35594 [ - + ]: 8 : if (p->error_indicator) {
35595 : 0 : p->level--;
35596 : 0 : 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 : 8 : while (
35601 [ + + ]: 15 : (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
35602 : : )
35603 : : {
35604 : 7 : _res = lambda_param_maybe_default_var;
35605 [ - + ]: 7 : if (_n == _children_capacity) {
35606 : 0 : _children_capacity *= 2;
35607 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35608 [ # # ]: 0 : if (!_new_children) {
35609 : 0 : p->error_indicator = 1;
35610 : : PyErr_NoMemory();
35611 : 0 : p->level--;
35612 : 0 : return NULL;
35613 : : }
35614 : 0 : _children = _new_children;
35615 : : }
35616 : 7 : _children[_n++] = _res;
35617 : 7 : _mark = p->mark;
35618 : : }
35619 : 8 : 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 : 8 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35624 [ - + ]: 8 : if (!_seq) {
35625 : 0 : PyMem_Free(_children);
35626 : 0 : p->error_indicator = 1;
35627 : : PyErr_NoMemory();
35628 : 0 : p->level--;
35629 : 0 : return NULL;
35630 : : }
35631 [ + + ]: 15 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35632 : 8 : PyMem_Free(_children);
35633 : 8 : _PyPegen_insert_memo(p, _start_mark, _loop0_190_type, _seq);
35634 : 8 : p->level--;
35635 : 8 : return _seq;
35636 : : }
35637 : :
35638 : : // _tmp_191: lambda_param_no_default | ','
35639 : : static void *
35640 : 4 : _tmp_191_rule(Parser *p)
35641 : : {
35642 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
35643 : 0 : p->error_indicator = 1;
35644 : : PyErr_NoMemory();
35645 : : }
35646 [ - + ]: 4 : if (p->error_indicator) {
35647 : 0 : p->level--;
35648 : 0 : return NULL;
35649 : : }
35650 : 4 : void * _res = NULL;
35651 : 4 : int _mark = p->mark;
35652 : : { // lambda_param_no_default
35653 [ - + ]: 4 : if (p->error_indicator) {
35654 : 0 : p->level--;
35655 : 0 : 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 [ + - ]: 4 : if (
35660 : 4 : (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 : 4 : _res = lambda_param_no_default_var;
35665 : 4 : goto done;
35666 : : }
35667 : 0 : 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 [ # # ]: 0 : if (p->error_indicator) {
35673 : 0 : p->level--;
35674 : 0 : return NULL;
35675 : : }
35676 : : D(fprintf(stderr, "%*c> _tmp_191[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
35677 : : Token * _literal;
35678 [ # # ]: 0 : if (
35679 : 0 : (_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 : 0 : _res = _literal;
35684 : 0 : goto done;
35685 : : }
35686 : 0 : 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 : 0 : _res = NULL;
35691 : 4 : done:
35692 : 4 : p->level--;
35693 : 4 : return _res;
35694 : : }
35695 : :
35696 : : // _tmp_192: '*' | '**' | '/'
35697 : : static void *
35698 : 4 : _tmp_192_rule(Parser *p)
35699 : : {
35700 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
35701 : 0 : p->error_indicator = 1;
35702 : : PyErr_NoMemory();
35703 : : }
35704 [ - + ]: 4 : if (p->error_indicator) {
35705 : 0 : p->level--;
35706 : 0 : return NULL;
35707 : : }
35708 : 4 : void * _res = NULL;
35709 : 4 : int _mark = p->mark;
35710 : : { // '*'
35711 [ - + ]: 4 : if (p->error_indicator) {
35712 : 0 : p->level--;
35713 : 0 : return NULL;
35714 : : }
35715 : : D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
35716 : : Token * _literal;
35717 [ + + ]: 4 : if (
35718 : 4 : (_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 : 1 : _res = _literal;
35723 : 1 : goto done;
35724 : : }
35725 : 3 : 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 [ - + ]: 3 : if (p->error_indicator) {
35731 : 0 : p->level--;
35732 : 0 : return NULL;
35733 : : }
35734 : : D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
35735 : : Token * _literal;
35736 [ + + ]: 3 : if (
35737 : 3 : (_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 : 1 : _res = _literal;
35742 : 1 : goto done;
35743 : : }
35744 : 2 : 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 [ - + ]: 2 : if (p->error_indicator) {
35750 : 0 : p->level--;
35751 : 0 : return NULL;
35752 : : }
35753 : : D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'"));
35754 : : Token * _literal;
35755 [ + - ]: 2 : if (
35756 : 2 : (_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 : 2 : _res = _literal;
35761 : 2 : goto done;
35762 : : }
35763 : 0 : 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 : 0 : _res = NULL;
35768 : 4 : done:
35769 : 4 : p->level--;
35770 : 4 : return _res;
35771 : : }
35772 : :
35773 : : // _tmp_193: ',' | ')' | ':'
35774 : : static void *
35775 : 14 : _tmp_193_rule(Parser *p)
35776 : : {
35777 [ - + ]: 14 : if (p->level++ == MAXSTACK) {
35778 : 0 : p->error_indicator = 1;
35779 : : PyErr_NoMemory();
35780 : : }
35781 [ - + ]: 14 : if (p->error_indicator) {
35782 : 0 : p->level--;
35783 : 0 : return NULL;
35784 : : }
35785 : 14 : void * _res = NULL;
35786 : 14 : int _mark = p->mark;
35787 : : { // ','
35788 [ - + ]: 14 : if (p->error_indicator) {
35789 : 0 : p->level--;
35790 : 0 : return NULL;
35791 : : }
35792 : : D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
35793 : : Token * _literal;
35794 [ + + ]: 14 : if (
35795 : 14 : (_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 : 1 : _res = _literal;
35800 : 1 : goto done;
35801 : : }
35802 : 13 : 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 [ - + ]: 13 : if (p->error_indicator) {
35808 : 0 : p->level--;
35809 : 0 : return NULL;
35810 : : }
35811 : : D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
35812 : : Token * _literal;
35813 [ - + ]: 13 : if (
35814 : 13 : (_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 : 0 : _res = _literal;
35819 : 0 : goto done;
35820 : : }
35821 : 13 : 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 [ - + ]: 13 : if (p->error_indicator) {
35827 : 0 : p->level--;
35828 : 0 : return NULL;
35829 : : }
35830 : : D(fprintf(stderr, "%*c> _tmp_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
35831 : : Token * _literal;
35832 [ + + ]: 13 : if (
35833 : 13 : (_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 : 10 : _res = _literal;
35838 : 10 : goto done;
35839 : : }
35840 : 3 : 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 : 3 : _res = NULL;
35845 : 14 : done:
35846 : 14 : p->level--;
35847 : 14 : return _res;
35848 : : }
35849 : :
35850 : : // _loop0_195: ',' (expression ['as' star_target])
35851 : : static asdl_seq *
35852 : 7 : _loop0_195_rule(Parser *p)
35853 : : {
35854 [ - + ]: 7 : if (p->level++ == MAXSTACK) {
35855 : 0 : p->error_indicator = 1;
35856 : : PyErr_NoMemory();
35857 : : }
35858 [ - + ]: 7 : if (p->error_indicator) {
35859 : 0 : p->level--;
35860 : 0 : return NULL;
35861 : : }
35862 : 7 : void *_res = NULL;
35863 : 7 : int _mark = p->mark;
35864 : 7 : int _start_mark = p->mark;
35865 : 7 : void **_children = PyMem_Malloc(sizeof(void *));
35866 [ - + ]: 7 : if (!_children) {
35867 : 0 : p->error_indicator = 1;
35868 : : PyErr_NoMemory();
35869 : 0 : p->level--;
35870 : 0 : return NULL;
35871 : : }
35872 : 7 : Py_ssize_t _children_capacity = 1;
35873 : 7 : Py_ssize_t _n = 0;
35874 : : { // ',' (expression ['as' star_target])
35875 [ - + ]: 7 : if (p->error_indicator) {
35876 : 0 : p->level--;
35877 : 0 : 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 : 7 : while (
35883 : 10 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
35884 [ + + + - ]: 13 : &&
35885 : 3 : (elem = _tmp_237_rule(p)) // expression ['as' star_target]
35886 : : )
35887 : : {
35888 : 3 : _res = elem;
35889 [ - + - - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
35890 : 0 : p->error_indicator = 1;
35891 : 0 : PyMem_Free(_children);
35892 : 0 : p->level--;
35893 : 0 : return NULL;
35894 : : }
35895 [ + + ]: 3 : if (_n == _children_capacity) {
35896 : 1 : _children_capacity *= 2;
35897 : 1 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35898 [ - + ]: 1 : if (!_new_children) {
35899 : 0 : p->error_indicator = 1;
35900 : : PyErr_NoMemory();
35901 : 0 : p->level--;
35902 : 0 : return NULL;
35903 : : }
35904 : 1 : _children = _new_children;
35905 : : }
35906 : 3 : _children[_n++] = _res;
35907 : 3 : _mark = p->mark;
35908 : : }
35909 : 7 : 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 : 7 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35914 [ - + ]: 7 : if (!_seq) {
35915 : 0 : PyMem_Free(_children);
35916 : 0 : p->error_indicator = 1;
35917 : : PyErr_NoMemory();
35918 : 0 : p->level--;
35919 : 0 : return NULL;
35920 : : }
35921 [ + + ]: 10 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35922 : 7 : PyMem_Free(_children);
35923 : 7 : _PyPegen_insert_memo(p, _start_mark, _loop0_195_type, _seq);
35924 : 7 : p->level--;
35925 : 7 : return _seq;
35926 : : }
35927 : :
35928 : : // _gather_194: (expression ['as' star_target]) _loop0_195
35929 : : static asdl_seq *
35930 : 11 : _gather_194_rule(Parser *p)
35931 : : {
35932 [ - + ]: 11 : if (p->level++ == MAXSTACK) {
35933 : 0 : p->error_indicator = 1;
35934 : : PyErr_NoMemory();
35935 : : }
35936 [ - + ]: 11 : if (p->error_indicator) {
35937 : 0 : p->level--;
35938 : 0 : return NULL;
35939 : : }
35940 : 11 : asdl_seq * _res = NULL;
35941 : 11 : int _mark = p->mark;
35942 : : { // (expression ['as' star_target]) _loop0_195
35943 [ - + ]: 11 : if (p->error_indicator) {
35944 : 0 : p->level--;
35945 : 0 : 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 [ + + ]: 11 : if (
35951 : 11 : (elem = _tmp_237_rule(p)) // expression ['as' star_target]
35952 [ + - ]: 7 : &&
35953 : 7 : (seq = _loop0_195_rule(p)) // _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 : 7 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
35958 : 7 : goto done;
35959 : : }
35960 : 4 : 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 : 4 : _res = NULL;
35965 : 11 : done:
35966 : 11 : p->level--;
35967 : 11 : return _res;
35968 : : }
35969 : :
35970 : : // _loop0_197: ',' (expressions ['as' star_target])
35971 : : static asdl_seq *
35972 : 3 : _loop0_197_rule(Parser *p)
35973 : : {
35974 [ - + ]: 3 : if (p->level++ == MAXSTACK) {
35975 : 0 : p->error_indicator = 1;
35976 : : PyErr_NoMemory();
35977 : : }
35978 [ - + ]: 3 : if (p->error_indicator) {
35979 : 0 : p->level--;
35980 : 0 : return NULL;
35981 : : }
35982 : 3 : void *_res = NULL;
35983 : 3 : int _mark = p->mark;
35984 : 3 : int _start_mark = p->mark;
35985 : 3 : void **_children = PyMem_Malloc(sizeof(void *));
35986 [ - + ]: 3 : if (!_children) {
35987 : 0 : p->error_indicator = 1;
35988 : : PyErr_NoMemory();
35989 : 0 : p->level--;
35990 : 0 : return NULL;
35991 : : }
35992 : 3 : Py_ssize_t _children_capacity = 1;
35993 : 3 : Py_ssize_t _n = 0;
35994 : : { // ',' (expressions ['as' star_target])
35995 [ - + ]: 3 : if (p->error_indicator) {
35996 : 0 : p->level--;
35997 : 0 : 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 : 3 : while (
36003 : 4 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
36004 [ + + + - ]: 5 : &&
36005 : 1 : (elem = _tmp_238_rule(p)) // expressions ['as' star_target]
36006 : : )
36007 : : {
36008 : 1 : _res = elem;
36009 [ - + - - ]: 1 : if (_res == NULL && PyErr_Occurred()) {
36010 : 0 : p->error_indicator = 1;
36011 : 0 : PyMem_Free(_children);
36012 : 0 : p->level--;
36013 : 0 : return NULL;
36014 : : }
36015 [ - + ]: 1 : if (_n == _children_capacity) {
36016 : 0 : _children_capacity *= 2;
36017 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36018 [ # # ]: 0 : if (!_new_children) {
36019 : 0 : p->error_indicator = 1;
36020 : : PyErr_NoMemory();
36021 : 0 : p->level--;
36022 : 0 : return NULL;
36023 : : }
36024 : 0 : _children = _new_children;
36025 : : }
36026 : 1 : _children[_n++] = _res;
36027 : 1 : _mark = p->mark;
36028 : : }
36029 : 3 : 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 : 3 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36034 [ - + ]: 3 : if (!_seq) {
36035 : 0 : PyMem_Free(_children);
36036 : 0 : p->error_indicator = 1;
36037 : : PyErr_NoMemory();
36038 : 0 : p->level--;
36039 : 0 : return NULL;
36040 : : }
36041 [ + + ]: 4 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36042 : 3 : PyMem_Free(_children);
36043 : 3 : _PyPegen_insert_memo(p, _start_mark, _loop0_197_type, _seq);
36044 : 3 : p->level--;
36045 : 3 : return _seq;
36046 : : }
36047 : :
36048 : : // _gather_196: (expressions ['as' star_target]) _loop0_197
36049 : : static asdl_seq *
36050 : 3 : _gather_196_rule(Parser *p)
36051 : : {
36052 [ - + ]: 3 : if (p->level++ == MAXSTACK) {
36053 : 0 : p->error_indicator = 1;
36054 : : PyErr_NoMemory();
36055 : : }
36056 [ - + ]: 3 : if (p->error_indicator) {
36057 : 0 : p->level--;
36058 : 0 : return NULL;
36059 : : }
36060 : 3 : asdl_seq * _res = NULL;
36061 : 3 : int _mark = p->mark;
36062 : : { // (expressions ['as' star_target]) _loop0_197
36063 [ - + ]: 3 : if (p->error_indicator) {
36064 : 0 : p->level--;
36065 : 0 : 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 [ + - ]: 3 : if (
36071 : 3 : (elem = _tmp_238_rule(p)) // expressions ['as' star_target]
36072 [ + - ]: 3 : &&
36073 : 3 : (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 : 3 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
36078 : 3 : goto done;
36079 : : }
36080 : 0 : 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 : 0 : _res = NULL;
36085 : 3 : done:
36086 : 3 : p->level--;
36087 : 3 : return _res;
36088 : : }
36089 : :
36090 : : // _loop0_199: ',' (expression ['as' star_target])
36091 : : static asdl_seq *
36092 : 22 : _loop0_199_rule(Parser *p)
36093 : : {
36094 [ - + ]: 22 : if (p->level++ == MAXSTACK) {
36095 : 0 : p->error_indicator = 1;
36096 : : PyErr_NoMemory();
36097 : : }
36098 [ - + ]: 22 : if (p->error_indicator) {
36099 : 0 : p->level--;
36100 : 0 : return NULL;
36101 : : }
36102 : 22 : void *_res = NULL;
36103 : 22 : int _mark = p->mark;
36104 : 22 : int _start_mark = p->mark;
36105 : 22 : void **_children = PyMem_Malloc(sizeof(void *));
36106 [ - + ]: 22 : if (!_children) {
36107 : 0 : p->error_indicator = 1;
36108 : : PyErr_NoMemory();
36109 : 0 : p->level--;
36110 : 0 : return NULL;
36111 : : }
36112 : 22 : Py_ssize_t _children_capacity = 1;
36113 : 22 : Py_ssize_t _n = 0;
36114 : : { // ',' (expression ['as' star_target])
36115 [ - + ]: 22 : if (p->error_indicator) {
36116 : 0 : p->level--;
36117 : 0 : 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 : 22 : while (
36123 : 28 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
36124 [ + + + - ]: 34 : &&
36125 : 6 : (elem = _tmp_239_rule(p)) // expression ['as' star_target]
36126 : : )
36127 : : {
36128 : 6 : _res = elem;
36129 [ - + - - ]: 6 : if (_res == NULL && PyErr_Occurred()) {
36130 : 0 : p->error_indicator = 1;
36131 : 0 : PyMem_Free(_children);
36132 : 0 : p->level--;
36133 : 0 : return NULL;
36134 : : }
36135 [ + + ]: 6 : if (_n == _children_capacity) {
36136 : 1 : _children_capacity *= 2;
36137 : 1 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36138 [ - + ]: 1 : if (!_new_children) {
36139 : 0 : p->error_indicator = 1;
36140 : : PyErr_NoMemory();
36141 : 0 : p->level--;
36142 : 0 : return NULL;
36143 : : }
36144 : 1 : _children = _new_children;
36145 : : }
36146 : 6 : _children[_n++] = _res;
36147 : 6 : _mark = p->mark;
36148 : : }
36149 : 22 : 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 : 22 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36154 [ - + ]: 22 : if (!_seq) {
36155 : 0 : PyMem_Free(_children);
36156 : 0 : p->error_indicator = 1;
36157 : : PyErr_NoMemory();
36158 : 0 : p->level--;
36159 : 0 : return NULL;
36160 : : }
36161 [ + + ]: 28 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36162 : 22 : PyMem_Free(_children);
36163 : 22 : _PyPegen_insert_memo(p, _start_mark, _loop0_199_type, _seq);
36164 : 22 : p->level--;
36165 : 22 : return _seq;
36166 : : }
36167 : :
36168 : : // _gather_198: (expression ['as' star_target]) _loop0_199
36169 : : static asdl_seq *
36170 : 29 : _gather_198_rule(Parser *p)
36171 : : {
36172 [ - + ]: 29 : if (p->level++ == MAXSTACK) {
36173 : 0 : p->error_indicator = 1;
36174 : : PyErr_NoMemory();
36175 : : }
36176 [ - + ]: 29 : if (p->error_indicator) {
36177 : 0 : p->level--;
36178 : 0 : return NULL;
36179 : : }
36180 : 29 : asdl_seq * _res = NULL;
36181 : 29 : int _mark = p->mark;
36182 : : { // (expression ['as' star_target]) _loop0_199
36183 [ - + ]: 29 : if (p->error_indicator) {
36184 : 0 : p->level--;
36185 : 0 : 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 [ + + ]: 29 : if (
36191 : 29 : (elem = _tmp_239_rule(p)) // expression ['as' star_target]
36192 [ + - ]: 22 : &&
36193 : 22 : (seq = _loop0_199_rule(p)) // _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 : 22 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
36198 : 22 : goto done;
36199 : : }
36200 : 7 : 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 : 7 : _res = NULL;
36205 : 29 : done:
36206 : 29 : p->level--;
36207 : 29 : return _res;
36208 : : }
36209 : :
36210 : : // _loop0_201: ',' (expressions ['as' star_target])
36211 : : static asdl_seq *
36212 : 6 : _loop0_201_rule(Parser *p)
36213 : : {
36214 [ - + ]: 6 : if (p->level++ == MAXSTACK) {
36215 : 0 : p->error_indicator = 1;
36216 : : PyErr_NoMemory();
36217 : : }
36218 [ - + ]: 6 : if (p->error_indicator) {
36219 : 0 : p->level--;
36220 : 0 : return NULL;
36221 : : }
36222 : 6 : void *_res = NULL;
36223 : 6 : int _mark = p->mark;
36224 : 6 : int _start_mark = p->mark;
36225 : 6 : void **_children = PyMem_Malloc(sizeof(void *));
36226 [ - + ]: 6 : if (!_children) {
36227 : 0 : p->error_indicator = 1;
36228 : : PyErr_NoMemory();
36229 : 0 : p->level--;
36230 : 0 : return NULL;
36231 : : }
36232 : 6 : Py_ssize_t _children_capacity = 1;
36233 : 6 : Py_ssize_t _n = 0;
36234 : : { // ',' (expressions ['as' star_target])
36235 [ - + ]: 6 : if (p->error_indicator) {
36236 : 0 : p->level--;
36237 : 0 : 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 : 6 : while (
36243 : 9 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
36244 [ + + + - ]: 12 : &&
36245 : 3 : (elem = _tmp_240_rule(p)) // expressions ['as' star_target]
36246 : : )
36247 : : {
36248 : 3 : _res = elem;
36249 [ - + - - ]: 3 : if (_res == NULL && PyErr_Occurred()) {
36250 : 0 : p->error_indicator = 1;
36251 : 0 : PyMem_Free(_children);
36252 : 0 : p->level--;
36253 : 0 : return NULL;
36254 : : }
36255 [ - + ]: 3 : if (_n == _children_capacity) {
36256 : 0 : _children_capacity *= 2;
36257 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36258 [ # # ]: 0 : if (!_new_children) {
36259 : 0 : p->error_indicator = 1;
36260 : : PyErr_NoMemory();
36261 : 0 : p->level--;
36262 : 0 : return NULL;
36263 : : }
36264 : 0 : _children = _new_children;
36265 : : }
36266 : 3 : _children[_n++] = _res;
36267 : 3 : _mark = p->mark;
36268 : : }
36269 : 6 : 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 : 6 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36274 [ - + ]: 6 : if (!_seq) {
36275 : 0 : PyMem_Free(_children);
36276 : 0 : p->error_indicator = 1;
36277 : : PyErr_NoMemory();
36278 : 0 : p->level--;
36279 : 0 : return NULL;
36280 : : }
36281 [ + + ]: 9 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36282 : 6 : PyMem_Free(_children);
36283 : 6 : _PyPegen_insert_memo(p, _start_mark, _loop0_201_type, _seq);
36284 : 6 : p->level--;
36285 : 6 : return _seq;
36286 : : }
36287 : :
36288 : : // _gather_200: (expressions ['as' star_target]) _loop0_201
36289 : : static asdl_seq *
36290 : 6 : _gather_200_rule(Parser *p)
36291 : : {
36292 [ - + ]: 6 : if (p->level++ == MAXSTACK) {
36293 : 0 : p->error_indicator = 1;
36294 : : PyErr_NoMemory();
36295 : : }
36296 [ - + ]: 6 : if (p->error_indicator) {
36297 : 0 : p->level--;
36298 : 0 : return NULL;
36299 : : }
36300 : 6 : asdl_seq * _res = NULL;
36301 : 6 : int _mark = p->mark;
36302 : : { // (expressions ['as' star_target]) _loop0_201
36303 [ - + ]: 6 : if (p->error_indicator) {
36304 : 0 : p->level--;
36305 : 0 : 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 [ + - ]: 6 : if (
36311 : 6 : (elem = _tmp_240_rule(p)) // expressions ['as' star_target]
36312 [ + - ]: 6 : &&
36313 : 6 : (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 : 6 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
36318 : 6 : goto done;
36319 : : }
36320 : 0 : 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 : 0 : _res = NULL;
36325 : 6 : done:
36326 : 6 : p->level--;
36327 : 6 : return _res;
36328 : : }
36329 : :
36330 : : // _tmp_202: 'except' | 'finally'
36331 : : static void *
36332 : 41 : _tmp_202_rule(Parser *p)
36333 : : {
36334 [ - + ]: 41 : if (p->level++ == MAXSTACK) {
36335 : 0 : p->error_indicator = 1;
36336 : : PyErr_NoMemory();
36337 : : }
36338 [ - + ]: 41 : if (p->error_indicator) {
36339 : 0 : p->level--;
36340 : 0 : return NULL;
36341 : : }
36342 : 41 : void * _res = NULL;
36343 : 41 : int _mark = p->mark;
36344 : : { // 'except'
36345 [ - + ]: 41 : if (p->error_indicator) {
36346 : 0 : p->level--;
36347 : 0 : return NULL;
36348 : : }
36349 : : D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'"));
36350 : : Token * _keyword;
36351 [ + + ]: 41 : if (
36352 : 41 : (_keyword = _PyPegen_expect_token(p, 629)) // token='except'
36353 : : )
36354 : : {
36355 : : D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'"));
36356 : 31 : _res = _keyword;
36357 : 31 : goto done;
36358 : : }
36359 : 10 : 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 [ - + ]: 10 : if (p->error_indicator) {
36365 : 0 : p->level--;
36366 : 0 : return NULL;
36367 : : }
36368 : : D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'"));
36369 : : Token * _keyword;
36370 [ + + ]: 10 : if (
36371 : 10 : (_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 : 9 : _res = _keyword;
36376 : 9 : goto done;
36377 : : }
36378 : 1 : 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 : 1 : _res = NULL;
36383 : 41 : done:
36384 : 41 : p->level--;
36385 : 41 : return _res;
36386 : : }
36387 : :
36388 : : // _loop0_203: block
36389 : : static asdl_seq *
36390 : 49 : _loop0_203_rule(Parser *p)
36391 : : {
36392 [ - + ]: 49 : if (p->level++ == MAXSTACK) {
36393 : 0 : p->error_indicator = 1;
36394 : : PyErr_NoMemory();
36395 : : }
36396 [ - + ]: 49 : if (p->error_indicator) {
36397 : 0 : p->level--;
36398 : 0 : return NULL;
36399 : : }
36400 : 49 : void *_res = NULL;
36401 : 49 : int _mark = p->mark;
36402 : 49 : int _start_mark = p->mark;
36403 : 49 : void **_children = PyMem_Malloc(sizeof(void *));
36404 [ - + ]: 49 : if (!_children) {
36405 : 0 : p->error_indicator = 1;
36406 : : PyErr_NoMemory();
36407 : 0 : p->level--;
36408 : 0 : return NULL;
36409 : : }
36410 : 49 : Py_ssize_t _children_capacity = 1;
36411 : 49 : Py_ssize_t _n = 0;
36412 : : { // block
36413 [ - + ]: 49 : if (p->error_indicator) {
36414 : 0 : p->level--;
36415 : 0 : 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 : 49 : while (
36420 [ + + ]: 89 : (block_var = block_rule(p)) // block
36421 : : )
36422 : : {
36423 : 40 : _res = block_var;
36424 [ - + ]: 40 : if (_n == _children_capacity) {
36425 : 0 : _children_capacity *= 2;
36426 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36427 [ # # ]: 0 : if (!_new_children) {
36428 : 0 : p->error_indicator = 1;
36429 : : PyErr_NoMemory();
36430 : 0 : p->level--;
36431 : 0 : return NULL;
36432 : : }
36433 : 0 : _children = _new_children;
36434 : : }
36435 : 40 : _children[_n++] = _res;
36436 : 40 : _mark = p->mark;
36437 : : }
36438 : 49 : 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 : 49 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36443 [ - + ]: 49 : if (!_seq) {
36444 : 0 : PyMem_Free(_children);
36445 : 0 : p->error_indicator = 1;
36446 : : PyErr_NoMemory();
36447 : 0 : p->level--;
36448 : 0 : return NULL;
36449 : : }
36450 [ + + ]: 89 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36451 : 49 : PyMem_Free(_children);
36452 : 49 : _PyPegen_insert_memo(p, _start_mark, _loop0_203_type, _seq);
36453 : 49 : p->level--;
36454 : 49 : return _seq;
36455 : : }
36456 : :
36457 : : // _tmp_204: (except_block+ except_star_block) | (except_star_block+ except_block)
36458 : : static void *
36459 : 49 : _tmp_204_rule(Parser *p)
36460 : : {
36461 [ - + ]: 49 : if (p->level++ == MAXSTACK) {
36462 : 0 : p->error_indicator = 1;
36463 : : PyErr_NoMemory();
36464 : : }
36465 [ - + ]: 49 : if (p->error_indicator) {
36466 : 0 : p->level--;
36467 : 0 : return NULL;
36468 : : }
36469 : 49 : void * _res = NULL;
36470 : 49 : int _mark = p->mark;
36471 : : { // (except_block+ except_star_block)
36472 [ - + ]: 49 : if (p->error_indicator) {
36473 : 0 : p->level--;
36474 : 0 : 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 [ + + ]: 49 : if (
36479 : 49 : (_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 : 5 : _res = _tmp_241_var;
36484 : 5 : goto done;
36485 : : }
36486 : 44 : 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 [ + + ]: 44 : if (p->error_indicator) {
36492 : 14 : p->level--;
36493 : 14 : 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 [ + + ]: 30 : if (
36498 : 30 : (_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 : 6 : _res = _tmp_242_var;
36503 : 6 : goto done;
36504 : : }
36505 : 24 : 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 : 24 : _res = NULL;
36510 : 35 : done:
36511 : 35 : p->level--;
36512 : 35 : return _res;
36513 : : }
36514 : :
36515 : : // _loop0_205: block
36516 : : static asdl_seq *
36517 : 11 : _loop0_205_rule(Parser *p)
36518 : : {
36519 [ - + ]: 11 : if (p->level++ == MAXSTACK) {
36520 : 0 : p->error_indicator = 1;
36521 : : PyErr_NoMemory();
36522 : : }
36523 [ - + ]: 11 : if (p->error_indicator) {
36524 : 0 : p->level--;
36525 : 0 : return NULL;
36526 : : }
36527 : 11 : void *_res = NULL;
36528 : 11 : int _mark = p->mark;
36529 : 11 : int _start_mark = p->mark;
36530 : 11 : void **_children = PyMem_Malloc(sizeof(void *));
36531 [ - + ]: 11 : if (!_children) {
36532 : 0 : p->error_indicator = 1;
36533 : : PyErr_NoMemory();
36534 : 0 : p->level--;
36535 : 0 : return NULL;
36536 : : }
36537 : 11 : Py_ssize_t _children_capacity = 1;
36538 : 11 : Py_ssize_t _n = 0;
36539 : : { // block
36540 [ - + ]: 11 : if (p->error_indicator) {
36541 : 0 : p->level--;
36542 : 0 : 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 : 11 : while (
36547 [ - + ]: 11 : (block_var = block_rule(p)) // block
36548 : : )
36549 : : {
36550 : 0 : _res = block_var;
36551 [ # # ]: 0 : if (_n == _children_capacity) {
36552 : 0 : _children_capacity *= 2;
36553 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36554 [ # # ]: 0 : if (!_new_children) {
36555 : 0 : p->error_indicator = 1;
36556 : : PyErr_NoMemory();
36557 : 0 : p->level--;
36558 : 0 : return NULL;
36559 : : }
36560 : 0 : _children = _new_children;
36561 : : }
36562 : 0 : _children[_n++] = _res;
36563 : 0 : _mark = p->mark;
36564 : : }
36565 : 11 : 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 : 11 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36570 [ - + ]: 11 : if (!_seq) {
36571 : 0 : PyMem_Free(_children);
36572 : 0 : p->error_indicator = 1;
36573 : : PyErr_NoMemory();
36574 : 0 : p->level--;
36575 : 0 : return NULL;
36576 : : }
36577 [ - + ]: 11 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36578 : 11 : PyMem_Free(_children);
36579 : 11 : _PyPegen_insert_memo(p, _start_mark, _loop0_205_type, _seq);
36580 : 11 : p->level--;
36581 : 11 : return _seq;
36582 : : }
36583 : :
36584 : : // _tmp_206: 'as' NAME
36585 : : static void *
36586 : 8 : _tmp_206_rule(Parser *p)
36587 : : {
36588 [ - + ]: 8 : if (p->level++ == MAXSTACK) {
36589 : 0 : p->error_indicator = 1;
36590 : : PyErr_NoMemory();
36591 : : }
36592 [ - + ]: 8 : if (p->error_indicator) {
36593 : 0 : p->level--;
36594 : 0 : return NULL;
36595 : : }
36596 : 8 : void * _res = NULL;
36597 : 8 : int _mark = p->mark;
36598 : : { // 'as' NAME
36599 [ - + ]: 8 : if (p->error_indicator) {
36600 : 0 : p->level--;
36601 : 0 : 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 [ + + ]: 8 : if (
36607 : 8 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
36608 [ + - ]: 4 : &&
36609 : 4 : (name_var = _PyPegen_name_token(p)) // NAME
36610 : : )
36611 : : {
36612 : : D(fprintf(stderr, "%*c+ _tmp_206[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
36613 : 4 : _res = _PyPegen_dummy_name(p, _keyword, name_var);
36614 : 4 : goto done;
36615 : : }
36616 : 4 : 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 : 4 : _res = NULL;
36621 : 8 : done:
36622 : 8 : p->level--;
36623 : 8 : return _res;
36624 : : }
36625 : :
36626 : : // _tmp_207: 'as' NAME
36627 : : static void *
36628 : 29 : _tmp_207_rule(Parser *p)
36629 : : {
36630 [ - + ]: 29 : if (p->level++ == MAXSTACK) {
36631 : 0 : p->error_indicator = 1;
36632 : : PyErr_NoMemory();
36633 : : }
36634 [ - + ]: 29 : if (p->error_indicator) {
36635 : 0 : p->level--;
36636 : 0 : return NULL;
36637 : : }
36638 : 29 : void * _res = NULL;
36639 : 29 : int _mark = p->mark;
36640 : : { // 'as' NAME
36641 [ - + ]: 29 : if (p->error_indicator) {
36642 : 0 : p->level--;
36643 : 0 : 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 [ + + ]: 29 : if (
36649 : 29 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
36650 [ + - ]: 12 : &&
36651 : 12 : (name_var = _PyPegen_name_token(p)) // NAME
36652 : : )
36653 : : {
36654 : : D(fprintf(stderr, "%*c+ _tmp_207[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
36655 : 12 : _res = _PyPegen_dummy_name(p, _keyword, name_var);
36656 : 12 : goto done;
36657 : : }
36658 : 17 : 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 : 17 : _res = NULL;
36663 : 29 : done:
36664 : 29 : p->level--;
36665 : 29 : return _res;
36666 : : }
36667 : :
36668 : : // _tmp_208: NEWLINE | ':'
36669 : : static void *
36670 : 23 : _tmp_208_rule(Parser *p)
36671 : : {
36672 [ - + ]: 23 : if (p->level++ == MAXSTACK) {
36673 : 0 : p->error_indicator = 1;
36674 : : PyErr_NoMemory();
36675 : : }
36676 [ - + ]: 23 : if (p->error_indicator) {
36677 : 0 : p->level--;
36678 : 0 : return NULL;
36679 : : }
36680 : 23 : void * _res = NULL;
36681 : 23 : int _mark = p->mark;
36682 : : { // NEWLINE
36683 [ - + ]: 23 : if (p->error_indicator) {
36684 : 0 : p->level--;
36685 : 0 : 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 [ - + ]: 23 : if (
36690 : 23 : (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 : 0 : _res = newline_var;
36695 : 0 : goto done;
36696 : : }
36697 : 23 : 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 [ - + ]: 23 : if (p->error_indicator) {
36703 : 0 : p->level--;
36704 : 0 : return NULL;
36705 : : }
36706 : : D(fprintf(stderr, "%*c> _tmp_208[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
36707 : : Token * _literal;
36708 [ + + ]: 23 : if (
36709 : 23 : (_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 : 4 : _res = _literal;
36714 : 4 : goto done;
36715 : : }
36716 : 19 : 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 : 19 : _res = NULL;
36721 : 23 : done:
36722 : 23 : p->level--;
36723 : 23 : return _res;
36724 : : }
36725 : :
36726 : : // _tmp_209: 'as' NAME
36727 : : static void *
36728 : 21 : _tmp_209_rule(Parser *p)
36729 : : {
36730 [ - + ]: 21 : if (p->level++ == MAXSTACK) {
36731 : 0 : p->error_indicator = 1;
36732 : : PyErr_NoMemory();
36733 : : }
36734 [ - + ]: 21 : if (p->error_indicator) {
36735 : 0 : p->level--;
36736 : 0 : return NULL;
36737 : : }
36738 : 21 : void * _res = NULL;
36739 : 21 : int _mark = p->mark;
36740 : : { // 'as' NAME
36741 [ - + ]: 21 : if (p->error_indicator) {
36742 : 0 : p->level--;
36743 : 0 : 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 [ + + ]: 21 : if (
36749 : 21 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
36750 [ + - ]: 4 : &&
36751 : 4 : (name_var = _PyPegen_name_token(p)) // NAME
36752 : : )
36753 : : {
36754 : : D(fprintf(stderr, "%*c+ _tmp_209[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
36755 : 4 : _res = _PyPegen_dummy_name(p, _keyword, name_var);
36756 : 4 : goto done;
36757 : : }
36758 : 17 : 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 : 17 : _res = NULL;
36763 : 21 : done:
36764 : 21 : p->level--;
36765 : 21 : return _res;
36766 : : }
36767 : :
36768 : : // _tmp_210: 'as' NAME
36769 : : static void *
36770 : 18 : _tmp_210_rule(Parser *p)
36771 : : {
36772 [ - + ]: 18 : if (p->level++ == MAXSTACK) {
36773 : 0 : p->error_indicator = 1;
36774 : : PyErr_NoMemory();
36775 : : }
36776 [ - + ]: 18 : if (p->error_indicator) {
36777 : 0 : p->level--;
36778 : 0 : return NULL;
36779 : : }
36780 : 18 : void * _res = NULL;
36781 : 18 : int _mark = p->mark;
36782 : : { // 'as' NAME
36783 [ - + ]: 18 : if (p->error_indicator) {
36784 : 0 : p->level--;
36785 : 0 : 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 [ + + ]: 18 : if (
36791 : 18 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
36792 [ + - ]: 5 : &&
36793 : 5 : (name_var = _PyPegen_name_token(p)) // NAME
36794 : : )
36795 : : {
36796 : : D(fprintf(stderr, "%*c+ _tmp_210[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
36797 : 5 : _res = _PyPegen_dummy_name(p, _keyword, name_var);
36798 : 5 : goto done;
36799 : : }
36800 : 13 : 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 : 13 : _res = NULL;
36805 : 18 : done:
36806 : 18 : p->level--;
36807 : 18 : return _res;
36808 : : }
36809 : :
36810 : : // _tmp_211: positional_patterns ','
36811 : : static void *
36812 : 4 : _tmp_211_rule(Parser *p)
36813 : : {
36814 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
36815 : 0 : p->error_indicator = 1;
36816 : : PyErr_NoMemory();
36817 : : }
36818 [ - + ]: 4 : if (p->error_indicator) {
36819 : 0 : p->level--;
36820 : 0 : return NULL;
36821 : : }
36822 : 4 : void * _res = NULL;
36823 : 4 : int _mark = p->mark;
36824 : : { // positional_patterns ','
36825 [ - + ]: 4 : if (p->error_indicator) {
36826 : 0 : p->level--;
36827 : 0 : 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 [ + + ]: 4 : if (
36833 : 4 : (positional_patterns_var = positional_patterns_rule(p)) // positional_patterns
36834 [ + - ]: 1 : &&
36835 : 1 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
36836 : : )
36837 : : {
36838 : : D(fprintf(stderr, "%*c+ _tmp_211[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','"));
36839 : 1 : _res = _PyPegen_dummy_name(p, positional_patterns_var, _literal);
36840 : 1 : goto done;
36841 : : }
36842 : 3 : 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 : 3 : _res = NULL;
36847 : 4 : done:
36848 : 4 : p->level--;
36849 : 4 : return _res;
36850 : : }
36851 : :
36852 : : // _tmp_212: '->' expression
36853 : : static void *
36854 : 66 : _tmp_212_rule(Parser *p)
36855 : : {
36856 [ - + ]: 66 : if (p->level++ == MAXSTACK) {
36857 : 0 : p->error_indicator = 1;
36858 : : PyErr_NoMemory();
36859 : : }
36860 [ - + ]: 66 : if (p->error_indicator) {
36861 : 0 : p->level--;
36862 : 0 : return NULL;
36863 : : }
36864 : 66 : void * _res = NULL;
36865 : 66 : int _mark = p->mark;
36866 : : { // '->' expression
36867 [ - + ]: 66 : if (p->error_indicator) {
36868 : 0 : p->level--;
36869 : 0 : 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 [ - + ]: 66 : if (
36875 : 66 : (_literal = _PyPegen_expect_token(p, 51)) // token='->'
36876 [ # # ]: 0 : &&
36877 : 0 : (expression_var = expression_rule(p)) // expression
36878 : : )
36879 : : {
36880 : : D(fprintf(stderr, "%*c+ _tmp_212[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
36881 : 0 : _res = _PyPegen_dummy_name(p, _literal, expression_var);
36882 : 0 : goto done;
36883 : : }
36884 : 66 : 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 : 66 : _res = NULL;
36889 : 66 : done:
36890 : 66 : p->level--;
36891 : 66 : return _res;
36892 : : }
36893 : :
36894 : : // _tmp_213: '(' arguments? ')'
36895 : : static void *
36896 : 6 : _tmp_213_rule(Parser *p)
36897 : : {
36898 [ - + ]: 6 : if (p->level++ == MAXSTACK) {
36899 : 0 : p->error_indicator = 1;
36900 : : PyErr_NoMemory();
36901 : : }
36902 [ - + ]: 6 : if (p->error_indicator) {
36903 : 0 : p->level--;
36904 : 0 : return NULL;
36905 : : }
36906 : 6 : void * _res = NULL;
36907 : 6 : int _mark = p->mark;
36908 : : { // '(' arguments? ')'
36909 [ - + ]: 6 : if (p->error_indicator) {
36910 : 0 : p->level--;
36911 : 0 : 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 [ + + ]: 6 : if (
36919 : 6 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
36920 : 2 : &&
36921 [ + - ]: 2 : (_opt_var = arguments_rule(p), !p->error_indicator) // arguments?
36922 [ + + ]: 2 : &&
36923 : 2 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
36924 : : )
36925 : : {
36926 : : D(fprintf(stderr, "%*c+ _tmp_213[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
36927 : 1 : _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1);
36928 : 1 : goto done;
36929 : : }
36930 : 5 : 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 : 5 : _res = NULL;
36935 : 6 : done:
36936 : 6 : p->level--;
36937 : 6 : return _res;
36938 : : }
36939 : :
36940 : : // _tmp_214: '(' arguments? ')'
36941 : : static void *
36942 : 5 : _tmp_214_rule(Parser *p)
36943 : : {
36944 [ - + ]: 5 : if (p->level++ == MAXSTACK) {
36945 : 0 : p->error_indicator = 1;
36946 : : PyErr_NoMemory();
36947 : : }
36948 [ - + ]: 5 : if (p->error_indicator) {
36949 : 0 : p->level--;
36950 : 0 : return NULL;
36951 : : }
36952 : 5 : void * _res = NULL;
36953 : 5 : int _mark = p->mark;
36954 : : { // '(' arguments? ')'
36955 [ - + ]: 5 : if (p->error_indicator) {
36956 : 0 : p->level--;
36957 : 0 : 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 [ + + ]: 5 : if (
36965 : 5 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
36966 : 2 : &&
36967 [ + - ]: 2 : (_opt_var = arguments_rule(p), !p->error_indicator) // arguments?
36968 [ + + ]: 2 : &&
36969 : 2 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
36970 : : )
36971 : : {
36972 : : D(fprintf(stderr, "%*c+ _tmp_214[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
36973 : 1 : _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1);
36974 : 1 : goto done;
36975 : : }
36976 : 4 : 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 : 4 : _res = NULL;
36981 : 5 : done:
36982 : 5 : p->level--;
36983 : 5 : return _res;
36984 : : }
36985 : :
36986 : : // _loop0_216: ',' double_starred_kvpair
36987 : : static asdl_seq *
36988 : 3792 : _loop0_216_rule(Parser *p)
36989 : : {
36990 [ - + ]: 3792 : if (p->level++ == MAXSTACK) {
36991 : 0 : p->error_indicator = 1;
36992 : : PyErr_NoMemory();
36993 : : }
36994 [ - + ]: 3792 : if (p->error_indicator) {
36995 : 0 : p->level--;
36996 : 0 : return NULL;
36997 : : }
36998 : 3792 : void *_res = NULL;
36999 : 3792 : int _mark = p->mark;
37000 : 3792 : int _start_mark = p->mark;
37001 : 3792 : void **_children = PyMem_Malloc(sizeof(void *));
37002 [ - + ]: 3792 : if (!_children) {
37003 : 0 : p->error_indicator = 1;
37004 : : PyErr_NoMemory();
37005 : 0 : p->level--;
37006 : 0 : return NULL;
37007 : : }
37008 : 3792 : Py_ssize_t _children_capacity = 1;
37009 : 3792 : Py_ssize_t _n = 0;
37010 : : { // ',' double_starred_kvpair
37011 [ - + ]: 3792 : if (p->error_indicator) {
37012 : 0 : p->level--;
37013 : 0 : 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 : 3792 : while (
37019 : 3800 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37020 [ + + + + ]: 3811 : &&
37021 : 11 : (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
37022 : : )
37023 : : {
37024 : 8 : _res = elem;
37025 [ - + - - ]: 8 : if (_res == NULL && PyErr_Occurred()) {
37026 : 0 : p->error_indicator = 1;
37027 : 0 : PyMem_Free(_children);
37028 : 0 : p->level--;
37029 : 0 : return NULL;
37030 : : }
37031 [ - + ]: 8 : if (_n == _children_capacity) {
37032 : 0 : _children_capacity *= 2;
37033 : 0 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37034 [ # # ]: 0 : if (!_new_children) {
37035 : 0 : p->error_indicator = 1;
37036 : : PyErr_NoMemory();
37037 : 0 : p->level--;
37038 : 0 : return NULL;
37039 : : }
37040 : 0 : _children = _new_children;
37041 : : }
37042 : 8 : _children[_n++] = _res;
37043 : 8 : _mark = p->mark;
37044 : : }
37045 : 3792 : 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 : 3792 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37050 [ - + ]: 3792 : if (!_seq) {
37051 : 0 : PyMem_Free(_children);
37052 : 0 : p->error_indicator = 1;
37053 : : PyErr_NoMemory();
37054 : 0 : p->level--;
37055 : 0 : return NULL;
37056 : : }
37057 [ + + ]: 3800 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37058 : 3792 : PyMem_Free(_children);
37059 : 3792 : _PyPegen_insert_memo(p, _start_mark, _loop0_216_type, _seq);
37060 : 3792 : p->level--;
37061 : 3792 : return _seq;
37062 : : }
37063 : :
37064 : : // _gather_215: double_starred_kvpair _loop0_216
37065 : : static asdl_seq *
37066 : 13769 : _gather_215_rule(Parser *p)
37067 : : {
37068 [ - + ]: 13769 : if (p->level++ == MAXSTACK) {
37069 : 0 : p->error_indicator = 1;
37070 : : PyErr_NoMemory();
37071 : : }
37072 [ - + ]: 13769 : if (p->error_indicator) {
37073 : 0 : p->level--;
37074 : 0 : return NULL;
37075 : : }
37076 : 13769 : asdl_seq * _res = NULL;
37077 : 13769 : int _mark = p->mark;
37078 : : { // double_starred_kvpair _loop0_216
37079 [ - + ]: 13769 : if (p->error_indicator) {
37080 : 0 : p->level--;
37081 : 0 : 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 [ + + ]: 13769 : if (
37087 : 13769 : (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
37088 [ + - ]: 3792 : &&
37089 : 3792 : (seq = _loop0_216_rule(p)) // _loop0_216
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 : 3792 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
37094 : 3792 : goto done;
37095 : : }
37096 : 9977 : 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 : 9977 : _res = NULL;
37101 : 13769 : done:
37102 : 13769 : p->level--;
37103 : 13769 : return _res;
37104 : : }
37105 : :
37106 : : // _tmp_217: '}' | ','
37107 : : static void *
37108 : 3799 : _tmp_217_rule(Parser *p)
37109 : : {
37110 [ - + ]: 3799 : if (p->level++ == MAXSTACK) {
37111 : 0 : p->error_indicator = 1;
37112 : : PyErr_NoMemory();
37113 : : }
37114 [ - + ]: 3799 : if (p->error_indicator) {
37115 : 0 : p->level--;
37116 : 0 : return NULL;
37117 : : }
37118 : 3799 : void * _res = NULL;
37119 : 3799 : int _mark = p->mark;
37120 : : { // '}'
37121 [ - + ]: 3799 : if (p->error_indicator) {
37122 : 0 : p->level--;
37123 : 0 : return NULL;
37124 : : }
37125 : : D(fprintf(stderr, "%*c> _tmp_217[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
37126 : : Token * _literal;
37127 [ + + ]: 3799 : if (
37128 : 3799 : (_literal = _PyPegen_expect_token(p, 26)) // token='}'
37129 : : )
37130 : : {
37131 : : D(fprintf(stderr, "%*c+ _tmp_217[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'"));
37132 : 1 : _res = _literal;
37133 : 1 : goto done;
37134 : : }
37135 : 3798 : 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 [ - + ]: 3798 : if (p->error_indicator) {
37141 : 0 : p->level--;
37142 : 0 : return NULL;
37143 : : }
37144 : : D(fprintf(stderr, "%*c> _tmp_217[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
37145 : : Token * _literal;
37146 [ - + ]: 3798 : if (
37147 : 3798 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37148 : : )
37149 : : {
37150 : : D(fprintf(stderr, "%*c+ _tmp_217[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
37151 : 0 : _res = _literal;
37152 : 0 : goto done;
37153 : : }
37154 : 3798 : 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 : 3798 : _res = NULL;
37159 : 3799 : done:
37160 : 3799 : p->level--;
37161 : 3799 : return _res;
37162 : : }
37163 : :
37164 : : // _tmp_218: '}' | ','
37165 : : static void *
37166 : 1 : _tmp_218_rule(Parser *p)
37167 : : {
37168 [ - + ]: 1 : if (p->level++ == MAXSTACK) {
37169 : 0 : p->error_indicator = 1;
37170 : : PyErr_NoMemory();
37171 : : }
37172 [ - + ]: 1 : if (p->error_indicator) {
37173 : 0 : p->level--;
37174 : 0 : return NULL;
37175 : : }
37176 : 1 : void * _res = NULL;
37177 : 1 : int _mark = p->mark;
37178 : : { // '}'
37179 [ - + ]: 1 : if (p->error_indicator) {
37180 : 0 : p->level--;
37181 : 0 : return NULL;
37182 : : }
37183 : : D(fprintf(stderr, "%*c> _tmp_218[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
37184 : : Token * _literal;
37185 [ + - ]: 1 : if (
37186 : 1 : (_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 : 1 : _res = _literal;
37191 : 1 : goto done;
37192 : : }
37193 : 0 : 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 [ # # ]: 0 : if (p->error_indicator) {
37199 : 0 : p->level--;
37200 : 0 : return NULL;
37201 : : }
37202 : : D(fprintf(stderr, "%*c> _tmp_218[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
37203 : : Token * _literal;
37204 [ # # ]: 0 : if (
37205 : 0 : (_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 : 0 : _res = _literal;
37210 : 0 : goto done;
37211 : : }
37212 : 0 : 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 : 0 : _res = NULL;
37217 : 1 : done:
37218 : 1 : p->level--;
37219 : 1 : return _res;
37220 : : }
37221 : :
37222 : : // _tmp_219: star_targets '='
37223 : : static void *
37224 : 4011463 : _tmp_219_rule(Parser *p)
37225 : : {
37226 [ - + ]: 4011463 : if (p->level++ == MAXSTACK) {
37227 : 0 : p->error_indicator = 1;
37228 : : PyErr_NoMemory();
37229 : : }
37230 [ - + ]: 4011463 : if (p->error_indicator) {
37231 : 0 : p->level--;
37232 : 0 : return NULL;
37233 : : }
37234 : 4011463 : void * _res = NULL;
37235 : 4011463 : int _mark = p->mark;
37236 : : { // star_targets '='
37237 [ - + ]: 4011463 : if (p->error_indicator) {
37238 : 0 : p->level--;
37239 : 0 : 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 [ + + ]: 4011463 : if (
37245 : 4011463 : (z = star_targets_rule(p)) // star_targets
37246 [ + + ]: 2158638 : &&
37247 : 2158638 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
37248 : : )
37249 : : {
37250 : : D(fprintf(stderr, "%*c+ _tmp_219[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
37251 : 812283 : _res = z;
37252 [ - + - - ]: 812283 : if (_res == NULL && PyErr_Occurred()) {
37253 : 0 : p->error_indicator = 1;
37254 : 0 : p->level--;
37255 : 0 : return NULL;
37256 : : }
37257 : 812283 : goto done;
37258 : : }
37259 : 3199180 : 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 : 3199180 : _res = NULL;
37264 : 4011463 : done:
37265 : 4011463 : p->level--;
37266 : 4011463 : return _res;
37267 : : }
37268 : :
37269 : : // _tmp_220: '.' | '...'
37270 : : static void *
37271 : 57387 : _tmp_220_rule(Parser *p)
37272 : : {
37273 [ - + ]: 57387 : if (p->level++ == MAXSTACK) {
37274 : 0 : p->error_indicator = 1;
37275 : : PyErr_NoMemory();
37276 : : }
37277 [ - + ]: 57387 : if (p->error_indicator) {
37278 : 0 : p->level--;
37279 : 0 : return NULL;
37280 : : }
37281 : 57387 : void * _res = NULL;
37282 : 57387 : int _mark = p->mark;
37283 : : { // '.'
37284 [ - + ]: 57387 : if (p->error_indicator) {
37285 : 0 : p->level--;
37286 : 0 : return NULL;
37287 : : }
37288 : : D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
37289 : : Token * _literal;
37290 [ + + ]: 57387 : if (
37291 : 57387 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
37292 : : )
37293 : : {
37294 : : D(fprintf(stderr, "%*c+ _tmp_220[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
37295 : 11591 : _res = _literal;
37296 : 11591 : goto done;
37297 : : }
37298 : 45796 : 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 [ - + ]: 45796 : if (p->error_indicator) {
37304 : 0 : p->level--;
37305 : 0 : return NULL;
37306 : : }
37307 : : D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
37308 : : Token * _literal;
37309 [ + + ]: 45796 : if (
37310 : 45796 : (_literal = _PyPegen_expect_token(p, 52)) // token='...'
37311 : : )
37312 : : {
37313 : : D(fprintf(stderr, "%*c+ _tmp_220[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
37314 : 6 : _res = _literal;
37315 : 6 : goto done;
37316 : : }
37317 : 45790 : 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 : 45790 : _res = NULL;
37322 : 57387 : done:
37323 : 57387 : p->level--;
37324 : 57387 : return _res;
37325 : : }
37326 : :
37327 : : // _tmp_221: '.' | '...'
37328 : : static void *
37329 : 2650 : _tmp_221_rule(Parser *p)
37330 : : {
37331 [ - + ]: 2650 : if (p->level++ == MAXSTACK) {
37332 : 0 : p->error_indicator = 1;
37333 : : PyErr_NoMemory();
37334 : : }
37335 [ - + ]: 2650 : if (p->error_indicator) {
37336 : 0 : p->level--;
37337 : 0 : return NULL;
37338 : : }
37339 : 2650 : void * _res = NULL;
37340 : 2650 : int _mark = p->mark;
37341 : : { // '.'
37342 [ - + ]: 2650 : if (p->error_indicator) {
37343 : 0 : p->level--;
37344 : 0 : return NULL;
37345 : : }
37346 : : D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
37347 : : Token * _literal;
37348 [ + + ]: 2650 : if (
37349 : 2650 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
37350 : : )
37351 : : {
37352 : : D(fprintf(stderr, "%*c+ _tmp_221[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
37353 : 1372 : _res = _literal;
37354 : 1372 : goto done;
37355 : : }
37356 : 1278 : 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 [ - + ]: 1278 : if (p->error_indicator) {
37362 : 0 : p->level--;
37363 : 0 : return NULL;
37364 : : }
37365 : : D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
37366 : : Token * _literal;
37367 [ + + ]: 1278 : if (
37368 : 1278 : (_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 : 1 : _res = _literal;
37373 : 1 : goto done;
37374 : : }
37375 : 1277 : 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 : 1277 : _res = NULL;
37380 : 2650 : done:
37381 : 2650 : p->level--;
37382 : 2650 : return _res;
37383 : : }
37384 : :
37385 : : // _tmp_222: '@' named_expression NEWLINE
37386 : : static void *
37387 : 440979 : _tmp_222_rule(Parser *p)
37388 : : {
37389 [ - + ]: 440979 : if (p->level++ == MAXSTACK) {
37390 : 0 : p->error_indicator = 1;
37391 : : PyErr_NoMemory();
37392 : : }
37393 [ - + ]: 440979 : if (p->error_indicator) {
37394 : 0 : p->level--;
37395 : 0 : return NULL;
37396 : : }
37397 : 440979 : void * _res = NULL;
37398 : 440979 : int _mark = p->mark;
37399 : : { // '@' named_expression NEWLINE
37400 [ - + ]: 440979 : if (p->error_indicator) {
37401 : 0 : p->level--;
37402 : 0 : 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 [ + + ]: 440979 : if (
37409 : 440979 : (_literal = _PyPegen_expect_token(p, 49)) // token='@'
37410 [ + + ]: 40159 : &&
37411 : 40159 : (f = named_expression_rule(p)) // named_expression
37412 [ + + ]: 40140 : &&
37413 : 40140 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
37414 : : )
37415 : : {
37416 : : D(fprintf(stderr, "%*c+ _tmp_222[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE"));
37417 : 40130 : _res = f;
37418 [ - + - - ]: 40130 : if (_res == NULL && PyErr_Occurred()) {
37419 : 0 : p->error_indicator = 1;
37420 : 0 : p->level--;
37421 : 0 : return NULL;
37422 : : }
37423 : 40130 : goto done;
37424 : : }
37425 : 400849 : 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 : 400849 : _res = NULL;
37430 : 440979 : done:
37431 : 440979 : p->level--;
37432 : 440979 : return _res;
37433 : : }
37434 : :
37435 : : // _tmp_223: ',' expression
37436 : : static void *
37437 : 513299 : _tmp_223_rule(Parser *p)
37438 : : {
37439 [ - + ]: 513299 : if (p->level++ == MAXSTACK) {
37440 : 0 : p->error_indicator = 1;
37441 : : PyErr_NoMemory();
37442 : : }
37443 [ - + ]: 513299 : if (p->error_indicator) {
37444 : 0 : p->level--;
37445 : 0 : return NULL;
37446 : : }
37447 : 513299 : void * _res = NULL;
37448 : 513299 : int _mark = p->mark;
37449 : : { // ',' expression
37450 [ - + ]: 513299 : if (p->error_indicator) {
37451 : 0 : p->level--;
37452 : 0 : 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 [ + + ]: 513299 : if (
37458 : 513299 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37459 [ + + ]: 441233 : &&
37460 : 441233 : (c = expression_rule(p)) // expression
37461 : : )
37462 : : {
37463 : : D(fprintf(stderr, "%*c+ _tmp_223[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression"));
37464 : 441210 : _res = c;
37465 [ - + - - ]: 441210 : if (_res == NULL && PyErr_Occurred()) {
37466 : 0 : p->error_indicator = 1;
37467 : 0 : p->level--;
37468 : 0 : return NULL;
37469 : : }
37470 : 441210 : goto done;
37471 : : }
37472 : 72089 : 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 : 72089 : _res = NULL;
37477 : 513299 : done:
37478 : 513299 : p->level--;
37479 : 513299 : return _res;
37480 : : }
37481 : :
37482 : : // _tmp_224: ',' star_expression
37483 : : static void *
37484 : 2122843 : _tmp_224_rule(Parser *p)
37485 : : {
37486 [ - + ]: 2122843 : if (p->level++ == MAXSTACK) {
37487 : 0 : p->error_indicator = 1;
37488 : : PyErr_NoMemory();
37489 : : }
37490 [ - + ]: 2122843 : if (p->error_indicator) {
37491 : 0 : p->level--;
37492 : 0 : return NULL;
37493 : : }
37494 : 2122843 : void * _res = NULL;
37495 : 2122843 : int _mark = p->mark;
37496 : : { // ',' star_expression
37497 [ - + ]: 2122843 : if (p->error_indicator) {
37498 : 0 : p->level--;
37499 : 0 : 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 [ + + ]: 2122843 : if (
37505 : 2122843 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37506 [ + + ]: 28232 : &&
37507 : 28232 : (c = star_expression_rule(p)) // star_expression
37508 : : )
37509 : : {
37510 : : D(fprintf(stderr, "%*c+ _tmp_224[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression"));
37511 : 27947 : _res = c;
37512 [ - + - - ]: 27947 : if (_res == NULL && PyErr_Occurred()) {
37513 : 0 : p->error_indicator = 1;
37514 : 0 : p->level--;
37515 : 0 : return NULL;
37516 : : }
37517 : 27947 : goto done;
37518 : : }
37519 : 2094896 : 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 : 2094896 : _res = NULL;
37524 : 2122843 : done:
37525 : 2122843 : p->level--;
37526 : 2122843 : return _res;
37527 : : }
37528 : :
37529 : : // _tmp_225: 'or' conjunction
37530 : : static void *
37531 : 9746242 : _tmp_225_rule(Parser *p)
37532 : : {
37533 [ - + ]: 9746242 : if (p->level++ == MAXSTACK) {
37534 : 0 : p->error_indicator = 1;
37535 : : PyErr_NoMemory();
37536 : : }
37537 [ - + ]: 9746242 : if (p->error_indicator) {
37538 : 0 : p->level--;
37539 : 0 : return NULL;
37540 : : }
37541 : 9746242 : void * _res = NULL;
37542 : 9746242 : int _mark = p->mark;
37543 : : { // 'or' conjunction
37544 [ - + ]: 9746242 : if (p->error_indicator) {
37545 : 0 : p->level--;
37546 : 0 : 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 [ + + ]: 9746242 : if (
37552 : 9746242 : (_keyword = _PyPegen_expect_token(p, 574)) // token='or'
37553 [ + - ]: 28865 : &&
37554 : 28865 : (c = conjunction_rule(p)) // conjunction
37555 : : )
37556 : : {
37557 : : D(fprintf(stderr, "%*c+ _tmp_225[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction"));
37558 : 28865 : _res = c;
37559 [ - + - - ]: 28865 : if (_res == NULL && PyErr_Occurred()) {
37560 : 0 : p->error_indicator = 1;
37561 : 0 : p->level--;
37562 : 0 : return NULL;
37563 : : }
37564 : 28865 : goto done;
37565 : : }
37566 : 9717377 : 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 : 9717377 : _res = NULL;
37571 : 9746242 : done:
37572 : 9746242 : p->level--;
37573 : 9746242 : return _res;
37574 : : }
37575 : :
37576 : : // _tmp_226: 'and' inversion
37577 : : static void *
37578 : 9792135 : _tmp_226_rule(Parser *p)
37579 : : {
37580 [ - + ]: 9792135 : if (p->level++ == MAXSTACK) {
37581 : 0 : p->error_indicator = 1;
37582 : : PyErr_NoMemory();
37583 : : }
37584 [ - + ]: 9792135 : if (p->error_indicator) {
37585 : 0 : p->level--;
37586 : 0 : return NULL;
37587 : : }
37588 : 9792135 : void * _res = NULL;
37589 : 9792135 : int _mark = p->mark;
37590 : : { // 'and' inversion
37591 [ - + ]: 9792135 : if (p->error_indicator) {
37592 : 0 : p->level--;
37593 : 0 : 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 [ + + ]: 9792135 : if (
37599 : 9792135 : (_keyword = _PyPegen_expect_token(p, 575)) // token='and'
37600 [ + - ]: 45893 : &&
37601 : 45893 : (c = inversion_rule(p)) // inversion
37602 : : )
37603 : : {
37604 : : D(fprintf(stderr, "%*c+ _tmp_226[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion"));
37605 : 45893 : _res = c;
37606 [ - + - - ]: 45893 : if (_res == NULL && PyErr_Occurred()) {
37607 : 0 : p->error_indicator = 1;
37608 : 0 : p->level--;
37609 : 0 : return NULL;
37610 : : }
37611 : 45893 : goto done;
37612 : : }
37613 : 9746242 : 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 : 9746242 : _res = NULL;
37618 : 9792135 : done:
37619 : 9792135 : p->level--;
37620 : 9792135 : return _res;
37621 : : }
37622 : :
37623 : : // _tmp_227: slice | starred_expression
37624 : : static void *
37625 : 48014 : _tmp_227_rule(Parser *p)
37626 : : {
37627 [ - + ]: 48014 : if (p->level++ == MAXSTACK) {
37628 : 0 : p->error_indicator = 1;
37629 : : PyErr_NoMemory();
37630 : : }
37631 [ - + ]: 48014 : if (p->error_indicator) {
37632 : 0 : p->level--;
37633 : 0 : return NULL;
37634 : : }
37635 : 48014 : void * _res = NULL;
37636 : 48014 : int _mark = p->mark;
37637 : : { // slice
37638 [ - + ]: 48014 : if (p->error_indicator) {
37639 : 0 : p->level--;
37640 : 0 : 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 [ + + ]: 48014 : if (
37645 : 48014 : (slice_var = slice_rule(p)) // slice
37646 : : )
37647 : : {
37648 : : D(fprintf(stderr, "%*c+ _tmp_227[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice"));
37649 : 45944 : _res = slice_var;
37650 : 45944 : goto done;
37651 : : }
37652 : 2070 : 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 [ + + ]: 2070 : if (p->error_indicator) {
37658 : 2 : p->level--;
37659 : 2 : 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 [ + + ]: 2068 : if (
37664 : 2068 : (starred_expression_var = starred_expression_rule(p)) // starred_expression
37665 : : )
37666 : : {
37667 : : D(fprintf(stderr, "%*c+ _tmp_227[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
37668 : 1545 : _res = starred_expression_var;
37669 : 1545 : goto done;
37670 : : }
37671 : 523 : 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 : 523 : _res = NULL;
37676 : 48012 : done:
37677 : 48012 : p->level--;
37678 : 48012 : return _res;
37679 : : }
37680 : :
37681 : : // _tmp_228: 'if' disjunction
37682 : : static void *
37683 : 568 : _tmp_228_rule(Parser *p)
37684 : : {
37685 [ - + ]: 568 : if (p->level++ == MAXSTACK) {
37686 : 0 : p->error_indicator = 1;
37687 : : PyErr_NoMemory();
37688 : : }
37689 [ - + ]: 568 : if (p->error_indicator) {
37690 : 0 : p->level--;
37691 : 0 : return NULL;
37692 : : }
37693 : 568 : void * _res = NULL;
37694 : 568 : int _mark = p->mark;
37695 : : { // 'if' disjunction
37696 [ - + ]: 568 : if (p->error_indicator) {
37697 : 0 : p->level--;
37698 : 0 : 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 [ + + ]: 568 : if (
37704 : 568 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
37705 [ + - ]: 60 : &&
37706 : 60 : (z = disjunction_rule(p)) // disjunction
37707 : : )
37708 : : {
37709 : : D(fprintf(stderr, "%*c+ _tmp_228[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
37710 : 60 : _res = z;
37711 [ - + - - ]: 60 : if (_res == NULL && PyErr_Occurred()) {
37712 : 0 : p->error_indicator = 1;
37713 : 0 : p->level--;
37714 : 0 : return NULL;
37715 : : }
37716 : 60 : goto done;
37717 : : }
37718 : 508 : 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 : 508 : _res = NULL;
37723 : 568 : done:
37724 : 568 : p->level--;
37725 : 568 : return _res;
37726 : : }
37727 : :
37728 : : // _tmp_229: 'if' disjunction
37729 : : static void *
37730 : 63504 : _tmp_229_rule(Parser *p)
37731 : : {
37732 [ - + ]: 63504 : if (p->level++ == MAXSTACK) {
37733 : 0 : p->error_indicator = 1;
37734 : : PyErr_NoMemory();
37735 : : }
37736 [ - + ]: 63504 : if (p->error_indicator) {
37737 : 0 : p->level--;
37738 : 0 : return NULL;
37739 : : }
37740 : 63504 : void * _res = NULL;
37741 : 63504 : int _mark = p->mark;
37742 : : { // 'if' disjunction
37743 [ - + ]: 63504 : if (p->error_indicator) {
37744 : 0 : p->level--;
37745 : 0 : 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 [ + + ]: 63504 : if (
37751 : 63504 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
37752 [ + - ]: 12432 : &&
37753 : 12432 : (z = disjunction_rule(p)) // disjunction
37754 : : )
37755 : : {
37756 : : D(fprintf(stderr, "%*c+ _tmp_229[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
37757 : 12432 : _res = z;
37758 [ - + - - ]: 12432 : if (_res == NULL && PyErr_Occurred()) {
37759 : 0 : p->error_indicator = 1;
37760 : 0 : p->level--;
37761 : 0 : return NULL;
37762 : : }
37763 : 12432 : goto done;
37764 : : }
37765 : 51072 : 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 : 51072 : _res = NULL;
37770 : 63504 : done:
37771 : 63504 : p->level--;
37772 : 63504 : return _res;
37773 : : }
37774 : :
37775 : : // _tmp_230: starred_expression | (assignment_expression | expression !':=') !'='
37776 : : static void *
37777 : 2751931 : _tmp_230_rule(Parser *p)
37778 : : {
37779 [ - + ]: 2751931 : if (p->level++ == MAXSTACK) {
37780 : 0 : p->error_indicator = 1;
37781 : : PyErr_NoMemory();
37782 : : }
37783 [ - + ]: 2751931 : if (p->error_indicator) {
37784 : 0 : p->level--;
37785 : 0 : return NULL;
37786 : : }
37787 : 2751931 : void * _res = NULL;
37788 : 2751931 : int _mark = p->mark;
37789 : : { // starred_expression
37790 [ - + ]: 2751931 : if (p->error_indicator) {
37791 : 0 : p->level--;
37792 : 0 : 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 [ + + ]: 2751931 : if (
37797 : 2751931 : (starred_expression_var = starred_expression_rule(p)) // starred_expression
37798 : : )
37799 : : {
37800 : : D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
37801 : 10827 : _res = starred_expression_var;
37802 : 10827 : goto done;
37803 : : }
37804 : 2741104 : 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 [ + + ]: 2741104 : if (p->error_indicator) {
37810 : 10 : p->level--;
37811 : 10 : 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 [ + + ]: 2741094 : if (
37816 : 2741094 : (_tmp_243_var = _tmp_243_rule(p)) // assignment_expression | expression !':='
37817 [ + + ]: 2183067 : &&
37818 : 2183067 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='='
37819 : : )
37820 : : {
37821 : : D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
37822 : 2084321 : _res = _tmp_243_var;
37823 : 2084321 : goto done;
37824 : : }
37825 : 656773 : 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 : 656773 : _res = NULL;
37830 : 2751921 : done:
37831 : 2751921 : p->level--;
37832 : 2751921 : return _res;
37833 : : }
37834 : :
37835 : : // _tmp_231: ',' star_target
37836 : : static void *
37837 : 135571 : _tmp_231_rule(Parser *p)
37838 : : {
37839 [ - + ]: 135571 : if (p->level++ == MAXSTACK) {
37840 : 0 : p->error_indicator = 1;
37841 : : PyErr_NoMemory();
37842 : : }
37843 [ - + ]: 135571 : if (p->error_indicator) {
37844 : 0 : p->level--;
37845 : 0 : return NULL;
37846 : : }
37847 : 135571 : void * _res = NULL;
37848 : 135571 : int _mark = p->mark;
37849 : : { // ',' star_target
37850 [ - + ]: 135571 : if (p->error_indicator) {
37851 : 0 : p->level--;
37852 : 0 : 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 [ + + ]: 135571 : if (
37858 : 135571 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37859 [ + + ]: 79982 : &&
37860 : 79982 : (c = star_target_rule(p)) // star_target
37861 : : )
37862 : : {
37863 : : D(fprintf(stderr, "%*c+ _tmp_231[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target"));
37864 : 78819 : _res = c;
37865 [ - + - - ]: 78819 : if (_res == NULL && PyErr_Occurred()) {
37866 : 0 : p->error_indicator = 1;
37867 : 0 : p->level--;
37868 : 0 : return NULL;
37869 : : }
37870 : 78819 : goto done;
37871 : : }
37872 : 56752 : 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 : 56752 : _res = NULL;
37877 : 135571 : done:
37878 : 135571 : p->level--;
37879 : 135571 : return _res;
37880 : : }
37881 : :
37882 : : // _tmp_232: ',' star_target
37883 : : static void *
37884 : 32920 : _tmp_232_rule(Parser *p)
37885 : : {
37886 [ - + ]: 32920 : if (p->level++ == MAXSTACK) {
37887 : 0 : p->error_indicator = 1;
37888 : : PyErr_NoMemory();
37889 : : }
37890 [ - + ]: 32920 : if (p->error_indicator) {
37891 : 0 : p->level--;
37892 : 0 : return NULL;
37893 : : }
37894 : 32920 : void * _res = NULL;
37895 : 32920 : int _mark = p->mark;
37896 : : { // ',' star_target
37897 [ - + ]: 32920 : if (p->error_indicator) {
37898 : 0 : p->level--;
37899 : 0 : 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 [ + + ]: 32920 : if (
37905 : 32920 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37906 [ + + ]: 18696 : &&
37907 : 18696 : (c = star_target_rule(p)) // star_target
37908 : : )
37909 : : {
37910 : : D(fprintf(stderr, "%*c+ _tmp_232[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target"));
37911 : 16420 : _res = c;
37912 [ - + - - ]: 16420 : if (_res == NULL && PyErr_Occurred()) {
37913 : 0 : p->error_indicator = 1;
37914 : 0 : p->level--;
37915 : 0 : return NULL;
37916 : : }
37917 : 16420 : goto done;
37918 : : }
37919 : 16500 : 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 : 16500 : _res = NULL;
37924 : 32920 : done:
37925 : 32920 : p->level--;
37926 : 32920 : return _res;
37927 : : }
37928 : :
37929 : : // _tmp_233: star_targets '='
37930 : : static void *
37931 : 803 : _tmp_233_rule(Parser *p)
37932 : : {
37933 [ - + ]: 803 : if (p->level++ == MAXSTACK) {
37934 : 0 : p->error_indicator = 1;
37935 : : PyErr_NoMemory();
37936 : : }
37937 [ - + ]: 803 : if (p->error_indicator) {
37938 : 0 : p->level--;
37939 : 0 : return NULL;
37940 : : }
37941 : 803 : void * _res = NULL;
37942 : 803 : int _mark = p->mark;
37943 : : { // star_targets '='
37944 [ - + ]: 803 : if (p->error_indicator) {
37945 : 0 : p->level--;
37946 : 0 : 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 [ + + ]: 803 : if (
37952 : 803 : (star_targets_var = star_targets_rule(p)) // star_targets
37953 [ + + ]: 106 : &&
37954 : 106 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
37955 : : )
37956 : : {
37957 : : D(fprintf(stderr, "%*c+ _tmp_233[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
37958 : 7 : _res = _PyPegen_dummy_name(p, star_targets_var, _literal);
37959 : 7 : goto done;
37960 : : }
37961 : 796 : 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 : 796 : _res = NULL;
37966 : 803 : done:
37967 : 803 : p->level--;
37968 : 803 : return _res;
37969 : : }
37970 : :
37971 : : // _tmp_234: star_targets '='
37972 : : static void *
37973 : 779 : _tmp_234_rule(Parser *p)
37974 : : {
37975 [ - + ]: 779 : if (p->level++ == MAXSTACK) {
37976 : 0 : p->error_indicator = 1;
37977 : : PyErr_NoMemory();
37978 : : }
37979 [ - + ]: 779 : if (p->error_indicator) {
37980 : 0 : p->level--;
37981 : 0 : return NULL;
37982 : : }
37983 : 779 : void * _res = NULL;
37984 : 779 : int _mark = p->mark;
37985 : : { // star_targets '='
37986 [ - + ]: 779 : if (p->error_indicator) {
37987 : 0 : p->level--;
37988 : 0 : 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 [ + + ]: 779 : if (
37994 : 779 : (star_targets_var = star_targets_rule(p)) // star_targets
37995 [ + + ]: 103 : &&
37996 : 103 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
37997 : : )
37998 : : {
37999 : : D(fprintf(stderr, "%*c+ _tmp_234[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
38000 : 5 : _res = _PyPegen_dummy_name(p, star_targets_var, _literal);
38001 : 5 : goto done;
38002 : : }
38003 : 774 : 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 : 774 : _res = NULL;
38008 : 779 : done:
38009 : 779 : p->level--;
38010 : 779 : return _res;
38011 : : }
38012 : :
38013 : : // _tmp_235: ')' | '**'
38014 : : static void *
38015 : 9 : _tmp_235_rule(Parser *p)
38016 : : {
38017 [ - + ]: 9 : if (p->level++ == MAXSTACK) {
38018 : 0 : p->error_indicator = 1;
38019 : : PyErr_NoMemory();
38020 : : }
38021 [ - + ]: 9 : if (p->error_indicator) {
38022 : 0 : p->level--;
38023 : 0 : return NULL;
38024 : : }
38025 : 9 : void * _res = NULL;
38026 : 9 : int _mark = p->mark;
38027 : : { // ')'
38028 [ - + ]: 9 : if (p->error_indicator) {
38029 : 0 : p->level--;
38030 : 0 : return NULL;
38031 : : }
38032 : : D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
38033 : : Token * _literal;
38034 [ - + ]: 9 : if (
38035 : 9 : (_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 : 0 : _res = _literal;
38040 : 0 : goto done;
38041 : : }
38042 : 9 : 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 [ - + ]: 9 : if (p->error_indicator) {
38048 : 0 : p->level--;
38049 : 0 : return NULL;
38050 : : }
38051 : : D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
38052 : : Token * _literal;
38053 [ + + ]: 9 : if (
38054 : 9 : (_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 : 1 : _res = _literal;
38059 : 1 : goto done;
38060 : : }
38061 : 8 : 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 : 8 : _res = NULL;
38066 : 9 : done:
38067 : 9 : p->level--;
38068 : 9 : return _res;
38069 : : }
38070 : :
38071 : : // _tmp_236: ':' | '**'
38072 : : static void *
38073 : 0 : _tmp_236_rule(Parser *p)
38074 : : {
38075 [ # # ]: 0 : if (p->level++ == MAXSTACK) {
38076 : 0 : p->error_indicator = 1;
38077 : : PyErr_NoMemory();
38078 : : }
38079 [ # # ]: 0 : if (p->error_indicator) {
38080 : 0 : p->level--;
38081 : 0 : return NULL;
38082 : : }
38083 : 0 : void * _res = NULL;
38084 : 0 : int _mark = p->mark;
38085 : : { // ':'
38086 [ # # ]: 0 : if (p->error_indicator) {
38087 : 0 : p->level--;
38088 : 0 : return NULL;
38089 : : }
38090 : : D(fprintf(stderr, "%*c> _tmp_236[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
38091 : : Token * _literal;
38092 [ # # ]: 0 : if (
38093 : 0 : (_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 : 0 : _res = _literal;
38098 : 0 : goto done;
38099 : : }
38100 : 0 : 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 [ # # ]: 0 : if (p->error_indicator) {
38106 : 0 : p->level--;
38107 : 0 : return NULL;
38108 : : }
38109 : : D(fprintf(stderr, "%*c> _tmp_236[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
38110 : : Token * _literal;
38111 [ # # ]: 0 : if (
38112 : 0 : (_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 : 0 : _res = _literal;
38117 : 0 : goto done;
38118 : : }
38119 : 0 : 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 : 0 : _res = NULL;
38124 : 0 : done:
38125 : 0 : p->level--;
38126 : 0 : return _res;
38127 : : }
38128 : :
38129 : : // _tmp_237: expression ['as' star_target]
38130 : : static void *
38131 : 14 : _tmp_237_rule(Parser *p)
38132 : : {
38133 [ - + ]: 14 : if (p->level++ == MAXSTACK) {
38134 : 0 : p->error_indicator = 1;
38135 : : PyErr_NoMemory();
38136 : : }
38137 [ - + ]: 14 : if (p->error_indicator) {
38138 : 0 : p->level--;
38139 : 0 : return NULL;
38140 : : }
38141 : 14 : void * _res = NULL;
38142 : 14 : int _mark = p->mark;
38143 : : { // expression ['as' star_target]
38144 [ - + ]: 14 : if (p->error_indicator) {
38145 : 0 : p->level--;
38146 : 0 : 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 [ + + ]: 14 : if (
38153 : 14 : (expression_var = expression_rule(p)) // expression
38154 : 10 : &&
38155 [ + - ]: 10 : (_opt_var = _tmp_244_rule(p), !p->error_indicator) // ['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 : 10 : _res = _PyPegen_dummy_name(p, expression_var, _opt_var);
38160 : 10 : goto done;
38161 : : }
38162 : 4 : 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 : 4 : _res = NULL;
38167 : 14 : done:
38168 : 14 : p->level--;
38169 : 14 : return _res;
38170 : : }
38171 : :
38172 : : // _tmp_238: expressions ['as' star_target]
38173 : : static void *
38174 : 4 : _tmp_238_rule(Parser *p)
38175 : : {
38176 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
38177 : 0 : p->error_indicator = 1;
38178 : : PyErr_NoMemory();
38179 : : }
38180 [ - + ]: 4 : if (p->error_indicator) {
38181 : 0 : p->level--;
38182 : 0 : return NULL;
38183 : : }
38184 : 4 : void * _res = NULL;
38185 : 4 : int _mark = p->mark;
38186 : : { // expressions ['as' star_target]
38187 [ - + ]: 4 : if (p->error_indicator) {
38188 : 0 : p->level--;
38189 : 0 : 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 [ + - ]: 4 : if (
38196 : 4 : (expressions_var = expressions_rule(p)) // expressions
38197 : 4 : &&
38198 [ + - ]: 4 : (_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 : 4 : _res = _PyPegen_dummy_name(p, expressions_var, _opt_var);
38203 : 4 : goto done;
38204 : : }
38205 : 0 : 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 : 0 : _res = NULL;
38210 : 4 : done:
38211 : 4 : p->level--;
38212 : 4 : return _res;
38213 : : }
38214 : :
38215 : : // _tmp_239: expression ['as' star_target]
38216 : : static void *
38217 : 35 : _tmp_239_rule(Parser *p)
38218 : : {
38219 [ - + ]: 35 : if (p->level++ == MAXSTACK) {
38220 : 0 : p->error_indicator = 1;
38221 : : PyErr_NoMemory();
38222 : : }
38223 [ - + ]: 35 : if (p->error_indicator) {
38224 : 0 : p->level--;
38225 : 0 : return NULL;
38226 : : }
38227 : 35 : void * _res = NULL;
38228 : 35 : int _mark = p->mark;
38229 : : { // expression ['as' star_target]
38230 [ - + ]: 35 : if (p->error_indicator) {
38231 : 0 : p->level--;
38232 : 0 : 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 [ + + ]: 35 : if (
38239 : 35 : (expression_var = expression_rule(p)) // expression
38240 : 28 : &&
38241 [ + - ]: 28 : (_opt_var = _tmp_246_rule(p), !p->error_indicator) // ['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 : 28 : _res = _PyPegen_dummy_name(p, expression_var, _opt_var);
38246 : 28 : goto done;
38247 : : }
38248 : 7 : 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 : 7 : _res = NULL;
38253 : 35 : done:
38254 : 35 : p->level--;
38255 : 35 : return _res;
38256 : : }
38257 : :
38258 : : // _tmp_240: expressions ['as' star_target]
38259 : : static void *
38260 : 9 : _tmp_240_rule(Parser *p)
38261 : : {
38262 [ - + ]: 9 : if (p->level++ == MAXSTACK) {
38263 : 0 : p->error_indicator = 1;
38264 : : PyErr_NoMemory();
38265 : : }
38266 [ - + ]: 9 : if (p->error_indicator) {
38267 : 0 : p->level--;
38268 : 0 : return NULL;
38269 : : }
38270 : 9 : void * _res = NULL;
38271 : 9 : int _mark = p->mark;
38272 : : { // expressions ['as' star_target]
38273 [ - + ]: 9 : if (p->error_indicator) {
38274 : 0 : p->level--;
38275 : 0 : 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 [ + - ]: 9 : if (
38282 : 9 : (expressions_var = expressions_rule(p)) // expressions
38283 : 9 : &&
38284 [ + - ]: 9 : (_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 : 9 : _res = _PyPegen_dummy_name(p, expressions_var, _opt_var);
38289 : 9 : goto done;
38290 : : }
38291 : 0 : 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 : 0 : _res = NULL;
38296 : 9 : done:
38297 : 9 : p->level--;
38298 : 9 : return _res;
38299 : : }
38300 : :
38301 : : // _tmp_241: except_block+ except_star_block
38302 : : static void *
38303 : 49 : _tmp_241_rule(Parser *p)
38304 : : {
38305 [ - + ]: 49 : if (p->level++ == MAXSTACK) {
38306 : 0 : p->error_indicator = 1;
38307 : : PyErr_NoMemory();
38308 : : }
38309 [ - + ]: 49 : if (p->error_indicator) {
38310 : 0 : p->level--;
38311 : 0 : return NULL;
38312 : : }
38313 : 49 : void * _res = NULL;
38314 : 49 : int _mark = p->mark;
38315 : : { // except_block+ except_star_block
38316 [ - + ]: 49 : if (p->error_indicator) {
38317 : 0 : p->level--;
38318 : 0 : 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 [ + + ]: 49 : if (
38324 : 49 : (_loop1_248_var = _loop1_248_rule(p)) // except_block+
38325 [ + + ]: 6 : &&
38326 : 6 : (except_star_block_var = except_star_block_rule(p)) // 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 : 5 : _res = _PyPegen_dummy_name(p, _loop1_248_var, except_star_block_var);
38331 : 5 : goto done;
38332 : : }
38333 : 44 : 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 : 44 : _res = NULL;
38338 : 49 : done:
38339 : 49 : p->level--;
38340 : 49 : return _res;
38341 : : }
38342 : :
38343 : : // _tmp_242: except_star_block+ except_block
38344 : : static void *
38345 : 30 : _tmp_242_rule(Parser *p)
38346 : : {
38347 [ - + ]: 30 : if (p->level++ == MAXSTACK) {
38348 : 0 : p->error_indicator = 1;
38349 : : PyErr_NoMemory();
38350 : : }
38351 [ - + ]: 30 : if (p->error_indicator) {
38352 : 0 : p->level--;
38353 : 0 : return NULL;
38354 : : }
38355 : 30 : void * _res = NULL;
38356 : 30 : int _mark = p->mark;
38357 : : { // except_star_block+ except_block
38358 [ - + ]: 30 : if (p->error_indicator) {
38359 : 0 : p->level--;
38360 : 0 : 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 [ + + ]: 30 : if (
38366 : 30 : (_loop1_249_var = _loop1_249_rule(p)) // except_star_block+
38367 [ + + ]: 7 : &&
38368 : 7 : (except_block_var = except_block_rule(p)) // 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 : 6 : _res = _PyPegen_dummy_name(p, _loop1_249_var, except_block_var);
38373 : 6 : goto done;
38374 : : }
38375 : 24 : 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 : 24 : _res = NULL;
38380 : 30 : done:
38381 : 30 : p->level--;
38382 : 30 : return _res;
38383 : : }
38384 : :
38385 : : // _tmp_243: assignment_expression | expression !':='
38386 : : static void *
38387 : 2741094 : _tmp_243_rule(Parser *p)
38388 : : {
38389 [ - + ]: 2741094 : if (p->level++ == MAXSTACK) {
38390 : 0 : p->error_indicator = 1;
38391 : : PyErr_NoMemory();
38392 : : }
38393 [ - + ]: 2741094 : if (p->error_indicator) {
38394 : 0 : p->level--;
38395 : 0 : return NULL;
38396 : : }
38397 : 2741094 : void * _res = NULL;
38398 : 2741094 : int _mark = p->mark;
38399 : : { // assignment_expression
38400 [ - + ]: 2741094 : if (p->error_indicator) {
38401 : 0 : p->level--;
38402 : 0 : 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 [ + + ]: 2741094 : if (
38407 : 2741094 : (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
38408 : : )
38409 : : {
38410 : : D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
38411 : 33 : _res = assignment_expression_var;
38412 : 33 : goto done;
38413 : : }
38414 : 2741061 : 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 [ + + ]: 2741061 : if (p->error_indicator) {
38420 : 6 : p->level--;
38421 : 6 : 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 [ + + ]: 2741055 : if (
38426 : 2741055 : (expression_var = expression_rule(p)) // expression
38427 [ + - ]: 2183034 : &&
38428 : 2183034 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
38429 : : )
38430 : : {
38431 : : D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
38432 : 2183034 : _res = expression_var;
38433 : 2183034 : goto done;
38434 : : }
38435 : 558021 : 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 : 558021 : _res = NULL;
38440 : 2741088 : done:
38441 : 2741088 : p->level--;
38442 : 2741088 : return _res;
38443 : : }
38444 : :
38445 : : // _tmp_244: 'as' star_target
38446 : : static void *
38447 : 10 : _tmp_244_rule(Parser *p)
38448 : : {
38449 [ - + ]: 10 : if (p->level++ == MAXSTACK) {
38450 : 0 : p->error_indicator = 1;
38451 : : PyErr_NoMemory();
38452 : : }
38453 [ - + ]: 10 : if (p->error_indicator) {
38454 : 0 : p->level--;
38455 : 0 : return NULL;
38456 : : }
38457 : 10 : void * _res = NULL;
38458 : 10 : int _mark = p->mark;
38459 : : { // 'as' star_target
38460 [ - + ]: 10 : if (p->error_indicator) {
38461 : 0 : p->level--;
38462 : 0 : 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 [ + + ]: 10 : if (
38468 : 10 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
38469 [ + - ]: 4 : &&
38470 : 4 : (star_target_var = star_target_rule(p)) // 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 : 4 : _res = _PyPegen_dummy_name(p, _keyword, star_target_var);
38475 : 4 : goto done;
38476 : : }
38477 : 6 : 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 : 6 : _res = NULL;
38482 : 10 : done:
38483 : 10 : p->level--;
38484 : 10 : return _res;
38485 : : }
38486 : :
38487 : : // _tmp_245: 'as' star_target
38488 : : static void *
38489 : 4 : _tmp_245_rule(Parser *p)
38490 : : {
38491 [ - + ]: 4 : if (p->level++ == MAXSTACK) {
38492 : 0 : p->error_indicator = 1;
38493 : : PyErr_NoMemory();
38494 : : }
38495 [ - + ]: 4 : if (p->error_indicator) {
38496 : 0 : p->level--;
38497 : 0 : return NULL;
38498 : : }
38499 : 4 : void * _res = NULL;
38500 : 4 : int _mark = p->mark;
38501 : : { // 'as' star_target
38502 [ - + ]: 4 : if (p->error_indicator) {
38503 : 0 : p->level--;
38504 : 0 : 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 [ + + ]: 4 : if (
38510 : 4 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
38511 [ + - ]: 3 : &&
38512 : 3 : (star_target_var = star_target_rule(p)) // 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 : 3 : _res = _PyPegen_dummy_name(p, _keyword, star_target_var);
38517 : 3 : goto done;
38518 : : }
38519 : 1 : 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 : 1 : _res = NULL;
38524 : 4 : done:
38525 : 4 : p->level--;
38526 : 4 : return _res;
38527 : : }
38528 : :
38529 : : // _tmp_246: 'as' star_target
38530 : : static void *
38531 : 28 : _tmp_246_rule(Parser *p)
38532 : : {
38533 [ - + ]: 28 : if (p->level++ == MAXSTACK) {
38534 : 0 : p->error_indicator = 1;
38535 : : PyErr_NoMemory();
38536 : : }
38537 [ - + ]: 28 : if (p->error_indicator) {
38538 : 0 : p->level--;
38539 : 0 : return NULL;
38540 : : }
38541 : 28 : void * _res = NULL;
38542 : 28 : int _mark = p->mark;
38543 : : { // 'as' star_target
38544 [ - + ]: 28 : if (p->error_indicator) {
38545 : 0 : p->level--;
38546 : 0 : 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 [ + + ]: 28 : if (
38552 : 28 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
38553 [ + + ]: 20 : &&
38554 : 20 : (star_target_var = star_target_rule(p)) // 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 : 11 : _res = _PyPegen_dummy_name(p, _keyword, star_target_var);
38559 : 11 : goto done;
38560 : : }
38561 : 17 : 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 : 17 : _res = NULL;
38566 : 28 : done:
38567 : 28 : p->level--;
38568 : 28 : return _res;
38569 : : }
38570 : :
38571 : : // _tmp_247: 'as' star_target
38572 : : static void *
38573 : 9 : _tmp_247_rule(Parser *p)
38574 : : {
38575 [ - + ]: 9 : if (p->level++ == MAXSTACK) {
38576 : 0 : p->error_indicator = 1;
38577 : : PyErr_NoMemory();
38578 : : }
38579 [ - + ]: 9 : if (p->error_indicator) {
38580 : 0 : p->level--;
38581 : 0 : return NULL;
38582 : : }
38583 : 9 : void * _res = NULL;
38584 : 9 : int _mark = p->mark;
38585 : : { // 'as' star_target
38586 [ - + ]: 9 : if (p->error_indicator) {
38587 : 0 : p->level--;
38588 : 0 : 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 [ + + ]: 9 : if (
38594 : 9 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
38595 [ + - ]: 7 : &&
38596 : 7 : (star_target_var = star_target_rule(p)) // 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 : 7 : _res = _PyPegen_dummy_name(p, _keyword, star_target_var);
38601 : 7 : goto done;
38602 : : }
38603 : 2 : 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 : 2 : _res = NULL;
38608 : 9 : done:
38609 : 9 : p->level--;
38610 : 9 : return _res;
38611 : : }
38612 : :
38613 : : // _loop1_248: except_block
38614 : : static asdl_seq *
38615 : 49 : _loop1_248_rule(Parser *p)
38616 : : {
38617 [ - + ]: 49 : if (p->level++ == MAXSTACK) {
38618 : 0 : p->error_indicator = 1;
38619 : : PyErr_NoMemory();
38620 : : }
38621 [ - + ]: 49 : if (p->error_indicator) {
38622 : 0 : p->level--;
38623 : 0 : return NULL;
38624 : : }
38625 : 49 : void *_res = NULL;
38626 : 49 : int _mark = p->mark;
38627 : 49 : int _start_mark = p->mark;
38628 : 49 : void **_children = PyMem_Malloc(sizeof(void *));
38629 [ - + ]: 49 : if (!_children) {
38630 : 0 : p->error_indicator = 1;
38631 : : PyErr_NoMemory();
38632 : 0 : p->level--;
38633 : 0 : return NULL;
38634 : : }
38635 : 49 : Py_ssize_t _children_capacity = 1;
38636 : 49 : Py_ssize_t _n = 0;
38637 : : { // except_block
38638 [ - + ]: 49 : if (p->error_indicator) {
38639 : 0 : p->level--;
38640 : 0 : 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 : 49 : while (
38645 [ + + ]: 57 : (except_block_var = except_block_rule(p)) // except_block
38646 : : )
38647 : : {
38648 : 8 : _res = except_block_var;
38649 [ + + ]: 8 : if (_n == _children_capacity) {
38650 : 1 : _children_capacity *= 2;
38651 : 1 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38652 [ - + ]: 1 : if (!_new_children) {
38653 : 0 : p->error_indicator = 1;
38654 : : PyErr_NoMemory();
38655 : 0 : p->level--;
38656 : 0 : return NULL;
38657 : : }
38658 : 1 : _children = _new_children;
38659 : : }
38660 : 8 : _children[_n++] = _res;
38661 : 8 : _mark = p->mark;
38662 : : }
38663 : 49 : 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 [ + + + + ]: 49 : if (_n == 0 || p->error_indicator) {
38668 : 43 : PyMem_Free(_children);
38669 : 43 : p->level--;
38670 : 43 : return NULL;
38671 : : }
38672 : 6 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38673 [ - + ]: 6 : if (!_seq) {
38674 : 0 : PyMem_Free(_children);
38675 : 0 : p->error_indicator = 1;
38676 : : PyErr_NoMemory();
38677 : 0 : p->level--;
38678 : 0 : return NULL;
38679 : : }
38680 [ + + ]: 13 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38681 : 6 : PyMem_Free(_children);
38682 : 6 : _PyPegen_insert_memo(p, _start_mark, _loop1_248_type, _seq);
38683 : 6 : p->level--;
38684 : 6 : return _seq;
38685 : : }
38686 : :
38687 : : // _loop1_249: except_star_block
38688 : : static asdl_seq *
38689 : 30 : _loop1_249_rule(Parser *p)
38690 : : {
38691 [ - + ]: 30 : if (p->level++ == MAXSTACK) {
38692 : 0 : p->error_indicator = 1;
38693 : : PyErr_NoMemory();
38694 : : }
38695 [ - + ]: 30 : if (p->error_indicator) {
38696 : 0 : p->level--;
38697 : 0 : return NULL;
38698 : : }
38699 : 30 : void *_res = NULL;
38700 : 30 : int _mark = p->mark;
38701 : 30 : int _start_mark = p->mark;
38702 : 30 : void **_children = PyMem_Malloc(sizeof(void *));
38703 [ - + ]: 30 : if (!_children) {
38704 : 0 : p->error_indicator = 1;
38705 : : PyErr_NoMemory();
38706 : 0 : p->level--;
38707 : 0 : return NULL;
38708 : : }
38709 : 30 : Py_ssize_t _children_capacity = 1;
38710 : 30 : Py_ssize_t _n = 0;
38711 : : { // except_star_block
38712 [ - + ]: 30 : if (p->error_indicator) {
38713 : 0 : p->level--;
38714 : 0 : 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 : 30 : while (
38719 [ + + ]: 39 : (except_star_block_var = except_star_block_rule(p)) // except_star_block
38720 : : )
38721 : : {
38722 : 9 : _res = except_star_block_var;
38723 [ + + ]: 9 : if (_n == _children_capacity) {
38724 : 1 : _children_capacity *= 2;
38725 : 1 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38726 [ - + ]: 1 : if (!_new_children) {
38727 : 0 : p->error_indicator = 1;
38728 : : PyErr_NoMemory();
38729 : 0 : p->level--;
38730 : 0 : return NULL;
38731 : : }
38732 : 1 : _children = _new_children;
38733 : : }
38734 : 9 : _children[_n++] = _res;
38735 : 9 : _mark = p->mark;
38736 : : }
38737 : 30 : 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 [ + + + + ]: 30 : if (_n == 0 || p->error_indicator) {
38742 : 23 : PyMem_Free(_children);
38743 : 23 : p->level--;
38744 : 23 : return NULL;
38745 : : }
38746 : 7 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38747 [ - + ]: 7 : if (!_seq) {
38748 : 0 : PyMem_Free(_children);
38749 : 0 : p->error_indicator = 1;
38750 : : PyErr_NoMemory();
38751 : 0 : p->level--;
38752 : 0 : return NULL;
38753 : : }
38754 [ + + ]: 15 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38755 : 7 : PyMem_Free(_children);
38756 : 7 : _PyPegen_insert_memo(p, _start_mark, _loop1_249_type, _seq);
38757 : 7 : p->level--;
38758 : 7 : return _seq;
38759 : : }
38760 : :
38761 : : void *
38762 : 224226 : _PyPegen_parse(Parser *p)
38763 : : {
38764 : : // Initialize keywords
38765 : 224226 : p->keywords = reserved_keywords;
38766 : 224226 : p->n_keyword_lists = n_keyword_lists;
38767 : 224226 : p->soft_keywords = soft_keywords;
38768 : :
38769 : : // Run parser
38770 : 224226 : void *result = NULL;
38771 [ + + ]: 224226 : if (p->start_rule == Py_file_input) {
38772 : 49245 : result = file_rule(p);
38773 [ + + ]: 174981 : } else if (p->start_rule == Py_single_input) {
38774 : 5077 : result = interactive_rule(p);
38775 [ + + ]: 169904 : } else if (p->start_rule == Py_eval_input) {
38776 : 73802 : result = eval_rule(p);
38777 [ + + ]: 96102 : } else if (p->start_rule == Py_func_type_input) {
38778 : 18 : result = func_type_rule(p);
38779 [ + - ]: 96084 : } else if (p->start_rule == Py_fstring_input) {
38780 : 96084 : result = fstring_rule(p);
38781 : : }
38782 : :
38783 : 224226 : return result;
38784 : : }
|
