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 49568 : file_rule(Parser *p)
1042 : {
1043 49568 : if (p->level++ == MAXSTACK) {
1044 0 : p->error_indicator = 1;
1045 0 : PyErr_NoMemory();
1046 : }
1047 49568 : if (p->error_indicator) {
1048 182 : p->level--;
1049 182 : return NULL;
1050 : }
1051 49386 : mod_ty _res = NULL;
1052 49386 : int _mark = p->mark;
1053 : { // statements? $
1054 49386 : if (p->error_indicator) {
1055 0 : p->level--;
1056 0 : return NULL;
1057 : }
1058 49386 : D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $"));
1059 : void *a;
1060 : Token * endmarker_var;
1061 49386 : if (
1062 49386 : (a = statements_rule(p), !p->error_indicator) // statements?
1063 49006 : &&
1064 49006 : (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1065 : )
1066 : {
1067 48204 : D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements? $"));
1068 48204 : _res = _PyPegen_make_module ( p , a );
1069 48204 : if (_res == NULL && PyErr_Occurred()) {
1070 0 : p->error_indicator = 1;
1071 0 : p->level--;
1072 0 : return NULL;
1073 : }
1074 48204 : goto done;
1075 : }
1076 1182 : p->mark = _mark;
1077 1182 : D(fprintf(stderr, "%*c%s file[%d-%d]: %s failed!\n", p->level, ' ',
1078 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statements? $"));
1079 : }
1080 1182 : _res = NULL;
1081 49386 : done:
1082 49386 : p->level--;
1083 49386 : return _res;
1084 : }
1085 :
1086 : // interactive: statement_newline
1087 : static mod_ty
1088 5080 : interactive_rule(Parser *p)
1089 : {
1090 5080 : if (p->level++ == MAXSTACK) {
1091 0 : p->error_indicator = 1;
1092 0 : PyErr_NoMemory();
1093 : }
1094 5080 : if (p->error_indicator) {
1095 17 : p->level--;
1096 17 : return NULL;
1097 : }
1098 5063 : mod_ty _res = NULL;
1099 5063 : int _mark = p->mark;
1100 : { // statement_newline
1101 5063 : if (p->error_indicator) {
1102 0 : p->level--;
1103 0 : return NULL;
1104 : }
1105 5063 : D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newline"));
1106 : asdl_stmt_seq* a;
1107 5063 : if (
1108 5063 : (a = statement_newline_rule(p)) // statement_newline
1109 : )
1110 : {
1111 4163 : D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement_newline"));
1112 4163 : _res = _PyAST_Interactive ( a , p -> arena );
1113 4163 : if (_res == NULL && PyErr_Occurred()) {
1114 0 : p->error_indicator = 1;
1115 0 : p->level--;
1116 0 : return NULL;
1117 : }
1118 4163 : goto done;
1119 : }
1120 900 : p->mark = _mark;
1121 900 : 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 5063 : done:
1126 5063 : p->level--;
1127 5063 : return _res;
1128 : }
1129 :
1130 : // eval: expressions NEWLINE* $
1131 : static mod_ty
1132 75155 : eval_rule(Parser *p)
1133 : {
1134 75155 : if (p->level++ == MAXSTACK) {
1135 0 : p->error_indicator = 1;
1136 0 : PyErr_NoMemory();
1137 : }
1138 75155 : if (p->error_indicator) {
1139 848 : p->level--;
1140 848 : return NULL;
1141 : }
1142 74307 : mod_ty _res = NULL;
1143 74307 : int _mark = p->mark;
1144 : { // expressions NEWLINE* $
1145 74307 : if (p->error_indicator) {
1146 0 : p->level--;
1147 0 : return NULL;
1148 : }
1149 74307 : 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 74307 : if (
1154 74307 : (a = expressions_rule(p)) // expressions
1155 73421 : &&
1156 73421 : (_loop0_1_var = _loop0_1_rule(p)) // NEWLINE*
1157 73421 : &&
1158 73421 : (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1159 : )
1160 : {
1161 73257 : D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));
1162 73257 : _res = _PyAST_Expression ( a , p -> arena );
1163 73257 : if (_res == NULL && PyErr_Occurred()) {
1164 0 : p->error_indicator = 1;
1165 0 : p->level--;
1166 0 : return NULL;
1167 : }
1168 73257 : goto done;
1169 : }
1170 1050 : p->mark = _mark;
1171 1050 : 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 74307 : done:
1176 74307 : p->level--;
1177 74307 : 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 0 : 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 18 : 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 12 : 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 6 : 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 96126 : fstring_rule(Parser *p)
1245 : {
1246 96126 : if (p->level++ == MAXSTACK) {
1247 0 : p->error_indicator = 1;
1248 0 : PyErr_NoMemory();
1249 : }
1250 96126 : if (p->error_indicator) {
1251 4 : p->level--;
1252 4 : return NULL;
1253 : }
1254 96122 : expr_ty _res = NULL;
1255 96122 : int _mark = p->mark;
1256 : { // star_expressions
1257 96122 : if (p->error_indicator) {
1258 0 : p->level--;
1259 0 : return NULL;
1260 : }
1261 96122 : D(fprintf(stderr, "%*c> fstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
1262 : expr_ty star_expressions_var;
1263 96122 : if (
1264 96122 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
1265 : )
1266 : {
1267 96094 : D(fprintf(stderr, "%*c+ fstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
1268 96094 : _res = star_expressions_var;
1269 96094 : goto done;
1270 : }
1271 28 : p->mark = _mark;
1272 28 : 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 96122 : done:
1277 96122 : p->level--;
1278 96122 : return _res;
1279 : }
1280 :
1281 : // statements: statement+
1282 : static asdl_stmt_seq*
1283 1045380 : statements_rule(Parser *p)
1284 : {
1285 1045380 : if (p->level++ == MAXSTACK) {
1286 0 : p->error_indicator = 1;
1287 0 : PyErr_NoMemory();
1288 : }
1289 1045380 : if (p->error_indicator) {
1290 0 : p->level--;
1291 0 : return NULL;
1292 : }
1293 1045380 : asdl_stmt_seq* _res = NULL;
1294 1045380 : int _mark = p->mark;
1295 : { // statement+
1296 1045380 : if (p->error_indicator) {
1297 0 : p->level--;
1298 0 : return NULL;
1299 : }
1300 1045380 : D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+"));
1301 : asdl_seq * a;
1302 1045380 : if (
1303 1045380 : (a = _loop1_3_rule(p)) // statement+
1304 : )
1305 : {
1306 1043400 : D(fprintf(stderr, "%*c+ statements[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement+"));
1307 1043400 : _res = ( asdl_stmt_seq* ) _PyPegen_seq_flatten ( p , a );
1308 1043400 : if (_res == NULL && PyErr_Occurred()) {
1309 0 : p->error_indicator = 1;
1310 0 : p->level--;
1311 0 : return NULL;
1312 : }
1313 1043400 : goto done;
1314 : }
1315 1979 : p->mark = _mark;
1316 1979 : D(fprintf(stderr, "%*c%s statements[%d-%d]: %s failed!\n", p->level, ' ',
1317 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement+"));
1318 : }
1319 1979 : _res = NULL;
1320 1045380 : done:
1321 1045380 : p->level--;
1322 1045380 : return _res;
1323 : }
1324 :
1325 : // statement: compound_stmt | simple_stmts
1326 : static asdl_stmt_seq*
1327 4057380 : statement_rule(Parser *p)
1328 : {
1329 4057380 : if (p->level++ == MAXSTACK) {
1330 0 : p->error_indicator = 1;
1331 0 : PyErr_NoMemory();
1332 : }
1333 4057380 : if (p->error_indicator) {
1334 0 : p->level--;
1335 0 : return NULL;
1336 : }
1337 4057380 : asdl_stmt_seq* _res = NULL;
1338 4057380 : int _mark = p->mark;
1339 : { // compound_stmt
1340 4057380 : if (p->error_indicator) {
1341 0 : p->level--;
1342 0 : return NULL;
1343 : }
1344 4057380 : D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt"));
1345 : stmt_ty a;
1346 4057380 : if (
1347 4057380 : (a = compound_stmt_rule(p)) // compound_stmt
1348 : )
1349 : {
1350 1050740 : D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt"));
1351 1050740 : _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a );
1352 1050740 : if (_res == NULL && PyErr_Occurred()) {
1353 0 : p->error_indicator = 1;
1354 0 : p->level--;
1355 0 : return NULL;
1356 : }
1357 1050740 : goto done;
1358 : }
1359 3006640 : p->mark = _mark;
1360 3006640 : 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 3006640 : if (p->error_indicator) {
1365 185 : p->level--;
1366 185 : return NULL;
1367 : }
1368 3006450 : D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1369 : asdl_stmt_seq* a;
1370 3006450 : if (
1371 3006450 : (a = (asdl_stmt_seq*)simple_stmts_rule(p)) // simple_stmts
1372 : )
1373 : {
1374 1961260 : D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1375 1961260 : _res = a;
1376 1961260 : if (_res == NULL && PyErr_Occurred()) {
1377 0 : p->error_indicator = 1;
1378 0 : p->level--;
1379 0 : return NULL;
1380 : }
1381 1961260 : goto done;
1382 : }
1383 1045190 : p->mark = _mark;
1384 1045190 : 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 1045190 : _res = NULL;
1388 4057190 : done:
1389 4057190 : p->level--;
1390 4057190 : return _res;
1391 : }
1392 :
1393 : // statement_newline: compound_stmt NEWLINE | simple_stmts | NEWLINE | $
1394 : static asdl_stmt_seq*
1395 5063 : statement_newline_rule(Parser *p)
1396 : {
1397 5063 : if (p->level++ == MAXSTACK) {
1398 0 : p->error_indicator = 1;
1399 0 : PyErr_NoMemory();
1400 : }
1401 5063 : if (p->error_indicator) {
1402 0 : p->level--;
1403 0 : return NULL;
1404 : }
1405 5063 : asdl_stmt_seq* _res = NULL;
1406 5063 : int _mark = p->mark;
1407 5063 : 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 5063 : int _start_lineno = p->tokens[_mark]->lineno;
1413 : UNUSED(_start_lineno); // Only used by EXTRA macro
1414 5063 : int _start_col_offset = p->tokens[_mark]->col_offset;
1415 : UNUSED(_start_col_offset); // Only used by EXTRA macro
1416 : { // compound_stmt NEWLINE
1417 5063 : if (p->error_indicator) {
1418 0 : p->level--;
1419 0 : return NULL;
1420 : }
1421 5063 : 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 5063 : if (
1425 5063 : (a = compound_stmt_rule(p)) // compound_stmt
1426 628 : &&
1427 628 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1428 : )
1429 : {
1430 596 : 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 4467 : p->mark = _mark;
1440 4467 : 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 4467 : if (p->error_indicator) {
1445 159 : p->level--;
1446 159 : return NULL;
1447 : }
1448 4308 : 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 4308 : if (
1451 4308 : (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts
1452 : )
1453 : {
1454 3565 : D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1455 3565 : _res = simple_stmts_var;
1456 3565 : goto done;
1457 : }
1458 743 : p->mark = _mark;
1459 743 : 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 498 : 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 2 : 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 496 : 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 496 : 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 14 : 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 482 : 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 4659 : done:
1521 4659 : p->level--;
1522 4659 : return _res;
1523 : }
1524 :
1525 : // simple_stmts: simple_stmt !';' NEWLINE | ';'.simple_stmt+ ';'? NEWLINE
1526 : static asdl_stmt_seq*
1527 3222740 : simple_stmts_rule(Parser *p)
1528 : {
1529 3222740 : if (p->level++ == MAXSTACK) {
1530 0 : p->error_indicator = 1;
1531 0 : PyErr_NoMemory();
1532 : }
1533 3222740 : if (p->error_indicator) {
1534 0 : p->level--;
1535 0 : return NULL;
1536 : }
1537 3222740 : asdl_stmt_seq* _res = NULL;
1538 3222740 : int _mark = p->mark;
1539 : { // simple_stmt !';' NEWLINE
1540 3222740 : if (p->error_indicator) {
1541 0 : p->level--;
1542 0 : return NULL;
1543 : }
1544 3222740 : 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 3222740 : if (
1548 3222740 : (a = simple_stmt_rule(p)) // simple_stmt
1549 2177010 : &&
1550 2177010 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13) // token=';'
1551 2174880 : &&
1552 2174880 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1553 : )
1554 : {
1555 2174330 : D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt !';' NEWLINE"));
1556 2174330 : _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a );
1557 2174330 : if (_res == NULL && PyErr_Occurred()) {
1558 0 : p->error_indicator = 1;
1559 0 : p->level--;
1560 0 : return NULL;
1561 : }
1562 2174330 : goto done;
1563 : }
1564 1048400 : p->mark = _mark;
1565 1048400 : 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 1048400 : if (p->error_indicator) {
1570 475 : p->level--;
1571 475 : return NULL;
1572 : }
1573 1047930 : 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 1047930 : if (
1579 1047930 : (a = (asdl_stmt_seq*)_gather_4_rule(p)) // ';'.simple_stmt+
1580 2679 : &&
1581 2679 : (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'?
1582 2677 : &&
1583 2677 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1584 : )
1585 : {
1586 2119 : D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE"));
1587 2119 : _res = a;
1588 2119 : if (_res == NULL && PyErr_Occurred()) {
1589 0 : p->error_indicator = 1;
1590 0 : p->level--;
1591 0 : return NULL;
1592 : }
1593 2119 : goto done;
1594 : }
1595 1045810 : p->mark = _mark;
1596 1045810 : 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 1045810 : _res = NULL;
1600 3222260 : done:
1601 3222260 : p->level--;
1602 3222260 : 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 4278360 : simple_stmt_rule(Parser *p)
1621 : {
1622 4278360 : if (p->level++ == MAXSTACK) {
1623 0 : p->error_indicator = 1;
1624 0 : PyErr_NoMemory();
1625 : }
1626 4278360 : if (p->error_indicator) {
1627 0 : p->level--;
1628 0 : return NULL;
1629 : }
1630 4278360 : stmt_ty _res = NULL;
1631 4278360 : if (_PyPegen_is_memoized(p, simple_stmt_type, &_res)) {
1632 1047930 : p->level--;
1633 1047930 : return _res;
1634 : }
1635 3230430 : int _mark = p->mark;
1636 3230430 : 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 3230430 : int _start_lineno = p->tokens[_mark]->lineno;
1642 : UNUSED(_start_lineno); // Only used by EXTRA macro
1643 3230430 : int _start_col_offset = p->tokens[_mark]->col_offset;
1644 : UNUSED(_start_col_offset); // Only used by EXTRA macro
1645 : { // assignment
1646 3230430 : if (p->error_indicator) {
1647 0 : p->level--;
1648 0 : return NULL;
1649 : }
1650 3230430 : D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment"));
1651 : stmt_ty assignment_var;
1652 3230430 : if (
1653 3230430 : (assignment_var = assignment_rule(p)) // assignment
1654 : )
1655 : {
1656 845056 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment"));
1657 845056 : _res = assignment_var;
1658 845056 : goto done;
1659 : }
1660 2385380 : p->mark = _mark;
1661 2385380 : 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 2385380 : if (p->error_indicator) {
1666 411 : p->level--;
1667 411 : return NULL;
1668 : }
1669 2384960 : D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
1670 : expr_ty e;
1671 2384960 : if (
1672 2384960 : (e = star_expressions_rule(p)) // star_expressions
1673 : )
1674 : {
1675 862754 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
1676 862754 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1677 862754 : if (_token == NULL) {
1678 0 : p->level--;
1679 0 : return NULL;
1680 : }
1681 862754 : int _end_lineno = _token->end_lineno;
1682 : UNUSED(_end_lineno); // Only used by EXTRA macro
1683 862754 : int _end_col_offset = _token->end_col_offset;
1684 : UNUSED(_end_col_offset); // Only used by EXTRA macro
1685 862754 : _res = _PyAST_Expr ( e , EXTRA );
1686 862754 : if (_res == NULL && PyErr_Occurred()) {
1687 0 : p->error_indicator = 1;
1688 0 : p->level--;
1689 0 : return NULL;
1690 : }
1691 862754 : goto done;
1692 : }
1693 1522210 : p->mark = _mark;
1694 1522210 : 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 1522210 : if (p->error_indicator) {
1699 14 : p->level--;
1700 14 : return NULL;
1701 : }
1702 1522200 : 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 1522200 : if (
1705 1522200 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 519) // token='return'
1706 241295 : &&
1707 241295 : (return_stmt_var = return_stmt_rule(p)) // return_stmt
1708 : )
1709 : {
1710 241294 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt"));
1711 241294 : _res = return_stmt_var;
1712 241294 : goto done;
1713 : }
1714 1280900 : p->mark = _mark;
1715 1280900 : 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 1280900 : if (p->error_indicator) {
1720 1 : p->level--;
1721 1 : return NULL;
1722 : }
1723 1280900 : 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 1280900 : if (
1726 1280900 : _PyPegen_lookahead(1, _tmp_6_rule, p)
1727 91360 : &&
1728 91360 : (import_stmt_var = import_stmt_rule(p)) // import_stmt
1729 : )
1730 : {
1731 91304 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt"));
1732 91304 : _res = import_stmt_var;
1733 91304 : goto done;
1734 : }
1735 1189600 : p->mark = _mark;
1736 1189600 : 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 1189600 : if (p->error_indicator) {
1741 21 : p->level--;
1742 21 : return NULL;
1743 : }
1744 1189580 : 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 1189580 : if (
1747 1189580 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 522) // token='raise'
1748 61395 : &&
1749 61395 : (raise_stmt_var = raise_stmt_rule(p)) // raise_stmt
1750 : )
1751 : {
1752 61395 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt"));
1753 61395 : _res = raise_stmt_var;
1754 61395 : goto done;
1755 : }
1756 1128180 : p->mark = _mark;
1757 1128180 : 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 1128180 : if (p->error_indicator) {
1762 0 : p->level--;
1763 0 : return NULL;
1764 : }
1765 1128180 : D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'"));
1766 : Token * _keyword;
1767 1128180 : if (
1768 1128180 : (_keyword = _PyPegen_expect_token(p, 504)) // token='pass'
1769 : )
1770 : {
1771 27351 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pass'"));
1772 27351 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1773 27351 : if (_token == NULL) {
1774 0 : p->level--;
1775 0 : return NULL;
1776 : }
1777 27351 : int _end_lineno = _token->end_lineno;
1778 : UNUSED(_end_lineno); // Only used by EXTRA macro
1779 27351 : int _end_col_offset = _token->end_col_offset;
1780 : UNUSED(_end_col_offset); // Only used by EXTRA macro
1781 27351 : _res = _PyAST_Pass ( EXTRA );
1782 27351 : if (_res == NULL && PyErr_Occurred()) {
1783 0 : p->error_indicator = 1;
1784 0 : p->level--;
1785 0 : return NULL;
1786 : }
1787 27351 : goto done;
1788 : }
1789 1100830 : p->mark = _mark;
1790 1100830 : 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 1100830 : if (p->error_indicator) {
1795 0 : p->level--;
1796 0 : return NULL;
1797 : }
1798 1100830 : 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 1100830 : if (
1801 1100830 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 603) // token='del'
1802 8979 : &&
1803 8979 : (del_stmt_var = del_stmt_rule(p)) // del_stmt
1804 : )
1805 : {
1806 8899 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt"));
1807 8899 : _res = del_stmt_var;
1808 8899 : goto done;
1809 : }
1810 1091930 : p->mark = _mark;
1811 1091930 : 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 1091930 : if (p->error_indicator) {
1816 30 : p->level--;
1817 30 : return NULL;
1818 : }
1819 1091900 : 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 1091900 : if (
1822 1091900 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 573) // token='yield'
1823 15365 : &&
1824 15365 : (yield_stmt_var = yield_stmt_rule(p)) // yield_stmt
1825 : )
1826 : {
1827 15365 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt"));
1828 15365 : _res = yield_stmt_var;
1829 15365 : goto done;
1830 : }
1831 1076540 : p->mark = _mark;
1832 1076540 : 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 1076540 : if (p->error_indicator) {
1837 0 : p->level--;
1838 0 : return NULL;
1839 : }
1840 1076540 : 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 1076540 : if (
1843 1076540 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 526) // token='assert'
1844 9782 : &&
1845 9782 : (assert_stmt_var = assert_stmt_rule(p)) // assert_stmt
1846 : )
1847 : {
1848 9780 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt"));
1849 9780 : _res = assert_stmt_var;
1850 9780 : goto done;
1851 : }
1852 1066760 : p->mark = _mark;
1853 1066760 : 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 1066760 : if (p->error_indicator) {
1858 0 : p->level--;
1859 0 : return NULL;
1860 : }
1861 1066760 : D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'"));
1862 : Token * _keyword;
1863 1066760 : if (
1864 1066760 : (_keyword = _PyPegen_expect_token(p, 508)) // token='break'
1865 : )
1866 : {
1867 9899 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'break'"));
1868 9899 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1869 9899 : if (_token == NULL) {
1870 0 : p->level--;
1871 0 : return NULL;
1872 : }
1873 9899 : int _end_lineno = _token->end_lineno;
1874 : UNUSED(_end_lineno); // Only used by EXTRA macro
1875 9899 : int _end_col_offset = _token->end_col_offset;
1876 : UNUSED(_end_col_offset); // Only used by EXTRA macro
1877 9899 : _res = _PyAST_Break ( EXTRA );
1878 9899 : if (_res == NULL && PyErr_Occurred()) {
1879 0 : p->error_indicator = 1;
1880 0 : p->level--;
1881 0 : return NULL;
1882 : }
1883 9899 : goto done;
1884 : }
1885 1056860 : p->mark = _mark;
1886 1056860 : 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 1056860 : if (p->error_indicator) {
1891 0 : p->level--;
1892 0 : return NULL;
1893 : }
1894 1056860 : D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'"));
1895 : Token * _keyword;
1896 1056860 : if (
1897 1056860 : (_keyword = _PyPegen_expect_token(p, 509)) // token='continue'
1898 : )
1899 : {
1900 8710 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'continue'"));
1901 8710 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1902 8710 : if (_token == NULL) {
1903 0 : p->level--;
1904 0 : return NULL;
1905 : }
1906 8710 : int _end_lineno = _token->end_lineno;
1907 : UNUSED(_end_lineno); // Only used by EXTRA macro
1908 8710 : int _end_col_offset = _token->end_col_offset;
1909 : UNUSED(_end_col_offset); // Only used by EXTRA macro
1910 8710 : _res = _PyAST_Continue ( EXTRA );
1911 8710 : if (_res == NULL && PyErr_Occurred()) {
1912 0 : p->error_indicator = 1;
1913 0 : p->level--;
1914 0 : return NULL;
1915 : }
1916 8710 : goto done;
1917 : }
1918 1048150 : p->mark = _mark;
1919 1048150 : 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 1048150 : if (p->error_indicator) {
1924 0 : p->level--;
1925 0 : return NULL;
1926 : }
1927 1048150 : 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 1048150 : if (
1930 1048150 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 523) // token='global'
1931 1841 : &&
1932 1841 : (global_stmt_var = global_stmt_rule(p)) // global_stmt
1933 : )
1934 : {
1935 1839 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt"));
1936 1839 : _res = global_stmt_var;
1937 1839 : goto done;
1938 : }
1939 1046310 : p->mark = _mark;
1940 1046310 : 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 1046310 : if (p->error_indicator) {
1945 0 : p->level--;
1946 0 : return NULL;
1947 : }
1948 1046310 : 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 1046310 : if (
1951 1046310 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 524) // token='nonlocal'
1952 929 : &&
1953 929 : (nonlocal_stmt_var = nonlocal_stmt_rule(p)) // nonlocal_stmt
1954 : )
1955 : {
1956 927 : D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
1957 927 : _res = nonlocal_stmt_var;
1958 927 : goto done;
1959 : }
1960 1045380 : p->mark = _mark;
1961 1045380 : 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 1045380 : _res = NULL;
1965 3229960 : done:
1966 3229960 : _PyPegen_insert_memo(p, _mark, simple_stmt_type, _res);
1967 3229960 : p->level--;
1968 3229960 : 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 4062440 : compound_stmt_rule(Parser *p)
1982 : {
1983 4062440 : if (p->level++ == MAXSTACK) {
1984 0 : p->error_indicator = 1;
1985 0 : PyErr_NoMemory();
1986 : }
1987 4062440 : if (p->error_indicator) {
1988 0 : p->level--;
1989 0 : return NULL;
1990 : }
1991 4062440 : stmt_ty _res = NULL;
1992 4062440 : int _mark = p->mark;
1993 : { // &('def' | '@' | ASYNC) function_def
1994 4062440 : if (p->error_indicator) {
1995 0 : p->level--;
1996 0 : return NULL;
1997 : }
1998 4062440 : 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 4062440 : if (
2001 4062440 : _PyPegen_lookahead(1, _tmp_7_rule, p)
2002 346581 : &&
2003 346581 : (function_def_var = function_def_rule(p)) // function_def
2004 : )
2005 : {
2006 342386 : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def"));
2007 342386 : _res = function_def_var;
2008 342386 : goto done;
2009 : }
2010 3720060 : p->mark = _mark;
2011 3720060 : 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 3720060 : if (p->error_indicator) {
2016 204 : p->level--;
2017 204 : return NULL;
2018 : }
2019 3719850 : 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 3719850 : if (
2022 3719850 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 634) // token='if'
2023 489180 : &&
2024 489180 : (if_stmt_var = if_stmt_rule(p)) // if_stmt
2025 : )
2026 : {
2027 489089 : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt"));
2028 489089 : _res = if_stmt_var;
2029 489089 : goto done;
2030 : }
2031 3230760 : p->mark = _mark;
2032 3230760 : 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 3230760 : if (p->error_indicator) {
2037 30 : p->level--;
2038 30 : return NULL;
2039 : }
2040 3230730 : 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 3230730 : if (
2043 3230730 : _PyPegen_lookahead(1, _tmp_8_rule, p)
2044 56811 : &&
2045 56811 : (class_def_var = class_def_rule(p)) // class_def
2046 : )
2047 : {
2048 56770 : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def"));
2049 56770 : _res = class_def_var;
2050 56770 : goto done;
2051 : }
2052 3173960 : p->mark = _mark;
2053 3173960 : 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 3173960 : if (p->error_indicator) {
2058 8 : p->level--;
2059 8 : return NULL;
2060 : }
2061 3173960 : 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 3173960 : if (
2064 3173960 : _PyPegen_lookahead(1, _tmp_9_rule, p)
2065 39289 : &&
2066 39289 : (with_stmt_var = with_stmt_rule(p)) // with_stmt
2067 : )
2068 : {
2069 38954 : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt"));
2070 38954 : _res = with_stmt_var;
2071 38954 : goto done;
2072 : }
2073 3135000 : p->mark = _mark;
2074 3135000 : 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 3135000 : if (p->error_indicator) {
2079 27 : p->level--;
2080 27 : return NULL;
2081 : }
2082 3134970 : 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 3134970 : if (
2085 3134970 : _PyPegen_lookahead(1, _tmp_10_rule, p)
2086 61778 : &&
2087 61778 : (for_stmt_var = for_stmt_rule(p)) // for_stmt
2088 : )
2089 : {
2090 61651 : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt"));
2091 61651 : _res = for_stmt_var;
2092 61651 : goto done;
2093 : }
2094 3073320 : p->mark = _mark;
2095 3073320 : 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 3073320 : if (p->error_indicator) {
2100 17 : p->level--;
2101 17 : return NULL;
2102 : }
2103 3073310 : 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 3073310 : if (
2106 3073310 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 618) // token='try'
2107 49660 : &&
2108 49660 : (try_stmt_var = try_stmt_rule(p)) // try_stmt
2109 : )
2110 : {
2111 49563 : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt"));
2112 49563 : _res = try_stmt_var;
2113 49563 : goto done;
2114 : }
2115 3023740 : p->mark = _mark;
2116 3023740 : 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 3023740 : if (p->error_indicator) {
2121 35 : p->level--;
2122 35 : return NULL;
2123 : }
2124 3023710 : 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 3023710 : if (
2127 3023710 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 639) // token='while'
2128 11785 : &&
2129 11785 : (while_stmt_var = while_stmt_rule(p)) // while_stmt
2130 : )
2131 : {
2132 11737 : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt"));
2133 11737 : _res = while_stmt_var;
2134 11737 : goto done;
2135 : }
2136 3011970 : p->mark = _mark;
2137 3011970 : 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 3011970 : if (p->error_indicator) {
2142 4 : p->level--;
2143 4 : return NULL;
2144 : }
2145 3011970 : D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "match_stmt"));
2146 : stmt_ty match_stmt_var;
2147 3011970 : if (
2148 3011970 : (match_stmt_var = match_stmt_rule(p)) // match_stmt
2149 : )
2150 : {
2151 1218 : D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "match_stmt"));
2152 1218 : _res = match_stmt_var;
2153 1218 : goto done;
2154 : }
2155 3010750 : p->mark = _mark;
2156 3010750 : 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 3010750 : _res = NULL;
2160 4062120 : done:
2161 4062120 : p->level--;
2162 4062120 : 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 3230430 : assignment_rule(Parser *p)
2173 : {
2174 3230430 : if (p->level++ == MAXSTACK) {
2175 0 : p->error_indicator = 1;
2176 0 : PyErr_NoMemory();
2177 : }
2178 3230430 : if (p->error_indicator) {
2179 0 : p->level--;
2180 0 : return NULL;
2181 : }
2182 3230430 : stmt_ty _res = NULL;
2183 3230430 : int _mark = p->mark;
2184 3230430 : 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 3230430 : int _start_lineno = p->tokens[_mark]->lineno;
2190 : UNUSED(_start_lineno); // Only used by EXTRA macro
2191 3230430 : 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 3230430 : if (p->error_indicator) {
2195 0 : p->level--;
2196 0 : return NULL;
2197 : }
2198 3230430 : 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 3230430 : if (
2204 3230430 : (a = _PyPegen_name_token(p)) // NAME
2205 1581300 : &&
2206 1581300 : (_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 9486 : 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 3220950 : p->mark = _mark;
2232 3220950 : 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 3220950 : if (p->error_indicator) {
2237 3 : p->level--;
2238 3 : return NULL;
2239 : }
2240 3220940 : 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 3220940 : if (
2246 3220940 : (a = _tmp_12_rule(p)) // '(' single_target ')' | single_subscript_attribute_target
2247 178922 : &&
2248 178922 : (_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 1969 : 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 3218970 : p->mark = _mark;
2274 3218970 : 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 3218970 : if (p->error_indicator) {
2279 223 : p->level--;
2280 223 : return NULL;
2281 : }
2282 3218750 : 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 3218750 : if (
2287 3218750 : (a = (asdl_expr_seq*)_loop1_14_rule(p)) // ((star_targets '='))+
2288 807926 : &&
2289 807926 : (b = _tmp_15_rule(p)) // yield_expr | star_expressions
2290 807910 : &&
2291 807910 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='='
2292 807906 : &&
2293 807906 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
2294 : )
2295 : {
2296 807906 : D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
2297 807906 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2298 807906 : if (_token == NULL) {
2299 0 : p->level--;
2300 0 : return NULL;
2301 : }
2302 807906 : int _end_lineno = _token->end_lineno;
2303 : UNUSED(_end_lineno); // Only used by EXTRA macro
2304 807906 : int _end_col_offset = _token->end_col_offset;
2305 : UNUSED(_end_col_offset); // Only used by EXTRA macro
2306 807906 : _res = _PyAST_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
2307 807906 : if (_res == NULL && PyErr_Occurred()) {
2308 0 : p->error_indicator = 1;
2309 0 : p->level--;
2310 0 : return NULL;
2311 : }
2312 807906 : goto done;
2313 : }
2314 2410840 : p->mark = _mark;
2315 2410840 : 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 2410840 : if (p->error_indicator) {
2320 41 : p->level--;
2321 41 : return NULL;
2322 : }
2323 2410800 : D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
2324 2410800 : int _cut_var = 0;
2325 : expr_ty a;
2326 : AugOperator* b;
2327 : void *c;
2328 2410800 : if (
2329 2410800 : (a = single_target_rule(p)) // single_target
2330 763640 : &&
2331 763640 : (b = augassign_rule(p)) // augassign
2332 : &&
2333 25695 : (_cut_var = 1)
2334 25695 : &&
2335 25695 : (c = _tmp_16_rule(p)) // yield_expr | star_expressions
2336 : )
2337 : {
2338 25695 : D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
2339 25695 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2340 25695 : if (_token == NULL) {
2341 0 : p->level--;
2342 0 : return NULL;
2343 : }
2344 25695 : int _end_lineno = _token->end_lineno;
2345 : UNUSED(_end_lineno); // Only used by EXTRA macro
2346 25695 : int _end_col_offset = _token->end_col_offset;
2347 : UNUSED(_end_col_offset); // Only used by EXTRA macro
2348 25695 : _res = _PyAST_AugAssign ( a , b -> kind , c , EXTRA );
2349 25695 : if (_res == NULL && PyErr_Occurred()) {
2350 0 : p->error_indicator = 1;
2351 0 : p->level--;
2352 0 : return NULL;
2353 : }
2354 25695 : goto done;
2355 : }
2356 2385110 : p->mark = _mark;
2357 2385110 : 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 2385110 : if (_cut_var) {
2360 0 : p->level--;
2361 0 : return NULL;
2362 : }
2363 : }
2364 2385110 : if (p->call_invalid_rules) { // invalid_assignment
2365 901 : if (p->error_indicator) {
2366 0 : p->level--;
2367 0 : return NULL;
2368 : }
2369 901 : 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 0 : 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 901 : 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 2385110 : _res = NULL;
2384 3230160 : done:
2385 3230160 : p->level--;
2386 3230160 : return _res;
2387 : }
2388 :
2389 : // annotated_rhs: yield_expr | star_expressions
2390 : static expr_ty
2391 7608 : annotated_rhs_rule(Parser *p)
2392 : {
2393 7608 : if (p->level++ == MAXSTACK) {
2394 0 : p->error_indicator = 1;
2395 0 : PyErr_NoMemory();
2396 : }
2397 7608 : if (p->error_indicator) {
2398 0 : p->level--;
2399 0 : return NULL;
2400 : }
2401 7608 : expr_ty _res = NULL;
2402 7608 : int _mark = p->mark;
2403 : { // yield_expr
2404 7608 : if (p->error_indicator) {
2405 0 : p->level--;
2406 0 : return NULL;
2407 : }
2408 7608 : D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
2409 : expr_ty yield_expr_var;
2410 7608 : if (
2411 7608 : (yield_expr_var = yield_expr_rule(p)) // yield_expr
2412 : )
2413 : {
2414 1 : 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 7607 : p->mark = _mark;
2419 7607 : 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 7607 : if (p->error_indicator) {
2424 0 : p->level--;
2425 0 : return NULL;
2426 : }
2427 7607 : D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
2428 : expr_ty star_expressions_var;
2429 7607 : if (
2430 7607 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
2431 : )
2432 : {
2433 7607 : D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
2434 7607 : _res = star_expressions_var;
2435 7607 : goto done;
2436 : }
2437 0 : p->mark = _mark;
2438 0 : 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 7608 : done:
2443 7608 : p->level--;
2444 7608 : return _res;
2445 : }
2446 :
2447 : // augassign:
2448 : // | '+='
2449 : // | '-='
2450 : // | '*='
2451 : // | '@='
2452 : // | '/='
2453 : // | '%='
2454 : // | '&='
2455 : // | '|='
2456 : // | '^='
2457 : // | '<<='
2458 : // | '>>='
2459 : // | '**='
2460 : // | '//='
2461 : static AugOperator*
2462 763771 : augassign_rule(Parser *p)
2463 : {
2464 763771 : if (p->level++ == MAXSTACK) {
2465 0 : p->error_indicator = 1;
2466 0 : PyErr_NoMemory();
2467 : }
2468 763771 : if (p->error_indicator) {
2469 0 : p->level--;
2470 0 : return NULL;
2471 : }
2472 763771 : AugOperator* _res = NULL;
2473 763771 : int _mark = p->mark;
2474 : { // '+='
2475 763771 : if (p->error_indicator) {
2476 0 : p->level--;
2477 0 : return NULL;
2478 : }
2479 763771 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='"));
2480 : Token * _literal;
2481 763771 : if (
2482 763771 : (_literal = _PyPegen_expect_token(p, 36)) // token='+='
2483 : )
2484 : {
2485 18930 : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+='"));
2486 18930 : _res = _PyPegen_augoperator ( p , Add );
2487 18930 : if (_res == NULL && PyErr_Occurred()) {
2488 0 : p->error_indicator = 1;
2489 0 : p->level--;
2490 0 : return NULL;
2491 : }
2492 18930 : goto done;
2493 : }
2494 744841 : p->mark = _mark;
2495 744841 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2496 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='"));
2497 : }
2498 : { // '-='
2499 744841 : if (p->error_indicator) {
2500 0 : p->level--;
2501 0 : return NULL;
2502 : }
2503 744841 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='"));
2504 : Token * _literal;
2505 744841 : if (
2506 744841 : (_literal = _PyPegen_expect_token(p, 37)) // token='-='
2507 : )
2508 : {
2509 2712 : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-='"));
2510 2712 : _res = _PyPegen_augoperator ( p , Sub );
2511 2712 : if (_res == NULL && PyErr_Occurred()) {
2512 0 : p->error_indicator = 1;
2513 0 : p->level--;
2514 0 : return NULL;
2515 : }
2516 2712 : goto done;
2517 : }
2518 742129 : p->mark = _mark;
2519 742129 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2520 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='"));
2521 : }
2522 : { // '*='
2523 742129 : if (p->error_indicator) {
2524 0 : p->level--;
2525 0 : return NULL;
2526 : }
2527 742129 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='"));
2528 : Token * _literal;
2529 742129 : if (
2530 742129 : (_literal = _PyPegen_expect_token(p, 38)) // token='*='
2531 : )
2532 : {
2533 643 : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*='"));
2534 643 : _res = _PyPegen_augoperator ( p , Mult );
2535 643 : if (_res == NULL && PyErr_Occurred()) {
2536 0 : p->error_indicator = 1;
2537 0 : p->level--;
2538 0 : return NULL;
2539 : }
2540 643 : goto done;
2541 : }
2542 741486 : p->mark = _mark;
2543 741486 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2544 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='"));
2545 : }
2546 : { // '@='
2547 741486 : if (p->error_indicator) {
2548 0 : p->level--;
2549 0 : return NULL;
2550 : }
2551 741486 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='"));
2552 : Token * _literal;
2553 741486 : if (
2554 741486 : (_literal = _PyPegen_expect_token(p, 50)) // token='@='
2555 : )
2556 : {
2557 45 : 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 741441 : p->mark = _mark;
2567 741441 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2568 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='"));
2569 : }
2570 : { // '/='
2571 741441 : if (p->error_indicator) {
2572 0 : p->level--;
2573 0 : return NULL;
2574 : }
2575 741441 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='"));
2576 : Token * _literal;
2577 741441 : if (
2578 741441 : (_literal = _PyPegen_expect_token(p, 39)) // token='/='
2579 : )
2580 : {
2581 126 : 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 741315 : p->mark = _mark;
2591 741315 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2592 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='"));
2593 : }
2594 : { // '%='
2595 741315 : if (p->error_indicator) {
2596 0 : p->level--;
2597 0 : return NULL;
2598 : }
2599 741315 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='"));
2600 : Token * _literal;
2601 741315 : if (
2602 741315 : (_literal = _PyPegen_expect_token(p, 40)) // token='%='
2603 : )
2604 : {
2605 73 : 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 741242 : p->mark = _mark;
2615 741242 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2616 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='"));
2617 : }
2618 : { // '&='
2619 741242 : if (p->error_indicator) {
2620 0 : p->level--;
2621 0 : return NULL;
2622 : }
2623 741242 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='"));
2624 : Token * _literal;
2625 741242 : if (
2626 741242 : (_literal = _PyPegen_expect_token(p, 41)) // token='&='
2627 : )
2628 : {
2629 501 : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'&='"));
2630 501 : _res = _PyPegen_augoperator ( p , BitAnd );
2631 501 : if (_res == NULL && PyErr_Occurred()) {
2632 0 : p->error_indicator = 1;
2633 0 : p->level--;
2634 0 : return NULL;
2635 : }
2636 501 : goto done;
2637 : }
2638 740741 : p->mark = _mark;
2639 740741 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2640 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='"));
2641 : }
2642 : { // '|='
2643 740741 : if (p->error_indicator) {
2644 0 : p->level--;
2645 0 : return NULL;
2646 : }
2647 740741 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='"));
2648 : Token * _literal;
2649 740741 : if (
2650 740741 : (_literal = _PyPegen_expect_token(p, 42)) // token='|='
2651 : )
2652 : {
2653 1687 : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|='"));
2654 1687 : _res = _PyPegen_augoperator ( p , BitOr );
2655 1687 : if (_res == NULL && PyErr_Occurred()) {
2656 0 : p->error_indicator = 1;
2657 0 : p->level--;
2658 0 : return NULL;
2659 : }
2660 1687 : goto done;
2661 : }
2662 739054 : p->mark = _mark;
2663 739054 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2664 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='"));
2665 : }
2666 : { // '^='
2667 739054 : if (p->error_indicator) {
2668 0 : p->level--;
2669 0 : return NULL;
2670 : }
2671 739054 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='"));
2672 : Token * _literal;
2673 739054 : if (
2674 739054 : (_literal = _PyPegen_expect_token(p, 43)) // token='^='
2675 : )
2676 : {
2677 227 : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'^='"));
2678 227 : _res = _PyPegen_augoperator ( p , BitXor );
2679 227 : if (_res == NULL && PyErr_Occurred()) {
2680 0 : p->error_indicator = 1;
2681 0 : p->level--;
2682 0 : return NULL;
2683 : }
2684 227 : goto done;
2685 : }
2686 738827 : p->mark = _mark;
2687 738827 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2688 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='"));
2689 : }
2690 : { // '<<='
2691 738827 : if (p->error_indicator) {
2692 0 : p->level--;
2693 0 : return NULL;
2694 : }
2695 738827 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='"));
2696 : Token * _literal;
2697 738827 : if (
2698 738827 : (_literal = _PyPegen_expect_token(p, 44)) // token='<<='
2699 : )
2700 : {
2701 269 : 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 738558 : p->mark = _mark;
2711 738558 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2712 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='"));
2713 : }
2714 : { // '>>='
2715 738558 : if (p->error_indicator) {
2716 0 : p->level--;
2717 0 : return NULL;
2718 : }
2719 738558 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='"));
2720 : Token * _literal;
2721 738558 : if (
2722 738558 : (_literal = _PyPegen_expect_token(p, 45)) // token='>>='
2723 : )
2724 : {
2725 81 : D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>>='"));
2726 81 : _res = _PyPegen_augoperator ( p , RShift );
2727 81 : if (_res == NULL && PyErr_Occurred()) {
2728 0 : p->error_indicator = 1;
2729 0 : p->level--;
2730 0 : return NULL;
2731 : }
2732 81 : goto done;
2733 : }
2734 738477 : p->mark = _mark;
2735 738477 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2736 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='"));
2737 : }
2738 : { // '**='
2739 738477 : if (p->error_indicator) {
2740 0 : p->level--;
2741 0 : return NULL;
2742 : }
2743 738477 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='"));
2744 : Token * _literal;
2745 738477 : if (
2746 738477 : (_literal = _PyPegen_expect_token(p, 46)) // token='**='
2747 : )
2748 : {
2749 58 : 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 738419 : p->mark = _mark;
2759 738419 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2760 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='"));
2761 : }
2762 : { // '//='
2763 738419 : if (p->error_indicator) {
2764 0 : p->level--;
2765 0 : return NULL;
2766 : }
2767 738419 : D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='"));
2768 : Token * _literal;
2769 738419 : if (
2770 738419 : (_literal = _PyPegen_expect_token(p, 48)) // token='//='
2771 : )
2772 : {
2773 357 : 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 738062 : p->mark = _mark;
2783 738062 : D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2784 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='"));
2785 : }
2786 738062 : _res = NULL;
2787 763771 : done:
2788 763771 : p->level--;
2789 763771 : return _res;
2790 : }
2791 :
2792 : // return_stmt: 'return' star_expressions?
2793 : static stmt_ty
2794 241295 : return_stmt_rule(Parser *p)
2795 : {
2796 241295 : if (p->level++ == MAXSTACK) {
2797 0 : p->error_indicator = 1;
2798 0 : PyErr_NoMemory();
2799 : }
2800 241295 : if (p->error_indicator) {
2801 0 : p->level--;
2802 0 : return NULL;
2803 : }
2804 241295 : stmt_ty _res = NULL;
2805 241295 : int _mark = p->mark;
2806 241295 : 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 241295 : int _start_lineno = p->tokens[_mark]->lineno;
2812 : UNUSED(_start_lineno); // Only used by EXTRA macro
2813 241295 : int _start_col_offset = p->tokens[_mark]->col_offset;
2814 : UNUSED(_start_col_offset); // Only used by EXTRA macro
2815 : { // 'return' star_expressions?
2816 241295 : if (p->error_indicator) {
2817 0 : p->level--;
2818 0 : return NULL;
2819 : }
2820 241295 : 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 241295 : if (
2824 241295 : (_keyword = _PyPegen_expect_token(p, 519)) // token='return'
2825 241295 : &&
2826 241295 : (a = star_expressions_rule(p), !p->error_indicator) // star_expressions?
2827 : )
2828 : {
2829 241294 : D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?"));
2830 241294 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2831 241294 : if (_token == NULL) {
2832 0 : p->level--;
2833 0 : return NULL;
2834 : }
2835 241294 : int _end_lineno = _token->end_lineno;
2836 : UNUSED(_end_lineno); // Only used by EXTRA macro
2837 241294 : int _end_col_offset = _token->end_col_offset;
2838 : UNUSED(_end_col_offset); // Only used by EXTRA macro
2839 241294 : _res = _PyAST_Return ( a , EXTRA );
2840 241294 : if (_res == NULL && PyErr_Occurred()) {
2841 0 : p->error_indicator = 1;
2842 0 : p->level--;
2843 0 : return NULL;
2844 : }
2845 241294 : goto done;
2846 : }
2847 1 : p->mark = _mark;
2848 1 : 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 241295 : done:
2853 241295 : p->level--;
2854 241295 : return _res;
2855 : }
2856 :
2857 : // raise_stmt: 'raise' expression ['from' expression] | 'raise'
2858 : static stmt_ty
2859 61395 : raise_stmt_rule(Parser *p)
2860 : {
2861 61395 : if (p->level++ == MAXSTACK) {
2862 0 : p->error_indicator = 1;
2863 0 : PyErr_NoMemory();
2864 : }
2865 61395 : if (p->error_indicator) {
2866 0 : p->level--;
2867 0 : return NULL;
2868 : }
2869 61395 : stmt_ty _res = NULL;
2870 61395 : int _mark = p->mark;
2871 61395 : 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 61395 : int _start_lineno = p->tokens[_mark]->lineno;
2877 : UNUSED(_start_lineno); // Only used by EXTRA macro
2878 61395 : 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 61395 : if (p->error_indicator) {
2882 0 : p->level--;
2883 0 : return NULL;
2884 : }
2885 61395 : 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 61395 : if (
2890 61395 : (_keyword = _PyPegen_expect_token(p, 522)) // token='raise'
2891 61395 : &&
2892 61395 : (a = expression_rule(p)) // expression
2893 56670 : &&
2894 56670 : (b = _tmp_17_rule(p), !p->error_indicator) // ['from' expression]
2895 : )
2896 : {
2897 56670 : D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]"));
2898 56670 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2899 56670 : if (_token == NULL) {
2900 0 : p->level--;
2901 0 : return NULL;
2902 : }
2903 56670 : int _end_lineno = _token->end_lineno;
2904 : UNUSED(_end_lineno); // Only used by EXTRA macro
2905 56670 : int _end_col_offset = _token->end_col_offset;
2906 : UNUSED(_end_col_offset); // Only used by EXTRA macro
2907 56670 : _res = _PyAST_Raise ( a , b , EXTRA );
2908 56670 : if (_res == NULL && PyErr_Occurred()) {
2909 0 : p->error_indicator = 1;
2910 0 : p->level--;
2911 0 : return NULL;
2912 : }
2913 56670 : goto done;
2914 : }
2915 4725 : p->mark = _mark;
2916 4725 : 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 4725 : if (p->error_indicator) {
2921 0 : p->level--;
2922 0 : return NULL;
2923 : }
2924 4725 : D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'"));
2925 : Token * _keyword;
2926 4725 : if (
2927 4725 : (_keyword = _PyPegen_expect_token(p, 522)) // token='raise'
2928 : )
2929 : {
2930 4725 : D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise'"));
2931 4725 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2932 4725 : if (_token == NULL) {
2933 0 : p->level--;
2934 0 : return NULL;
2935 : }
2936 4725 : int _end_lineno = _token->end_lineno;
2937 : UNUSED(_end_lineno); // Only used by EXTRA macro
2938 4725 : int _end_col_offset = _token->end_col_offset;
2939 : UNUSED(_end_col_offset); // Only used by EXTRA macro
2940 4725 : _res = _PyAST_Raise ( NULL , NULL , EXTRA );
2941 4725 : if (_res == NULL && PyErr_Occurred()) {
2942 0 : p->error_indicator = 1;
2943 0 : p->level--;
2944 0 : return NULL;
2945 : }
2946 4725 : goto done;
2947 : }
2948 0 : p->mark = _mark;
2949 0 : 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 61395 : done:
2954 61395 : p->level--;
2955 61395 : return _res;
2956 : }
2957 :
2958 : // global_stmt: 'global' ','.NAME+
2959 : static stmt_ty
2960 1841 : global_stmt_rule(Parser *p)
2961 : {
2962 1841 : if (p->level++ == MAXSTACK) {
2963 0 : p->error_indicator = 1;
2964 0 : PyErr_NoMemory();
2965 : }
2966 1841 : if (p->error_indicator) {
2967 0 : p->level--;
2968 0 : return NULL;
2969 : }
2970 1841 : stmt_ty _res = NULL;
2971 1841 : int _mark = p->mark;
2972 1841 : 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 1841 : int _start_lineno = p->tokens[_mark]->lineno;
2978 : UNUSED(_start_lineno); // Only used by EXTRA macro
2979 1841 : int _start_col_offset = p->tokens[_mark]->col_offset;
2980 : UNUSED(_start_col_offset); // Only used by EXTRA macro
2981 : { // 'global' ','.NAME+
2982 1841 : if (p->error_indicator) {
2983 0 : p->level--;
2984 0 : return NULL;
2985 : }
2986 1841 : 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 1841 : if (
2990 1841 : (_keyword = _PyPegen_expect_token(p, 523)) // token='global'
2991 1841 : &&
2992 1841 : (a = (asdl_expr_seq*)_gather_18_rule(p)) // ','.NAME+
2993 : )
2994 : {
2995 1839 : D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+"));
2996 1839 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2997 1839 : if (_token == NULL) {
2998 0 : p->level--;
2999 0 : return NULL;
3000 : }
3001 1839 : int _end_lineno = _token->end_lineno;
3002 : UNUSED(_end_lineno); // Only used by EXTRA macro
3003 1839 : int _end_col_offset = _token->end_col_offset;
3004 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3005 1839 : _res = _PyAST_Global ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
3006 1839 : if (_res == NULL && PyErr_Occurred()) {
3007 0 : p->error_indicator = 1;
3008 0 : p->level--;
3009 0 : return NULL;
3010 : }
3011 1839 : goto done;
3012 : }
3013 2 : p->mark = _mark;
3014 2 : 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 1841 : done:
3019 1841 : p->level--;
3020 1841 : return _res;
3021 : }
3022 :
3023 : // nonlocal_stmt: 'nonlocal' ','.NAME+
3024 : static stmt_ty
3025 929 : nonlocal_stmt_rule(Parser *p)
3026 : {
3027 929 : if (p->level++ == MAXSTACK) {
3028 0 : p->error_indicator = 1;
3029 0 : PyErr_NoMemory();
3030 : }
3031 929 : if (p->error_indicator) {
3032 0 : p->level--;
3033 0 : return NULL;
3034 : }
3035 929 : stmt_ty _res = NULL;
3036 929 : int _mark = p->mark;
3037 929 : 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 929 : int _start_lineno = p->tokens[_mark]->lineno;
3043 : UNUSED(_start_lineno); // Only used by EXTRA macro
3044 929 : int _start_col_offset = p->tokens[_mark]->col_offset;
3045 : UNUSED(_start_col_offset); // Only used by EXTRA macro
3046 : { // 'nonlocal' ','.NAME+
3047 929 : if (p->error_indicator) {
3048 0 : p->level--;
3049 0 : return NULL;
3050 : }
3051 929 : 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 929 : if (
3055 929 : (_keyword = _PyPegen_expect_token(p, 524)) // token='nonlocal'
3056 929 : &&
3057 929 : (a = (asdl_expr_seq*)_gather_20_rule(p)) // ','.NAME+
3058 : )
3059 : {
3060 927 : D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+"));
3061 927 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3062 927 : if (_token == NULL) {
3063 0 : p->level--;
3064 0 : return NULL;
3065 : }
3066 927 : int _end_lineno = _token->end_lineno;
3067 : UNUSED(_end_lineno); // Only used by EXTRA macro
3068 927 : int _end_col_offset = _token->end_col_offset;
3069 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3070 927 : _res = _PyAST_Nonlocal ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
3071 927 : if (_res == NULL && PyErr_Occurred()) {
3072 0 : p->error_indicator = 1;
3073 0 : p->level--;
3074 0 : return NULL;
3075 : }
3076 927 : goto done;
3077 : }
3078 2 : p->mark = _mark;
3079 2 : 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 929 : done:
3084 929 : p->level--;
3085 929 : return _res;
3086 : }
3087 :
3088 : // del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt
3089 : static stmt_ty
3090 8979 : del_stmt_rule(Parser *p)
3091 : {
3092 8979 : if (p->level++ == MAXSTACK) {
3093 0 : p->error_indicator = 1;
3094 0 : PyErr_NoMemory();
3095 : }
3096 8979 : if (p->error_indicator) {
3097 0 : p->level--;
3098 0 : return NULL;
3099 : }
3100 8979 : stmt_ty _res = NULL;
3101 8979 : int _mark = p->mark;
3102 8979 : 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 8979 : int _start_lineno = p->tokens[_mark]->lineno;
3108 : UNUSED(_start_lineno); // Only used by EXTRA macro
3109 8979 : 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 8979 : if (p->error_indicator) {
3113 0 : p->level--;
3114 0 : return NULL;
3115 : }
3116 8979 : 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 8979 : if (
3120 8979 : (_keyword = _PyPegen_expect_token(p, 603)) // token='del'
3121 8979 : &&
3122 8979 : (a = del_targets_rule(p)) // del_targets
3123 8933 : &&
3124 8933 : _PyPegen_lookahead(1, _tmp_22_rule, p)
3125 : )
3126 : {
3127 8899 : D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
3128 8899 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3129 8899 : if (_token == NULL) {
3130 0 : p->level--;
3131 0 : return NULL;
3132 : }
3133 8899 : int _end_lineno = _token->end_lineno;
3134 : UNUSED(_end_lineno); // Only used by EXTRA macro
3135 8899 : int _end_col_offset = _token->end_col_offset;
3136 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3137 8899 : _res = _PyAST_Delete ( a , EXTRA );
3138 8899 : if (_res == NULL && PyErr_Occurred()) {
3139 0 : p->error_indicator = 1;
3140 0 : p->level--;
3141 0 : return NULL;
3142 : }
3143 8899 : goto done;
3144 : }
3145 80 : p->mark = _mark;
3146 80 : 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 37 : 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 0 : 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 37 : 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 8978 : done:
3170 8978 : p->level--;
3171 8978 : return _res;
3172 : }
3173 :
3174 : // yield_stmt: yield_expr
3175 : static stmt_ty
3176 15365 : yield_stmt_rule(Parser *p)
3177 : {
3178 15365 : if (p->level++ == MAXSTACK) {
3179 0 : p->error_indicator = 1;
3180 0 : PyErr_NoMemory();
3181 : }
3182 15365 : if (p->error_indicator) {
3183 0 : p->level--;
3184 0 : return NULL;
3185 : }
3186 15365 : stmt_ty _res = NULL;
3187 15365 : int _mark = p->mark;
3188 15365 : 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 15365 : int _start_lineno = p->tokens[_mark]->lineno;
3194 : UNUSED(_start_lineno); // Only used by EXTRA macro
3195 15365 : int _start_col_offset = p->tokens[_mark]->col_offset;
3196 : UNUSED(_start_col_offset); // Only used by EXTRA macro
3197 : { // yield_expr
3198 15365 : if (p->error_indicator) {
3199 0 : p->level--;
3200 0 : return NULL;
3201 : }
3202 15365 : D(fprintf(stderr, "%*c> yield_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
3203 : expr_ty y;
3204 15365 : if (
3205 15365 : (y = yield_expr_rule(p)) // yield_expr
3206 : )
3207 : {
3208 15365 : D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
3209 15365 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3210 15365 : if (_token == NULL) {
3211 0 : p->level--;
3212 0 : return NULL;
3213 : }
3214 15365 : int _end_lineno = _token->end_lineno;
3215 : UNUSED(_end_lineno); // Only used by EXTRA macro
3216 15365 : int _end_col_offset = _token->end_col_offset;
3217 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3218 15365 : _res = _PyAST_Expr ( y , EXTRA );
3219 15365 : if (_res == NULL && PyErr_Occurred()) {
3220 0 : p->error_indicator = 1;
3221 0 : p->level--;
3222 0 : return NULL;
3223 : }
3224 15365 : goto done;
3225 : }
3226 0 : p->mark = _mark;
3227 0 : 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 15365 : done:
3232 15365 : p->level--;
3233 15365 : return _res;
3234 : }
3235 :
3236 : // assert_stmt: 'assert' expression [',' expression]
3237 : static stmt_ty
3238 9782 : assert_stmt_rule(Parser *p)
3239 : {
3240 9782 : if (p->level++ == MAXSTACK) {
3241 0 : p->error_indicator = 1;
3242 0 : PyErr_NoMemory();
3243 : }
3244 9782 : if (p->error_indicator) {
3245 0 : p->level--;
3246 0 : return NULL;
3247 : }
3248 9782 : stmt_ty _res = NULL;
3249 9782 : int _mark = p->mark;
3250 9782 : 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 9782 : int _start_lineno = p->tokens[_mark]->lineno;
3256 : UNUSED(_start_lineno); // Only used by EXTRA macro
3257 9782 : int _start_col_offset = p->tokens[_mark]->col_offset;
3258 : UNUSED(_start_col_offset); // Only used by EXTRA macro
3259 : { // 'assert' expression [',' expression]
3260 9782 : if (p->error_indicator) {
3261 0 : p->level--;
3262 0 : return NULL;
3263 : }
3264 9782 : 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 9782 : if (
3269 9782 : (_keyword = _PyPegen_expect_token(p, 526)) // token='assert'
3270 9782 : &&
3271 9782 : (a = expression_rule(p)) // expression
3272 9780 : &&
3273 9780 : (b = _tmp_23_rule(p), !p->error_indicator) // [',' expression]
3274 : )
3275 : {
3276 9780 : D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]"));
3277 9780 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3278 9780 : if (_token == NULL) {
3279 0 : p->level--;
3280 0 : return NULL;
3281 : }
3282 9780 : int _end_lineno = _token->end_lineno;
3283 : UNUSED(_end_lineno); // Only used by EXTRA macro
3284 9780 : int _end_col_offset = _token->end_col_offset;
3285 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3286 9780 : _res = _PyAST_Assert ( a , b , EXTRA );
3287 9780 : if (_res == NULL && PyErr_Occurred()) {
3288 0 : p->error_indicator = 1;
3289 0 : p->level--;
3290 0 : return NULL;
3291 : }
3292 9780 : goto done;
3293 : }
3294 2 : p->mark = _mark;
3295 2 : 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 9782 : done:
3300 9782 : p->level--;
3301 9782 : return _res;
3302 : }
3303 :
3304 : // import_stmt: import_name | import_from
3305 : static stmt_ty
3306 91360 : import_stmt_rule(Parser *p)
3307 : {
3308 91360 : if (p->level++ == MAXSTACK) {
3309 0 : p->error_indicator = 1;
3310 0 : PyErr_NoMemory();
3311 : }
3312 91360 : if (p->error_indicator) {
3313 0 : p->level--;
3314 0 : return NULL;
3315 : }
3316 91360 : stmt_ty _res = NULL;
3317 91360 : int _mark = p->mark;
3318 : { // import_name
3319 91360 : if (p->error_indicator) {
3320 0 : p->level--;
3321 0 : return NULL;
3322 : }
3323 91360 : D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_name"));
3324 : stmt_ty import_name_var;
3325 91360 : if (
3326 91360 : (import_name_var = import_name_rule(p)) // import_name
3327 : )
3328 : {
3329 45171 : D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_name"));
3330 45171 : _res = import_name_var;
3331 45171 : goto done;
3332 : }
3333 46189 : p->mark = _mark;
3334 46189 : 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 46189 : if (p->error_indicator) {
3339 2 : p->level--;
3340 2 : return NULL;
3341 : }
3342 46187 : D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from"));
3343 : stmt_ty import_from_var;
3344 46187 : if (
3345 46187 : (import_from_var = import_from_rule(p)) // import_from
3346 : )
3347 : {
3348 46133 : D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from"));
3349 46133 : _res = import_from_var;
3350 46133 : goto done;
3351 : }
3352 54 : p->mark = _mark;
3353 54 : 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 91358 : done:
3358 91358 : p->level--;
3359 91358 : return _res;
3360 : }
3361 :
3362 : // import_name: 'import' dotted_as_names
3363 : static stmt_ty
3364 91360 : import_name_rule(Parser *p)
3365 : {
3366 91360 : if (p->level++ == MAXSTACK) {
3367 0 : p->error_indicator = 1;
3368 0 : PyErr_NoMemory();
3369 : }
3370 91360 : if (p->error_indicator) {
3371 0 : p->level--;
3372 0 : return NULL;
3373 : }
3374 91360 : stmt_ty _res = NULL;
3375 91360 : int _mark = p->mark;
3376 91360 : 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 91360 : int _start_lineno = p->tokens[_mark]->lineno;
3382 : UNUSED(_start_lineno); // Only used by EXTRA macro
3383 91360 : 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 91360 : if (p->error_indicator) {
3387 0 : p->level--;
3388 0 : return NULL;
3389 : }
3390 91360 : 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 91360 : if (
3394 91360 : (_keyword = _PyPegen_expect_token(p, 531)) // token='import'
3395 45189 : &&
3396 45189 : (a = dotted_as_names_rule(p)) // dotted_as_names
3397 : )
3398 : {
3399 45171 : D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names"));
3400 45171 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3401 45171 : if (_token == NULL) {
3402 0 : p->level--;
3403 0 : return NULL;
3404 : }
3405 45171 : int _end_lineno = _token->end_lineno;
3406 : UNUSED(_end_lineno); // Only used by EXTRA macro
3407 45171 : int _end_col_offset = _token->end_col_offset;
3408 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3409 45171 : _res = _PyAST_Import ( a , EXTRA );
3410 45171 : if (_res == NULL && PyErr_Occurred()) {
3411 0 : p->error_indicator = 1;
3412 0 : p->level--;
3413 0 : return NULL;
3414 : }
3415 45171 : goto done;
3416 : }
3417 46189 : p->mark = _mark;
3418 46189 : 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 46189 : _res = NULL;
3422 91360 : done:
3423 91360 : p->level--;
3424 91360 : 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 46187 : import_from_rule(Parser *p)
3432 : {
3433 46187 : if (p->level++ == MAXSTACK) {
3434 0 : p->error_indicator = 1;
3435 0 : PyErr_NoMemory();
3436 : }
3437 46187 : if (p->error_indicator) {
3438 0 : p->level--;
3439 0 : return NULL;
3440 : }
3441 46187 : stmt_ty _res = NULL;
3442 46187 : int _mark = p->mark;
3443 46187 : 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 46187 : int _start_lineno = p->tokens[_mark]->lineno;
3449 : UNUSED(_start_lineno); // Only used by EXTRA macro
3450 46187 : 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 46187 : if (p->error_indicator) {
3454 0 : p->level--;
3455 0 : return NULL;
3456 : }
3457 46187 : 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 46187 : if (
3464 46187 : (_keyword = _PyPegen_expect_token(p, 572)) // token='from'
3465 46171 : &&
3466 46171 : (a = _loop0_24_rule(p)) // (('.' | '...'))*
3467 46171 : &&
3468 46171 : (b = dotted_name_rule(p)) // dotted_name
3469 44912 : &&
3470 44912 : (_keyword_1 = _PyPegen_expect_token(p, 531)) // token='import'
3471 44912 : &&
3472 44912 : (c = import_from_targets_rule(p)) // import_from_targets
3473 : )
3474 : {
3475 44878 : D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
3476 44878 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3477 44878 : if (_token == NULL) {
3478 0 : p->level--;
3479 0 : return NULL;
3480 : }
3481 44878 : int _end_lineno = _token->end_lineno;
3482 : UNUSED(_end_lineno); // Only used by EXTRA macro
3483 44878 : int _end_col_offset = _token->end_col_offset;
3484 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3485 44878 : _res = _PyAST_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA );
3486 44878 : if (_res == NULL && PyErr_Occurred()) {
3487 0 : p->error_indicator = 1;
3488 0 : p->level--;
3489 0 : return NULL;
3490 : }
3491 44878 : goto done;
3492 : }
3493 1309 : p->mark = _mark;
3494 1309 : 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 1309 : if (p->error_indicator) {
3499 19 : p->level--;
3500 19 : return NULL;
3501 : }
3502 1290 : 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 1290 : if (
3508 1290 : (_keyword = _PyPegen_expect_token(p, 572)) // token='from'
3509 1274 : &&
3510 1274 : (a = _loop1_25_rule(p)) // (('.' | '...'))+
3511 1255 : &&
3512 1255 : (_keyword_1 = _PyPegen_expect_token(p, 531)) // token='import'
3513 1255 : &&
3514 1255 : (b = import_from_targets_rule(p)) // import_from_targets
3515 : )
3516 : {
3517 1255 : D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
3518 1255 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3519 1255 : if (_token == NULL) {
3520 0 : p->level--;
3521 0 : return NULL;
3522 : }
3523 1255 : int _end_lineno = _token->end_lineno;
3524 : UNUSED(_end_lineno); // Only used by EXTRA macro
3525 1255 : int _end_col_offset = _token->end_col_offset;
3526 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3527 1255 : _res = _PyAST_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA );
3528 1255 : if (_res == NULL && PyErr_Occurred()) {
3529 0 : p->error_indicator = 1;
3530 0 : p->level--;
3531 0 : return NULL;
3532 : }
3533 1255 : goto done;
3534 : }
3535 35 : p->mark = _mark;
3536 35 : 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 46168 : done:
3541 46168 : p->level--;
3542 46168 : 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 46167 : import_from_targets_rule(Parser *p)
3552 : {
3553 46167 : if (p->level++ == MAXSTACK) {
3554 0 : p->error_indicator = 1;
3555 0 : PyErr_NoMemory();
3556 : }
3557 46167 : if (p->error_indicator) {
3558 0 : p->level--;
3559 0 : return NULL;
3560 : }
3561 46167 : asdl_alias_seq* _res = NULL;
3562 46167 : int _mark = p->mark;
3563 46167 : 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 46167 : int _start_lineno = p->tokens[_mark]->lineno;
3569 : UNUSED(_start_lineno); // Only used by EXTRA macro
3570 46167 : 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 46167 : if (p->error_indicator) {
3574 0 : p->level--;
3575 0 : return NULL;
3576 : }
3577 46167 : 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 46167 : if (
3584 46167 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
3585 2231 : &&
3586 2231 : (a = import_from_as_names_rule(p)) // import_from_as_names
3587 2223 : &&
3588 2223 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
3589 2217 : &&
3590 2217 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
3591 : )
3592 : {
3593 2215 : D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'"));
3594 2215 : _res = a;
3595 2215 : if (_res == NULL && PyErr_Occurred()) {
3596 0 : p->error_indicator = 1;
3597 0 : p->level--;
3598 0 : return NULL;
3599 : }
3600 2215 : goto done;
3601 : }
3602 43952 : p->mark = _mark;
3603 43952 : 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 43952 : if (p->error_indicator) {
3608 12 : p->level--;
3609 12 : return NULL;
3610 : }
3611 43940 : 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 43940 : if (
3614 43940 : (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names
3615 42800 : &&
3616 42800 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
3617 : )
3618 : {
3619 42788 : D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','"));
3620 42788 : _res = import_from_as_names_var;
3621 42788 : goto done;
3622 : }
3623 1152 : p->mark = _mark;
3624 1152 : 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 1152 : if (p->error_indicator) {
3629 2 : p->level--;
3630 2 : return NULL;
3631 : }
3632 1150 : D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
3633 : Token * _literal;
3634 1150 : if (
3635 1150 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
3636 : )
3637 : {
3638 1130 : D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'"));
3639 1130 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3640 1130 : if (_token == NULL) {
3641 0 : p->level--;
3642 0 : return NULL;
3643 : }
3644 1130 : int _end_lineno = _token->end_lineno;
3645 : UNUSED(_end_lineno); // Only used by EXTRA macro
3646 1130 : int _end_col_offset = _token->end_col_offset;
3647 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3648 1130 : _res = ( asdl_alias_seq* ) _PyPegen_singleton_seq ( p , CHECK ( alias_ty , _PyPegen_alias_for_star ( p , EXTRA ) ) );
3649 1130 : if (_res == NULL && PyErr_Occurred()) {
3650 0 : p->error_indicator = 1;
3651 0 : p->level--;
3652 0 : return NULL;
3653 : }
3654 1130 : goto done;
3655 : }
3656 20 : p->mark = _mark;
3657 20 : 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 10 : 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 0 : 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 10 : 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 46153 : done:
3681 46153 : p->level--;
3682 46153 : return _res;
3683 : }
3684 :
3685 : // import_from_as_names: ','.import_from_as_name+
3686 : static asdl_alias_seq*
3687 46181 : import_from_as_names_rule(Parser *p)
3688 : {
3689 46181 : if (p->level++ == MAXSTACK) {
3690 0 : p->error_indicator = 1;
3691 0 : PyErr_NoMemory();
3692 : }
3693 46181 : if (p->error_indicator) {
3694 0 : p->level--;
3695 0 : return NULL;
3696 : }
3697 46181 : asdl_alias_seq* _res = NULL;
3698 46181 : int _mark = p->mark;
3699 : { // ','.import_from_as_name+
3700 46181 : if (p->error_indicator) {
3701 0 : p->level--;
3702 0 : return NULL;
3703 : }
3704 46181 : 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 46181 : if (
3707 46181 : (a = (asdl_alias_seq*)_gather_26_rule(p)) // ','.import_from_as_name+
3708 : )
3709 : {
3710 45029 : D(fprintf(stderr, "%*c+ import_from_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+"));
3711 45029 : _res = a;
3712 45029 : if (_res == NULL && PyErr_Occurred()) {
3713 0 : p->error_indicator = 1;
3714 0 : p->level--;
3715 0 : return NULL;
3716 : }
3717 45029 : goto done;
3718 : }
3719 1152 : p->mark = _mark;
3720 1152 : 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 1152 : _res = NULL;
3724 46181 : done:
3725 46181 : p->level--;
3726 46181 : return _res;
3727 : }
3728 :
3729 : // import_from_as_name: NAME ['as' NAME]
3730 : static alias_ty
3731 80036 : import_from_as_name_rule(Parser *p)
3732 : {
3733 80036 : if (p->level++ == MAXSTACK) {
3734 0 : p->error_indicator = 1;
3735 0 : PyErr_NoMemory();
3736 : }
3737 80036 : if (p->error_indicator) {
3738 0 : p->level--;
3739 0 : return NULL;
3740 : }
3741 80036 : alias_ty _res = NULL;
3742 80036 : int _mark = p->mark;
3743 80036 : 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 80030 : int _start_lineno = p->tokens[_mark]->lineno;
3749 : UNUSED(_start_lineno); // Only used by EXTRA macro
3750 80030 : int _start_col_offset = p->tokens[_mark]->col_offset;
3751 : UNUSED(_start_col_offset); // Only used by EXTRA macro
3752 : { // NAME ['as' NAME]
3753 80030 : if (p->error_indicator) {
3754 0 : p->level--;
3755 0 : return NULL;
3756 : }
3757 80030 : 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 80030 : if (
3761 80030 : (a = _PyPegen_name_token(p)) // NAME
3762 77512 : &&
3763 77512 : (b = _tmp_28_rule(p), !p->error_indicator) // ['as' NAME]
3764 : )
3765 : {
3766 77504 : D(fprintf(stderr, "%*c+ import_from_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]"));
3767 77504 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3768 77504 : if (_token == NULL) {
3769 0 : p->level--;
3770 0 : return NULL;
3771 : }
3772 77504 : int _end_lineno = _token->end_lineno;
3773 : UNUSED(_end_lineno); // Only used by EXTRA macro
3774 77504 : int _end_col_offset = _token->end_col_offset;
3775 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3776 77504 : _res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXTRA );
3777 77504 : if (_res == NULL && PyErr_Occurred()) {
3778 0 : p->error_indicator = 1;
3779 0 : p->level--;
3780 0 : return NULL;
3781 : }
3782 77504 : goto done;
3783 : }
3784 2526 : p->mark = _mark;
3785 2526 : 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 2526 : _res = NULL;
3789 80030 : done:
3790 80030 : p->level--;
3791 80030 : return _res;
3792 : }
3793 :
3794 : // dotted_as_names: ','.dotted_as_name+
3795 : static asdl_alias_seq*
3796 45189 : dotted_as_names_rule(Parser *p)
3797 : {
3798 45189 : if (p->level++ == MAXSTACK) {
3799 0 : p->error_indicator = 1;
3800 0 : PyErr_NoMemory();
3801 : }
3802 45189 : if (p->error_indicator) {
3803 0 : p->level--;
3804 0 : return NULL;
3805 : }
3806 45189 : asdl_alias_seq* _res = NULL;
3807 45189 : int _mark = p->mark;
3808 : { // ','.dotted_as_name+
3809 45189 : if (p->error_indicator) {
3810 0 : p->level--;
3811 0 : return NULL;
3812 : }
3813 45189 : 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 45189 : if (
3816 45189 : (a = (asdl_alias_seq*)_gather_29_rule(p)) // ','.dotted_as_name+
3817 : )
3818 : {
3819 45171 : D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+"));
3820 45171 : _res = a;
3821 45171 : if (_res == NULL && PyErr_Occurred()) {
3822 0 : p->error_indicator = 1;
3823 0 : p->level--;
3824 0 : return NULL;
3825 : }
3826 45171 : goto done;
3827 : }
3828 18 : p->mark = _mark;
3829 18 : 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 45189 : done:
3834 45189 : p->level--;
3835 45189 : return _res;
3836 : }
3837 :
3838 : // dotted_as_name: dotted_name ['as' NAME]
3839 : static alias_ty
3840 46436 : dotted_as_name_rule(Parser *p)
3841 : {
3842 46436 : if (p->level++ == MAXSTACK) {
3843 0 : p->error_indicator = 1;
3844 0 : PyErr_NoMemory();
3845 : }
3846 46436 : if (p->error_indicator) {
3847 0 : p->level--;
3848 0 : return NULL;
3849 : }
3850 46436 : alias_ty _res = NULL;
3851 46436 : int _mark = p->mark;
3852 46436 : 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 46436 : int _start_lineno = p->tokens[_mark]->lineno;
3858 : UNUSED(_start_lineno); // Only used by EXTRA macro
3859 46436 : 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 46436 : if (p->error_indicator) {
3863 0 : p->level--;
3864 0 : return NULL;
3865 : }
3866 46436 : 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 46436 : if (
3870 46436 : (a = dotted_name_rule(p)) // dotted_name
3871 46418 : &&
3872 46418 : (b = _tmp_31_rule(p), !p->error_indicator) // ['as' NAME]
3873 : )
3874 : {
3875 46418 : D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]"));
3876 46418 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3877 46418 : if (_token == NULL) {
3878 0 : p->level--;
3879 0 : return NULL;
3880 : }
3881 46418 : int _end_lineno = _token->end_lineno;
3882 : UNUSED(_end_lineno); // Only used by EXTRA macro
3883 46418 : int _end_col_offset = _token->end_col_offset;
3884 : UNUSED(_end_col_offset); // Only used by EXTRA macro
3885 46418 : _res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXTRA );
3886 46418 : if (_res == NULL && PyErr_Occurred()) {
3887 0 : p->error_indicator = 1;
3888 0 : p->level--;
3889 0 : return NULL;
3890 : }
3891 46418 : goto done;
3892 : }
3893 18 : p->mark = _mark;
3894 18 : 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 46436 : done:
3899 46436 : p->level--;
3900 46436 : 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 316604 : dotted_name_rule(Parser *p)
3908 : {
3909 316604 : if (p->level++ == MAXSTACK) {
3910 0 : p->error_indicator = 1;
3911 0 : PyErr_NoMemory();
3912 : }
3913 316604 : expr_ty _res = NULL;
3914 316604 : if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) {
3915 223997 : p->level--;
3916 223997 : return _res;
3917 : }
3918 92607 : int _mark = p->mark;
3919 92607 : int _resmark = p->mark;
3920 131390 : while (1) {
3921 223997 : int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res);
3922 223997 : if (tmpvar_0) {
3923 0 : p->level--;
3924 0 : return _res;
3925 : }
3926 223997 : p->mark = _mark;
3927 223997 : void *_raw = dotted_name_raw(p);
3928 223997 : if (p->error_indicator) {
3929 2 : p->level--;
3930 2 : return NULL;
3931 : }
3932 223995 : if (_raw == NULL || p->mark <= _resmark)
3933 : break;
3934 131390 : _resmark = p->mark;
3935 131390 : _res = _raw;
3936 : }
3937 92605 : p->mark = _resmark;
3938 92605 : p->level--;
3939 92605 : return _res;
3940 : }
3941 : static expr_ty
3942 223997 : dotted_name_raw(Parser *p)
3943 : {
3944 223997 : if (p->level++ == MAXSTACK) {
3945 0 : p->error_indicator = 1;
3946 0 : PyErr_NoMemory();
3947 : }
3948 223997 : if (p->error_indicator) {
3949 0 : p->level--;
3950 0 : return NULL;
3951 : }
3952 223997 : expr_ty _res = NULL;
3953 223997 : int _mark = p->mark;
3954 : { // dotted_name '.' NAME
3955 223997 : if (p->error_indicator) {
3956 0 : p->level--;
3957 0 : return NULL;
3958 : }
3959 223997 : 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 223997 : if (
3964 223997 : (a = dotted_name_rule(p)) // dotted_name
3965 131390 : &&
3966 131390 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
3967 40058 : &&
3968 40058 : (b = _PyPegen_name_token(p)) // NAME
3969 : )
3970 : {
3971 40058 : D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME"));
3972 40058 : _res = _PyPegen_join_names_with_dot ( p , a , b );
3973 40058 : if (_res == NULL && PyErr_Occurred()) {
3974 0 : p->error_indicator = 1;
3975 0 : p->level--;
3976 0 : return NULL;
3977 : }
3978 40058 : goto done;
3979 : }
3980 183939 : p->mark = _mark;
3981 183939 : 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 183939 : if (p->error_indicator) {
3986 2 : p->level--;
3987 2 : return NULL;
3988 : }
3989 183937 : D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
3990 : expr_ty name_var;
3991 183937 : if (
3992 183937 : (name_var = _PyPegen_name_token(p)) // NAME
3993 : )
3994 : {
3995 182662 : D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
3996 182662 : _res = name_var;
3997 182662 : goto done;
3998 : }
3999 1275 : p->mark = _mark;
4000 1275 : 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 1275 : _res = NULL;
4004 223995 : done:
4005 223995 : p->level--;
4006 223995 : return _res;
4007 : }
4008 :
4009 : // block: NEWLINE INDENT statements DEDENT | simple_stmts | invalid_block
4010 : static asdl_stmt_seq*
4011 1739560 : block_rule(Parser *p)
4012 : {
4013 1739560 : if (p->level++ == MAXSTACK) {
4014 0 : p->error_indicator = 1;
4015 0 : PyErr_NoMemory();
4016 : }
4017 1739560 : if (p->error_indicator) {
4018 0 : p->level--;
4019 0 : return NULL;
4020 : }
4021 1739560 : asdl_stmt_seq* _res = NULL;
4022 1739560 : if (_PyPegen_is_memoized(p, block_type, &_res)) {
4023 531718 : p->level--;
4024 531718 : return _res;
4025 : }
4026 1207850 : int _mark = p->mark;
4027 : { // NEWLINE INDENT statements DEDENT
4028 1207850 : if (p->error_indicator) {
4029 0 : p->level--;
4030 0 : return NULL;
4031 : }
4032 1207850 : 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 1207850 : if (
4038 1207850 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
4039 996080 : &&
4040 996080 : (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT'
4041 995991 : &&
4042 995991 : (a = statements_rule(p)) // statements
4043 995866 : &&
4044 995866 : (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT'
4045 : )
4046 : {
4047 995840 : D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
4048 995840 : _res = a;
4049 995840 : if (_res == NULL && PyErr_Occurred()) {
4050 0 : p->error_indicator = 1;
4051 0 : p->level--;
4052 0 : return NULL;
4053 : }
4054 995840 : goto done;
4055 : }
4056 212006 : p->mark = _mark;
4057 212006 : 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 212006 : if (p->error_indicator) {
4062 29 : p->level--;
4063 29 : return NULL;
4064 : }
4065 211977 : D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
4066 : asdl_stmt_seq* simple_stmts_var;
4067 211977 : if (
4068 211977 : (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts
4069 : )
4070 : {
4071 211626 : D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
4072 211626 : _res = simple_stmts_var;
4073 211626 : goto done;
4074 : }
4075 351 : p->mark = _mark;
4076 351 : 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 136 : 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 0 : 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 136 : 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 1207810 : done:
4100 1207810 : _PyPegen_insert_memo(p, _mark, block_type, _res);
4101 1207810 : p->level--;
4102 1207810 : return _res;
4103 : }
4104 :
4105 : // decorators: (('@' named_expression NEWLINE))+
4106 : static asdl_expr_seq*
4107 403392 : decorators_rule(Parser *p)
4108 : {
4109 403392 : if (p->level++ == MAXSTACK) {
4110 0 : p->error_indicator = 1;
4111 0 : PyErr_NoMemory();
4112 : }
4113 403392 : if (p->error_indicator) {
4114 0 : p->level--;
4115 0 : return NULL;
4116 : }
4117 403392 : asdl_expr_seq* _res = NULL;
4118 403392 : int _mark = p->mark;
4119 : { // (('@' named_expression NEWLINE))+
4120 403392 : if (p->error_indicator) {
4121 0 : p->level--;
4122 0 : return NULL;
4123 : }
4124 403392 : D(fprintf(stderr, "%*c> decorators[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+"));
4125 : asdl_expr_seq* a;
4126 403392 : if (
4127 403392 : (a = (asdl_expr_seq*)_loop1_32_rule(p)) // (('@' named_expression NEWLINE))+
4128 : )
4129 : {
4130 37681 : D(fprintf(stderr, "%*c+ decorators[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+"));
4131 37681 : _res = a;
4132 37681 : if (_res == NULL && PyErr_Occurred()) {
4133 0 : p->error_indicator = 1;
4134 0 : p->level--;
4135 0 : return NULL;
4136 : }
4137 37681 : goto done;
4138 : }
4139 365711 : p->mark = _mark;
4140 365711 : 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 365711 : _res = NULL;
4144 403392 : done:
4145 403392 : p->level--;
4146 403392 : return _res;
4147 : }
4148 :
4149 : // class_def: decorators class_def_raw | class_def_raw
4150 : static stmt_ty
4151 56811 : class_def_rule(Parser *p)
4152 : {
4153 56811 : if (p->level++ == MAXSTACK) {
4154 0 : p->error_indicator = 1;
4155 0 : PyErr_NoMemory();
4156 : }
4157 56811 : if (p->error_indicator) {
4158 0 : p->level--;
4159 0 : return NULL;
4160 : }
4161 56811 : stmt_ty _res = NULL;
4162 56811 : int _mark = p->mark;
4163 : { // decorators class_def_raw
4164 56811 : if (p->error_indicator) {
4165 0 : p->level--;
4166 0 : return NULL;
4167 : }
4168 56811 : 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 56811 : if (
4172 56811 : (a = decorators_rule(p)) // decorators
4173 3176 : &&
4174 3176 : (b = class_def_raw_rule(p)) // class_def_raw
4175 : )
4176 : {
4177 3176 : D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw"));
4178 3176 : _res = _PyPegen_class_def_decorators ( p , a , b );
4179 3176 : if (_res == NULL && PyErr_Occurred()) {
4180 0 : p->error_indicator = 1;
4181 0 : p->level--;
4182 0 : return NULL;
4183 : }
4184 3176 : goto done;
4185 : }
4186 53635 : p->mark = _mark;
4187 53635 : 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 53635 : if (p->error_indicator) {
4192 0 : p->level--;
4193 0 : return NULL;
4194 : }
4195 53635 : 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 53635 : if (
4198 53635 : (class_def_raw_var = class_def_raw_rule(p)) // class_def_raw
4199 : )
4200 : {
4201 53594 : D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_def_raw"));
4202 53594 : _res = class_def_raw_var;
4203 53594 : goto done;
4204 : }
4205 41 : p->mark = _mark;
4206 41 : 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 56811 : done:
4211 56811 : p->level--;
4212 56811 : return _res;
4213 : }
4214 :
4215 : // class_def_raw: invalid_class_def_raw | 'class' NAME ['(' arguments? ')'] ':' block
4216 : static stmt_ty
4217 56811 : class_def_raw_rule(Parser *p)
4218 : {
4219 56811 : if (p->level++ == MAXSTACK) {
4220 0 : p->error_indicator = 1;
4221 0 : PyErr_NoMemory();
4222 : }
4223 56811 : if (p->error_indicator) {
4224 0 : p->level--;
4225 0 : return NULL;
4226 : }
4227 56811 : stmt_ty _res = NULL;
4228 56811 : int _mark = p->mark;
4229 56811 : 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 56811 : int _start_lineno = p->tokens[_mark]->lineno;
4235 : UNUSED(_start_lineno); // Only used by EXTRA macro
4236 56811 : int _start_col_offset = p->tokens[_mark]->col_offset;
4237 : UNUSED(_start_col_offset); // Only used by EXTRA macro
4238 56811 : 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 15 : 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 0 : 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 15 : 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 56811 : if (p->error_indicator) {
4259 2 : p->level--;
4260 2 : return NULL;
4261 : }
4262 56809 : 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 56809 : if (
4269 56809 : (_keyword = _PyPegen_expect_token(p, 646)) // token='class'
4270 56800 : &&
4271 56800 : (a = _PyPegen_name_token(p)) // NAME
4272 56790 : &&
4273 56790 : (b = _tmp_33_rule(p), !p->error_indicator) // ['(' arguments? ')']
4274 56784 : &&
4275 56784 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
4276 56779 : &&
4277 56779 : (c = block_rule(p)) // block
4278 : )
4279 : {
4280 56770 : D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block"));
4281 56770 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4282 56770 : if (_token == NULL) {
4283 0 : p->level--;
4284 0 : return NULL;
4285 : }
4286 56770 : int _end_lineno = _token->end_lineno;
4287 : UNUSED(_end_lineno); // Only used by EXTRA macro
4288 56770 : int _end_col_offset = _token->end_col_offset;
4289 : UNUSED(_end_col_offset); // Only used by EXTRA macro
4290 56770 : _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 56770 : if (_res == NULL && PyErr_Occurred()) {
4292 0 : p->error_indicator = 1;
4293 0 : p->level--;
4294 0 : return NULL;
4295 : }
4296 56770 : goto done;
4297 : }
4298 39 : p->mark = _mark;
4299 39 : 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 56809 : done:
4304 56809 : p->level--;
4305 56809 : return _res;
4306 : }
4307 :
4308 : // function_def: decorators function_def_raw | function_def_raw
4309 : static stmt_ty
4310 346581 : function_def_rule(Parser *p)
4311 : {
4312 346581 : if (p->level++ == MAXSTACK) {
4313 0 : p->error_indicator = 1;
4314 0 : PyErr_NoMemory();
4315 : }
4316 346581 : if (p->error_indicator) {
4317 0 : p->level--;
4318 0 : return NULL;
4319 : }
4320 346581 : stmt_ty _res = NULL;
4321 346581 : int _mark = p->mark;
4322 : { // decorators function_def_raw
4323 346581 : if (p->error_indicator) {
4324 0 : p->level--;
4325 0 : return NULL;
4326 : }
4327 346581 : 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 346581 : if (
4331 346581 : (d = decorators_rule(p)) // decorators
4332 34505 : &&
4333 34505 : (f = function_def_raw_rule(p)) // function_def_raw
4334 : )
4335 : {
4336 31329 : D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw"));
4337 31329 : _res = _PyPegen_function_def_decorators ( p , d , f );
4338 31329 : if (_res == NULL && PyErr_Occurred()) {
4339 0 : p->error_indicator = 1;
4340 0 : p->level--;
4341 0 : return NULL;
4342 : }
4343 31329 : goto done;
4344 : }
4345 315252 : p->mark = _mark;
4346 315252 : 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 315252 : if (p->error_indicator) {
4351 11 : p->level--;
4352 11 : return NULL;
4353 : }
4354 315241 : 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 315241 : if (
4357 315241 : (function_def_raw_var = function_def_raw_rule(p)) // function_def_raw
4358 : )
4359 : {
4360 311057 : D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "function_def_raw"));
4361 311057 : _res = function_def_raw_var;
4362 311057 : goto done;
4363 : }
4364 4184 : p->mark = _mark;
4365 4184 : 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 4184 : _res = NULL;
4369 346570 : done:
4370 346570 : p->level--;
4371 346570 : 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 349746 : function_def_raw_rule(Parser *p)
4380 : {
4381 349746 : if (p->level++ == MAXSTACK) {
4382 0 : p->error_indicator = 1;
4383 0 : PyErr_NoMemory();
4384 : }
4385 349746 : if (p->error_indicator) {
4386 0 : p->level--;
4387 0 : return NULL;
4388 : }
4389 349746 : stmt_ty _res = NULL;
4390 349746 : int _mark = p->mark;
4391 349746 : 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 349746 : int _start_lineno = p->tokens[_mark]->lineno;
4397 : UNUSED(_start_lineno); // Only used by EXTRA macro
4398 349746 : int _start_col_offset = p->tokens[_mark]->col_offset;
4399 : UNUSED(_start_col_offset); // Only used by EXTRA macro
4400 349746 : if (p->call_invalid_rules) { // invalid_def_raw
4401 217 : if (p->error_indicator) {
4402 0 : p->level--;
4403 0 : return NULL;
4404 : }
4405 217 : 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 0 : 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 217 : 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 349746 : if (p->error_indicator) {
4421 72 : p->level--;
4422 72 : return NULL;
4423 : }
4424 349674 : 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 349674 : if (
4435 349674 : (_keyword = _PyPegen_expect_token(p, 644)) // token='def'
4436 339196 : &&
4437 339196 : (n = _PyPegen_name_token(p)) // NAME
4438 339178 : &&
4439 339178 : (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='('
4440 339173 : &&
4441 339173 : (params = params_rule(p), !p->error_indicator) // params?
4442 339160 : &&
4443 339160 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
4444 339010 : &&
4445 339010 : (a = _tmp_34_rule(p), !p->error_indicator) // ['->' expression]
4446 339010 : &&
4447 339010 : (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
4448 339009 : &&
4449 339009 : (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment?
4450 339000 : &&
4451 339000 : (b = block_rule(p)) // block
4452 : )
4453 : {
4454 338923 : 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 338923 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4456 338923 : if (_token == NULL) {
4457 0 : p->level--;
4458 0 : return NULL;
4459 : }
4460 338923 : int _end_lineno = _token->end_lineno;
4461 : UNUSED(_end_lineno); // Only used by EXTRA macro
4462 338923 : int _end_col_offset = _token->end_col_offset;
4463 : UNUSED(_end_col_offset); // Only used by EXTRA macro
4464 338923 : _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 338923 : if (_res == NULL && PyErr_Occurred()) {
4466 0 : p->error_indicator = 1;
4467 0 : p->level--;
4468 0 : return NULL;
4469 : }
4470 338923 : goto done;
4471 : }
4472 10751 : p->mark = _mark;
4473 10751 : 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 10751 : if (p->error_indicator) {
4478 39 : p->level--;
4479 39 : return NULL;
4480 : }
4481 10712 : 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 10712 : if (
4493 10712 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
4494 4117 : &&
4495 4117 : (_keyword = _PyPegen_expect_token(p, 644)) // token='def'
4496 3522 : &&
4497 3522 : (n = _PyPegen_name_token(p)) // NAME
4498 3522 : &&
4499 3522 : (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='('
4500 3521 : &&
4501 3521 : (params = params_rule(p), !p->error_indicator) // params?
4502 3521 : &&
4503 3521 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
4504 3498 : &&
4505 3498 : (a = _tmp_35_rule(p), !p->error_indicator) // ['->' expression]
4506 3498 : &&
4507 3498 : (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
4508 3498 : &&
4509 3498 : (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment?
4510 3498 : &&
4511 3498 : (b = block_rule(p)) // block
4512 : )
4513 : {
4514 3463 : 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 3463 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4516 3463 : if (_token == NULL) {
4517 0 : p->level--;
4518 0 : return NULL;
4519 : }
4520 3463 : int _end_lineno = _token->end_lineno;
4521 : UNUSED(_end_lineno); // Only used by EXTRA macro
4522 3463 : int _end_col_offset = _token->end_col_offset;
4523 : UNUSED(_end_col_offset); // Only used by EXTRA macro
4524 3463 : _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 3463 : if (_res == NULL && PyErr_Occurred()) {
4526 0 : p->error_indicator = 1;
4527 0 : p->level--;
4528 0 : return NULL;
4529 : }
4530 3463 : goto done;
4531 : }
4532 7249 : p->mark = _mark;
4533 7249 : 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 7249 : _res = NULL;
4537 349635 : done:
4538 349635 : p->level--;
4539 349635 : return _res;
4540 : }
4541 :
4542 : // params: invalid_parameters | parameters
4543 : static arguments_ty
4544 342881 : params_rule(Parser *p)
4545 : {
4546 342881 : if (p->level++ == MAXSTACK) {
4547 0 : p->error_indicator = 1;
4548 0 : PyErr_NoMemory();
4549 : }
4550 342881 : if (p->error_indicator) {
4551 0 : p->level--;
4552 0 : return NULL;
4553 : }
4554 342881 : arguments_ty _res = NULL;
4555 342881 : int _mark = p->mark;
4556 342881 : if (p->call_invalid_rules) { // invalid_parameters
4557 302 : if (p->error_indicator) {
4558 0 : p->level--;
4559 0 : return NULL;
4560 : }
4561 302 : 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 0 : 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 302 : 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 342881 : if (p->error_indicator) {
4577 50 : p->level--;
4578 50 : return NULL;
4579 : }
4580 342831 : D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "parameters"));
4581 : arguments_ty parameters_var;
4582 342831 : if (
4583 342831 : (parameters_var = parameters_rule(p)) // parameters
4584 : )
4585 : {
4586 324502 : D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "parameters"));
4587 324502 : _res = parameters_var;
4588 324502 : goto done;
4589 : }
4590 18329 : p->mark = _mark;
4591 18329 : D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ',
4592 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "parameters"));
4593 : }
4594 18329 : _res = NULL;
4595 342831 : done:
4596 342831 : p->level--;
4597 342831 : 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 342831 : parameters_rule(Parser *p)
4608 : {
4609 342831 : if (p->level++ == MAXSTACK) {
4610 0 : p->error_indicator = 1;
4611 0 : PyErr_NoMemory();
4612 : }
4613 342831 : if (p->error_indicator) {
4614 0 : p->level--;
4615 0 : return NULL;
4616 : }
4617 342831 : arguments_ty _res = NULL;
4618 342831 : int _mark = p->mark;
4619 : { // slash_no_default param_no_default* param_with_default* star_etc?
4620 342831 : if (p->error_indicator) {
4621 0 : p->level--;
4622 0 : return NULL;
4623 : }
4624 342831 : 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 342831 : if (
4630 342831 : (a = slash_no_default_rule(p)) // slash_no_default
4631 17415 : &&
4632 17415 : (b = (asdl_arg_seq*)_loop0_36_rule(p)) // param_no_default*
4633 17415 : &&
4634 17415 : (c = _loop0_37_rule(p)) // param_with_default*
4635 17415 : &&
4636 17415 : (d = star_etc_rule(p), !p->error_indicator) // star_etc?
4637 : )
4638 : {
4639 17413 : 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 17413 : _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
4641 17413 : if (_res == NULL && PyErr_Occurred()) {
4642 0 : p->error_indicator = 1;
4643 0 : p->level--;
4644 0 : return NULL;
4645 : }
4646 17413 : goto done;
4647 : }
4648 325418 : p->mark = _mark;
4649 325418 : 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 325418 : if (p->error_indicator) {
4654 15 : p->level--;
4655 15 : return NULL;
4656 : }
4657 325403 : 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 325403 : if (
4662 325403 : (a = slash_with_default_rule(p)) // slash_with_default
4663 375 : &&
4664 375 : (b = _loop0_38_rule(p)) // param_with_default*
4665 375 : &&
4666 375 : (c = star_etc_rule(p), !p->error_indicator) // star_etc?
4667 : )
4668 : {
4669 374 : D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?"));
4670 374 : _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
4671 374 : if (_res == NULL && PyErr_Occurred()) {
4672 0 : p->error_indicator = 1;
4673 0 : p->level--;
4674 0 : return NULL;
4675 : }
4676 374 : goto done;
4677 : }
4678 325029 : p->mark = _mark;
4679 325029 : 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 325029 : if (p->error_indicator) {
4684 1 : p->level--;
4685 1 : return NULL;
4686 : }
4687 325028 : 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 325028 : if (
4692 325028 : (a = (asdl_arg_seq*)_loop1_39_rule(p)) // param_no_default+
4693 300289 : &&
4694 300289 : (b = _loop0_40_rule(p)) // param_with_default*
4695 300289 : &&
4696 300289 : (c = star_etc_rule(p), !p->error_indicator) // star_etc?
4697 : )
4698 : {
4699 300278 : D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?"));
4700 300278 : _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
4701 300278 : if (_res == NULL && PyErr_Occurred()) {
4702 0 : p->error_indicator = 1;
4703 0 : p->level--;
4704 0 : return NULL;
4705 : }
4706 300278 : goto done;
4707 : }
4708 24750 : p->mark = _mark;
4709 24750 : 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 24750 : if (p->error_indicator) {
4714 11 : p->level--;
4715 11 : return NULL;
4716 : }
4717 24739 : 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 24739 : if (
4721 24739 : (a = _loop1_41_rule(p)) // param_with_default+
4722 3107 : &&
4723 3107 : (b = star_etc_rule(p), !p->error_indicator) // star_etc?
4724 : )
4725 : {
4726 3107 : D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?"));
4727 3107 : _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
4728 3107 : if (_res == NULL && PyErr_Occurred()) {
4729 0 : p->error_indicator = 1;
4730 0 : p->level--;
4731 0 : return NULL;
4732 : }
4733 3107 : goto done;
4734 : }
4735 21632 : p->mark = _mark;
4736 21632 : 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 21632 : if (p->error_indicator) {
4741 0 : p->level--;
4742 0 : return NULL;
4743 : }
4744 21632 : D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc"));
4745 : StarEtc* a;
4746 21632 : if (
4747 21632 : (a = star_etc_rule(p)) // star_etc
4748 : )
4749 : {
4750 3330 : D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_etc"));
4751 3330 : _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
4752 3330 : if (_res == NULL && PyErr_Occurred()) {
4753 0 : p->error_indicator = 1;
4754 0 : p->level--;
4755 0 : return NULL;
4756 : }
4757 3330 : goto done;
4758 : }
4759 18302 : p->mark = _mark;
4760 18302 : 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 18302 : _res = NULL;
4764 342804 : done:
4765 342804 : p->level--;
4766 342804 : return _res;
4767 : }
4768 :
4769 : // slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &')'
4770 : static asdl_arg_seq*
4771 343371 : slash_no_default_rule(Parser *p)
4772 : {
4773 343371 : if (p->level++ == MAXSTACK) {
4774 0 : p->error_indicator = 1;
4775 0 : PyErr_NoMemory();
4776 : }
4777 343371 : if (p->error_indicator) {
4778 0 : p->level--;
4779 0 : return NULL;
4780 : }
4781 343371 : asdl_arg_seq* _res = NULL;
4782 343371 : int _mark = p->mark;
4783 : { // param_no_default+ '/' ','
4784 343371 : if (p->error_indicator) {
4785 0 : p->level--;
4786 0 : return NULL;
4787 : }
4788 343371 : 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 343371 : if (
4793 343371 : (a = (asdl_arg_seq*)_loop1_42_rule(p)) // param_no_default+
4794 318080 : &&
4795 318080 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4796 17430 : &&
4797 17430 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
4798 : )
4799 : {
4800 17200 : D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','"));
4801 17200 : _res = a;
4802 17200 : if (_res == NULL && PyErr_Occurred()) {
4803 0 : p->error_indicator = 1;
4804 0 : p->level--;
4805 0 : return NULL;
4806 : }
4807 17200 : goto done;
4808 : }
4809 326171 : p->mark = _mark;
4810 326171 : 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 326171 : if (p->error_indicator) {
4815 13 : p->level--;
4816 13 : return NULL;
4817 : }
4818 326158 : 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 326158 : if (
4822 326158 : (a = (asdl_arg_seq*)_loop1_43_rule(p)) // param_no_default+
4823 300880 : &&
4824 300880 : (_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 230 : 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 325928 : p->mark = _mark;
4839 325928 : 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 325928 : _res = NULL;
4843 343358 : done:
4844 343358 : p->level--;
4845 343358 : 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 326225 : slash_with_default_rule(Parser *p)
4853 : {
4854 326225 : if (p->level++ == MAXSTACK) {
4855 0 : p->error_indicator = 1;
4856 0 : PyErr_NoMemory();
4857 : }
4858 326225 : if (p->error_indicator) {
4859 0 : p->level--;
4860 0 : return NULL;
4861 : }
4862 326225 : SlashWithDefault* _res = NULL;
4863 326225 : int _mark = p->mark;
4864 : { // param_no_default* param_with_default+ '/' ','
4865 326225 : if (p->error_indicator) {
4866 0 : p->level--;
4867 0 : return NULL;
4868 : }
4869 326225 : 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 326225 : if (
4875 326225 : (a = _loop0_44_rule(p)) // param_no_default*
4876 326225 : &&
4877 326225 : (b = _loop1_45_rule(p)) // param_with_default+
4878 40138 : &&
4879 40138 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4880 388 : &&
4881 388 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
4882 : )
4883 : {
4884 360 : D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','"));
4885 360 : _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
4886 360 : if (_res == NULL && PyErr_Occurred()) {
4887 0 : p->error_indicator = 1;
4888 0 : p->level--;
4889 0 : return NULL;
4890 : }
4891 360 : goto done;
4892 : }
4893 325865 : p->mark = _mark;
4894 325865 : 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 325865 : if (p->error_indicator) {
4899 3 : p->level--;
4900 3 : return NULL;
4901 : }
4902 325862 : 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 325862 : if (
4907 325862 : (a = _loop0_46_rule(p)) // param_no_default*
4908 325862 : &&
4909 325862 : (b = _loop1_47_rule(p)) // param_with_default+
4910 39778 : &&
4911 39778 : (_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 24 : 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 325838 : p->mark = _mark;
4926 325838 : 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 325838 : _res = NULL;
4930 326222 : done:
4931 326222 : p->level--;
4932 326222 : 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 342818 : star_etc_rule(Parser *p)
4943 : {
4944 342818 : if (p->level++ == MAXSTACK) {
4945 0 : p->error_indicator = 1;
4946 0 : PyErr_NoMemory();
4947 : }
4948 342818 : if (p->error_indicator) {
4949 0 : p->level--;
4950 0 : return NULL;
4951 : }
4952 342818 : StarEtc* _res = NULL;
4953 342818 : int _mark = p->mark;
4954 342818 : if (p->call_invalid_rules) { // invalid_star_etc
4955 252 : if (p->error_indicator) {
4956 0 : p->level--;
4957 0 : return NULL;
4958 : }
4959 252 : 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 0 : 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 252 : 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 342818 : if (p->error_indicator) {
4975 10 : p->level--;
4976 10 : return NULL;
4977 : }
4978 342808 : 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 342808 : if (
4984 342808 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
4985 33090 : &&
4986 33090 : (a = param_no_default_rule(p)) // param_no_default
4987 27138 : &&
4988 27138 : (b = _loop0_48_rule(p)) // param_maybe_default*
4989 27138 : &&
4990 27138 : (c = kwds_rule(p), !p->error_indicator) // kwds?
4991 : )
4992 : {
4993 27134 : D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?"));
4994 27134 : _res = _PyPegen_star_etc ( p , a , b , c );
4995 27134 : if (_res == NULL && PyErr_Occurred()) {
4996 0 : p->error_indicator = 1;
4997 0 : p->level--;
4998 0 : return NULL;
4999 : }
5000 27134 : goto done;
5001 : }
5002 315674 : p->mark = _mark;
5003 315674 : 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 315674 : if (p->error_indicator) {
5008 4 : p->level--;
5009 4 : return NULL;
5010 : }
5011 315670 : 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 315670 : if (
5017 315670 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
5018 5952 : &&
5019 5952 : (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 20 : 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 315650 : p->mark = _mark;
5036 315650 : 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 315650 : if (p->error_indicator) {
5041 0 : p->level--;
5042 0 : return NULL;
5043 : }
5044 315650 : 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 315650 : if (
5050 315650 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
5051 5932 : &&
5052 5932 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
5053 5922 : &&
5054 5922 : (b = _loop1_50_rule(p)) // param_maybe_default+
5055 5909 : &&
5056 5909 : (c = kwds_rule(p), !p->error_indicator) // kwds?
5057 : )
5058 : {
5059 5909 : D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
5060 5909 : _res = _PyPegen_star_etc ( p , NULL , b , c );
5061 5909 : if (_res == NULL && PyErr_Occurred()) {
5062 0 : p->error_indicator = 1;
5063 0 : p->level--;
5064 0 : return NULL;
5065 : }
5066 5909 : goto done;
5067 : }
5068 309741 : p->mark = _mark;
5069 309741 : 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 309741 : if (p->error_indicator) {
5074 0 : p->level--;
5075 0 : return NULL;
5076 : }
5077 309741 : D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwds"));
5078 : arg_ty a;
5079 309741 : if (
5080 309741 : (a = kwds_rule(p)) // kwds
5081 : )
5082 : {
5083 3524 : D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwds"));
5084 3524 : _res = _PyPegen_star_etc ( p , NULL , NULL , a );
5085 3524 : if (_res == NULL && PyErr_Occurred()) {
5086 0 : p->error_indicator = 1;
5087 0 : p->level--;
5088 0 : return NULL;
5089 : }
5090 3524 : goto done;
5091 : }
5092 306217 : p->mark = _mark;
5093 306217 : 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 306217 : _res = NULL;
5097 342804 : done:
5098 342804 : p->level--;
5099 342804 : return _res;
5100 : }
5101 :
5102 : // kwds: invalid_kwds | '**' param_no_default
5103 : static arg_ty
5104 342808 : kwds_rule(Parser *p)
5105 : {
5106 342808 : if (p->level++ == MAXSTACK) {
5107 0 : p->error_indicator = 1;
5108 0 : PyErr_NoMemory();
5109 : }
5110 342808 : if (p->error_indicator) {
5111 0 : p->level--;
5112 0 : return NULL;
5113 : }
5114 342808 : arg_ty _res = NULL;
5115 342808 : int _mark = p->mark;
5116 342808 : if (p->call_invalid_rules) { // invalid_kwds
5117 242 : if (p->error_indicator) {
5118 0 : p->level--;
5119 0 : return NULL;
5120 : }
5121 242 : 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 0 : 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 242 : 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 342808 : if (p->error_indicator) {
5137 9 : p->level--;
5138 9 : return NULL;
5139 : }
5140 342799 : 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 342799 : if (
5144 342799 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
5145 25435 : &&
5146 25435 : (a = param_no_default_rule(p)) // param_no_default
5147 : )
5148 : {
5149 25427 : D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"));
5150 25427 : _res = a;
5151 25427 : if (_res == NULL && PyErr_Occurred()) {
5152 0 : p->error_indicator = 1;
5153 0 : p->level--;
5154 0 : return NULL;
5155 : }
5156 25427 : goto done;
5157 : }
5158 317372 : p->mark = _mark;
5159 317372 : 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 317372 : _res = NULL;
5163 342799 : done:
5164 342799 : p->level--;
5165 342799 : return _res;
5166 : }
5167 :
5168 : // param_no_default: param ',' TYPE_COMMENT? | param TYPE_COMMENT? &')'
5169 : static arg_ty
5170 4079850 : param_no_default_rule(Parser *p)
5171 : {
5172 4079850 : if (p->level++ == MAXSTACK) {
5173 0 : p->error_indicator = 1;
5174 0 : PyErr_NoMemory();
5175 : }
5176 4079850 : if (p->error_indicator) {
5177 0 : p->level--;
5178 0 : return NULL;
5179 : }
5180 4079850 : arg_ty _res = NULL;
5181 4079850 : int _mark = p->mark;
5182 : { // param ',' TYPE_COMMENT?
5183 4079850 : if (p->error_indicator) {
5184 0 : p->level--;
5185 0 : return NULL;
5186 : }
5187 4079850 : 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 4079850 : if (
5192 4079850 : (a = param_rule(p)) // param
5193 2610540 : &&
5194 2610540 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
5195 1126870 : &&
5196 1126870 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5197 : )
5198 : {
5199 1126870 : D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?"));
5200 1126870 : _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5201 1126870 : if (_res == NULL && PyErr_Occurred()) {
5202 0 : p->error_indicator = 1;
5203 0 : p->level--;
5204 0 : return NULL;
5205 : }
5206 1126870 : goto done;
5207 : }
5208 2952980 : p->mark = _mark;
5209 2952980 : 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 2952980 : if (p->error_indicator) {
5214 18 : p->level--;
5215 18 : return NULL;
5216 : }
5217 2952960 : 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 2952960 : if (
5221 2952960 : (a = param_rule(p)) // param
5222 1483670 : &&
5223 1483670 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5224 1483670 : &&
5225 1483670 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
5226 : )
5227 : {
5228 1282350 : D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'"));
5229 1282350 : _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5230 1282350 : if (_res == NULL && PyErr_Occurred()) {
5231 0 : p->error_indicator = 1;
5232 0 : p->level--;
5233 0 : return NULL;
5234 : }
5235 1282350 : goto done;
5236 : }
5237 1670610 : p->mark = _mark;
5238 1670610 : 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 1670610 : _res = NULL;
5242 4079830 : done:
5243 4079830 : p->level--;
5244 4079830 : 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 5952 : param_no_default_star_annotation_rule(Parser *p)
5252 : {
5253 5952 : if (p->level++ == MAXSTACK) {
5254 0 : p->error_indicator = 1;
5255 0 : PyErr_NoMemory();
5256 : }
5257 5952 : if (p->error_indicator) {
5258 0 : p->level--;
5259 0 : return NULL;
5260 : }
5261 5952 : arg_ty _res = NULL;
5262 5952 : int _mark = p->mark;
5263 : { // param_star_annotation ',' TYPE_COMMENT?
5264 5952 : if (p->error_indicator) {
5265 0 : p->level--;
5266 0 : return NULL;
5267 : }
5268 5952 : 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 5952 : if (
5273 5952 : (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 3 : 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 5949 : p->mark = _mark;
5290 5949 : 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 5949 : if (p->error_indicator) {
5295 0 : p->level--;
5296 0 : return NULL;
5297 : }
5298 5949 : 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 5949 : if (
5302 5949 : (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 17 : 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 5932 : p->mark = _mark;
5319 5932 : 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 5932 : _res = NULL;
5323 5952 : done:
5324 5952 : p->level--;
5325 5952 : return _res;
5326 : }
5327 :
5328 : // param_with_default: param default ',' TYPE_COMMENT? | param default TYPE_COMMENT? &')'
5329 : static NameDefaultPair*
5330 1216990 : param_with_default_rule(Parser *p)
5331 : {
5332 1216990 : if (p->level++ == MAXSTACK) {
5333 0 : p->error_indicator = 1;
5334 0 : PyErr_NoMemory();
5335 : }
5336 1216990 : if (p->error_indicator) {
5337 0 : p->level--;
5338 0 : return NULL;
5339 : }
5340 1216990 : NameDefaultPair* _res = NULL;
5341 1216990 : int _mark = p->mark;
5342 : { // param default ',' TYPE_COMMENT?
5343 1216990 : if (p->error_indicator) {
5344 0 : p->level--;
5345 0 : return NULL;
5346 : }
5347 1216990 : 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 1216990 : if (
5353 1216990 : (a = param_rule(p)) // param
5354 222602 : &&
5355 222602 : (c = default_rule(p)) // default
5356 221822 : &&
5357 221822 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
5358 120441 : &&
5359 120441 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5360 : )
5361 : {
5362 120441 : D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?"));
5363 120441 : _res = _PyPegen_name_default_pair ( p , a , c , tc );
5364 120441 : if (_res == NULL && PyErr_Occurred()) {
5365 0 : p->error_indicator = 1;
5366 0 : p->level--;
5367 0 : return NULL;
5368 : }
5369 120441 : goto done;
5370 : }
5371 1096550 : p->mark = _mark;
5372 1096550 : 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 1096550 : if (p->error_indicator) {
5377 3 : p->level--;
5378 3 : return NULL;
5379 : }
5380 1096550 : 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 1096550 : if (
5385 1096550 : (a = param_rule(p)) // param
5386 102158 : &&
5387 102158 : (c = default_rule(p)) // default
5388 101381 : &&
5389 101381 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5390 101381 : &&
5391 101381 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
5392 : )
5393 : {
5394 101358 : D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'"));
5395 101358 : _res = _PyPegen_name_default_pair ( p , a , c , tc );
5396 101358 : if (_res == NULL && PyErr_Occurred()) {
5397 0 : p->error_indicator = 1;
5398 0 : p->level--;
5399 0 : return NULL;
5400 : }
5401 101358 : goto done;
5402 : }
5403 995190 : p->mark = _mark;
5404 995190 : 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 995190 : _res = NULL;
5408 1216990 : done:
5409 1216990 : p->level--;
5410 1216990 : return _res;
5411 : }
5412 :
5413 : // param_maybe_default:
5414 : // | param default? ',' TYPE_COMMENT?
5415 : // | param default? TYPE_COMMENT? &')'
5416 : static NameDefaultPair*
5417 52141 : param_maybe_default_rule(Parser *p)
5418 : {
5419 52141 : if (p->level++ == MAXSTACK) {
5420 0 : p->error_indicator = 1;
5421 0 : PyErr_NoMemory();
5422 : }
5423 52141 : if (p->error_indicator) {
5424 0 : p->level--;
5425 0 : return NULL;
5426 : }
5427 52141 : NameDefaultPair* _res = NULL;
5428 52141 : int _mark = p->mark;
5429 : { // param default? ',' TYPE_COMMENT?
5430 52141 : if (p->error_indicator) {
5431 0 : p->level--;
5432 0 : return NULL;
5433 : }
5434 52141 : 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 52141 : if (
5440 52141 : (a = param_rule(p)) // param
5441 18605 : &&
5442 18605 : (c = default_rule(p), !p->error_indicator) // default?
5443 18605 : &&
5444 18605 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
5445 13693 : &&
5446 13693 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5447 : )
5448 : {
5449 13693 : D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?"));
5450 13693 : _res = _PyPegen_name_default_pair ( p , a , c , tc );
5451 13693 : if (_res == NULL && PyErr_Occurred()) {
5452 0 : p->error_indicator = 1;
5453 0 : p->level--;
5454 0 : return NULL;
5455 : }
5456 13693 : goto done;
5457 : }
5458 38448 : p->mark = _mark;
5459 38448 : 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 38448 : if (p->error_indicator) {
5464 0 : p->level--;
5465 0 : return NULL;
5466 : }
5467 38448 : 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 38448 : if (
5472 38448 : (a = param_rule(p)) // param
5473 4912 : &&
5474 4912 : (c = default_rule(p), !p->error_indicator) // default?
5475 4912 : &&
5476 4912 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5477 4912 : &&
5478 4912 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
5479 : )
5480 : {
5481 4784 : D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'"));
5482 4784 : _res = _PyPegen_name_default_pair ( p , a , c , tc );
5483 4784 : if (_res == NULL && PyErr_Occurred()) {
5484 0 : p->error_indicator = 1;
5485 0 : p->level--;
5486 0 : return NULL;
5487 : }
5488 4784 : goto done;
5489 : }
5490 33664 : p->mark = _mark;
5491 33664 : 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 33664 : _res = NULL;
5495 52141 : done:
5496 52141 : p->level--;
5497 52141 : return _res;
5498 : }
5499 :
5500 : // param: NAME annotation?
5501 : static arg_ty
5502 9437020 : param_rule(Parser *p)
5503 : {
5504 9437020 : if (p->level++ == MAXSTACK) {
5505 0 : p->error_indicator = 1;
5506 0 : PyErr_NoMemory();
5507 : }
5508 9437020 : if (p->error_indicator) {
5509 0 : p->level--;
5510 0 : return NULL;
5511 : }
5512 9437020 : arg_ty _res = NULL;
5513 9437020 : int _mark = p->mark;
5514 9437020 : 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 9437020 : int _start_lineno = p->tokens[_mark]->lineno;
5520 : UNUSED(_start_lineno); // Only used by EXTRA macro
5521 9437020 : int _start_col_offset = p->tokens[_mark]->col_offset;
5522 : UNUSED(_start_col_offset); // Only used by EXTRA macro
5523 : { // NAME annotation?
5524 9437020 : if (p->error_indicator) {
5525 0 : p->level--;
5526 0 : return NULL;
5527 : }
5528 9437020 : D(fprintf(stderr, "%*c> param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
5529 : expr_ty a;
5530 : void *b;
5531 9437020 : if (
5532 9437020 : (a = _PyPegen_name_token(p)) // NAME
5533 4442550 : &&
5534 4442550 : (b = annotation_rule(p), !p->error_indicator) // annotation?
5535 : )
5536 : {
5537 4442540 : D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
5538 4442540 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5539 4442540 : if (_token == NULL) {
5540 0 : p->level--;
5541 0 : return NULL;
5542 : }
5543 4442540 : int _end_lineno = _token->end_lineno;
5544 : UNUSED(_end_lineno); // Only used by EXTRA macro
5545 4442540 : int _end_col_offset = _token->end_col_offset;
5546 : UNUSED(_end_col_offset); // Only used by EXTRA macro
5547 4442540 : _res = _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA );
5548 4442540 : if (_res == NULL && PyErr_Occurred()) {
5549 0 : p->error_indicator = 1;
5550 0 : p->level--;
5551 0 : return NULL;
5552 : }
5553 4442540 : goto done;
5554 : }
5555 4994480 : p->mark = _mark;
5556 4994480 : 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 4994480 : _res = NULL;
5560 9437020 : done:
5561 9437020 : p->level--;
5562 9437020 : return _res;
5563 : }
5564 :
5565 : // param_star_annotation: NAME star_annotation
5566 : static arg_ty
5567 11901 : param_star_annotation_rule(Parser *p)
5568 : {
5569 11901 : if (p->level++ == MAXSTACK) {
5570 0 : p->error_indicator = 1;
5571 0 : PyErr_NoMemory();
5572 : }
5573 11901 : if (p->error_indicator) {
5574 0 : p->level--;
5575 0 : return NULL;
5576 : }
5577 11901 : arg_ty _res = NULL;
5578 11901 : int _mark = p->mark;
5579 11901 : 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 11901 : int _start_lineno = p->tokens[_mark]->lineno;
5585 : UNUSED(_start_lineno); // Only used by EXTRA macro
5586 11901 : int _start_col_offset = p->tokens[_mark]->col_offset;
5587 : UNUSED(_start_col_offset); // Only used by EXTRA macro
5588 : { // NAME star_annotation
5589 11901 : if (p->error_indicator) {
5590 0 : p->level--;
5591 0 : return NULL;
5592 : }
5593 11901 : 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 11901 : if (
5597 11901 : (a = _PyPegen_name_token(p)) // NAME
5598 47 : &&
5599 47 : (b = star_annotation_rule(p)) // star_annotation
5600 : )
5601 : {
5602 45 : 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 11856 : p->mark = _mark;
5621 11856 : 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 11856 : _res = NULL;
5625 11901 : done:
5626 11901 : p->level--;
5627 11901 : return _res;
5628 : }
5629 :
5630 : // annotation: ':' expression
5631 : static expr_ty
5632 4442550 : annotation_rule(Parser *p)
5633 : {
5634 4442550 : if (p->level++ == MAXSTACK) {
5635 0 : p->error_indicator = 1;
5636 0 : PyErr_NoMemory();
5637 : }
5638 4442550 : if (p->error_indicator) {
5639 0 : p->level--;
5640 0 : return NULL;
5641 : }
5642 4442550 : expr_ty _res = NULL;
5643 4442550 : int _mark = p->mark;
5644 : { // ':' expression
5645 4442550 : if (p->error_indicator) {
5646 0 : p->level--;
5647 0 : return NULL;
5648 : }
5649 4442550 : D(fprintf(stderr, "%*c> annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression"));
5650 : Token * _literal;
5651 : expr_ty a;
5652 4442550 : if (
5653 4442550 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5654 340391 : &&
5655 340391 : (a = expression_rule(p)) // expression
5656 : )
5657 : {
5658 340054 : D(fprintf(stderr, "%*c+ annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression"));
5659 340054 : _res = a;
5660 340054 : if (_res == NULL && PyErr_Occurred()) {
5661 0 : p->error_indicator = 1;
5662 0 : p->level--;
5663 0 : return NULL;
5664 : }
5665 340054 : goto done;
5666 : }
5667 4102500 : p->mark = _mark;
5668 4102500 : D(fprintf(stderr, "%*c%s annotation[%d-%d]: %s failed!\n", p->level, ' ',
5669 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression"));
5670 : }
5671 4102500 : _res = NULL;
5672 4442550 : done:
5673 4442550 : p->level--;
5674 4442550 : 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 0 : 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 47 : 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 45 : 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 2 : 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 350306 : default_rule(Parser *p)
5727 : {
5728 350306 : if (p->level++ == MAXSTACK) {
5729 0 : p->error_indicator = 1;
5730 0 : PyErr_NoMemory();
5731 : }
5732 350306 : if (p->error_indicator) {
5733 0 : p->level--;
5734 0 : return NULL;
5735 : }
5736 350306 : expr_ty _res = NULL;
5737 350306 : int _mark = p->mark;
5738 : { // '=' expression
5739 350306 : if (p->error_indicator) {
5740 0 : p->level--;
5741 0 : return NULL;
5742 : }
5743 350306 : D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression"));
5744 : Token * _literal;
5745 : expr_ty a;
5746 350306 : if (
5747 350306 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
5748 343914 : &&
5749 343914 : (a = expression_rule(p)) // expression
5750 : )
5751 : {
5752 343609 : D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expression"));
5753 343609 : _res = a;
5754 343609 : if (_res == NULL && PyErr_Occurred()) {
5755 0 : p->error_indicator = 1;
5756 0 : p->level--;
5757 0 : return NULL;
5758 : }
5759 343609 : goto done;
5760 : }
5761 6697 : p->mark = _mark;
5762 6697 : 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 1775 : 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 0 : 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 1775 : 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 350306 : done:
5786 350306 : p->level--;
5787 350306 : 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 489180 : if_stmt_rule(Parser *p)
5796 : {
5797 489180 : if (p->level++ == MAXSTACK) {
5798 0 : p->error_indicator = 1;
5799 0 : PyErr_NoMemory();
5800 : }
5801 489180 : if (p->error_indicator) {
5802 0 : p->level--;
5803 0 : return NULL;
5804 : }
5805 489180 : stmt_ty _res = NULL;
5806 489180 : int _mark = p->mark;
5807 489180 : 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 489180 : int _start_lineno = p->tokens[_mark]->lineno;
5813 : UNUSED(_start_lineno); // Only used by EXTRA macro
5814 489180 : int _start_col_offset = p->tokens[_mark]->col_offset;
5815 : UNUSED(_start_col_offset); // Only used by EXTRA macro
5816 489180 : if (p->call_invalid_rules) { // invalid_if_stmt
5817 39 : if (p->error_indicator) {
5818 0 : p->level--;
5819 0 : return NULL;
5820 : }
5821 39 : 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 0 : 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 39 : 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 489180 : if (p->error_indicator) {
5837 6 : p->level--;
5838 6 : return NULL;
5839 : }
5840 489174 : 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 489174 : if (
5847 489174 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
5848 489174 : &&
5849 489174 : (a = named_expression_rule(p)) // named_expression
5850 489168 : &&
5851 489168 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5852 489165 : &&
5853 489165 : (b = block_rule(p)) // block
5854 489096 : &&
5855 489096 : (c = elif_stmt_rule(p)) // elif_stmt
5856 : )
5857 : {
5858 19942 : D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
5859 19942 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5860 19942 : if (_token == NULL) {
5861 0 : p->level--;
5862 0 : return NULL;
5863 : }
5864 19942 : int _end_lineno = _token->end_lineno;
5865 : UNUSED(_end_lineno); // Only used by EXTRA macro
5866 19942 : int _end_col_offset = _token->end_col_offset;
5867 : UNUSED(_end_col_offset); // Only used by EXTRA macro
5868 19942 : _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
5869 19942 : if (_res == NULL && PyErr_Occurred()) {
5870 0 : p->error_indicator = 1;
5871 0 : p->level--;
5872 0 : return NULL;
5873 : }
5874 19942 : goto done;
5875 : }
5876 469232 : p->mark = _mark;
5877 469232 : 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 469232 : if (p->error_indicator) {
5882 24 : p->level--;
5883 24 : return NULL;
5884 : }
5885 469208 : 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 469208 : if (
5892 469208 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
5893 469208 : &&
5894 469208 : (a = named_expression_rule(p)) // named_expression
5895 469202 : &&
5896 469202 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5897 469199 : &&
5898 469199 : (b = block_rule(p)) // block
5899 469147 : &&
5900 469147 : (c = else_block_rule(p), !p->error_indicator) // else_block?
5901 : )
5902 : {
5903 469147 : D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?"));
5904 469147 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5905 469147 : if (_token == NULL) {
5906 0 : p->level--;
5907 0 : return NULL;
5908 : }
5909 469147 : int _end_lineno = _token->end_lineno;
5910 : UNUSED(_end_lineno); // Only used by EXTRA macro
5911 469147 : int _end_col_offset = _token->end_col_offset;
5912 : UNUSED(_end_col_offset); // Only used by EXTRA macro
5913 469147 : _res = _PyAST_If ( a , b , c , EXTRA );
5914 469147 : if (_res == NULL && PyErr_Occurred()) {
5915 0 : p->error_indicator = 1;
5916 0 : p->level--;
5917 0 : return NULL;
5918 : }
5919 469147 : goto done;
5920 : }
5921 61 : p->mark = _mark;
5922 61 : 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 489150 : done:
5927 489150 : p->level--;
5928 489150 : 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 523196 : elif_stmt_rule(Parser *p)
5937 : {
5938 523196 : if (p->level++ == MAXSTACK) {
5939 0 : p->error_indicator = 1;
5940 0 : PyErr_NoMemory();
5941 : }
5942 523196 : if (p->error_indicator) {
5943 0 : p->level--;
5944 0 : return NULL;
5945 : }
5946 523196 : stmt_ty _res = NULL;
5947 523196 : int _mark = p->mark;
5948 523196 : 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 523196 : int _start_lineno = p->tokens[_mark]->lineno;
5954 : UNUSED(_start_lineno); // Only used by EXTRA macro
5955 523196 : int _start_col_offset = p->tokens[_mark]->col_offset;
5956 : UNUSED(_start_col_offset); // Only used by EXTRA macro
5957 523196 : if (p->call_invalid_rules) { // invalid_elif_stmt
5958 8 : if (p->error_indicator) {
5959 0 : p->level--;
5960 0 : return NULL;
5961 : }
5962 8 : 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 0 : 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 8 : 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 523196 : if (p->error_indicator) {
5978 2 : p->level--;
5979 2 : return NULL;
5980 : }
5981 523194 : 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 523194 : if (
5988 523194 : (_keyword = _PyPegen_expect_token(p, 636)) // token='elif'
5989 34108 : &&
5990 34108 : (a = named_expression_rule(p)) // named_expression
5991 34108 : &&
5992 34108 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5993 34107 : &&
5994 34107 : (b = block_rule(p)) // block
5995 34100 : &&
5996 34100 : (c = elif_stmt_rule(p)) // elif_stmt
5997 : )
5998 : {
5999 14155 : D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
6000 14155 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6001 14155 : if (_token == NULL) {
6002 0 : p->level--;
6003 0 : return NULL;
6004 : }
6005 14155 : int _end_lineno = _token->end_lineno;
6006 : UNUSED(_end_lineno); // Only used by EXTRA macro
6007 14155 : int _end_col_offset = _token->end_col_offset;
6008 : UNUSED(_end_col_offset); // Only used by EXTRA macro
6009 14155 : _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
6010 14155 : if (_res == NULL && PyErr_Occurred()) {
6011 0 : p->error_indicator = 1;
6012 0 : p->level--;
6013 0 : return NULL;
6014 : }
6015 14155 : goto done;
6016 : }
6017 509039 : p->mark = _mark;
6018 509039 : 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 509039 : if (p->error_indicator) {
6023 2 : p->level--;
6024 2 : return NULL;
6025 : }
6026 509037 : 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 509037 : if (
6033 509037 : (_keyword = _PyPegen_expect_token(p, 636)) // token='elif'
6034 19951 : &&
6035 19951 : (a = named_expression_rule(p)) // named_expression
6036 19951 : &&
6037 19951 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6038 19950 : &&
6039 19950 : (b = block_rule(p)) // block
6040 19945 : &&
6041 19945 : (c = else_block_rule(p), !p->error_indicator) // else_block?
6042 : )
6043 : {
6044 19942 : D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?"));
6045 19942 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6046 19942 : if (_token == NULL) {
6047 0 : p->level--;
6048 0 : return NULL;
6049 : }
6050 19942 : int _end_lineno = _token->end_lineno;
6051 : UNUSED(_end_lineno); // Only used by EXTRA macro
6052 19942 : int _end_col_offset = _token->end_col_offset;
6053 : UNUSED(_end_col_offset); // Only used by EXTRA macro
6054 19942 : _res = _PyAST_If ( a , b , c , EXTRA );
6055 19942 : if (_res == NULL && PyErr_Occurred()) {
6056 0 : p->error_indicator = 1;
6057 0 : p->level--;
6058 0 : return NULL;
6059 : }
6060 19942 : goto done;
6061 : }
6062 489095 : p->mark = _mark;
6063 489095 : 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 489095 : _res = NULL;
6067 523192 : done:
6068 523192 : p->level--;
6069 523192 : return _res;
6070 : }
6071 :
6072 : // else_block: invalid_else_stmt | 'else' &&':' block
6073 : static asdl_stmt_seq*
6074 604598 : else_block_rule(Parser *p)
6075 : {
6076 604598 : if (p->level++ == MAXSTACK) {
6077 0 : p->error_indicator = 1;
6078 0 : PyErr_NoMemory();
6079 : }
6080 604598 : if (p->error_indicator) {
6081 0 : p->level--;
6082 0 : return NULL;
6083 : }
6084 604598 : asdl_stmt_seq* _res = NULL;
6085 604598 : int _mark = p->mark;
6086 604598 : if (p->call_invalid_rules) { // invalid_else_stmt
6087 6 : if (p->error_indicator) {
6088 0 : p->level--;
6089 0 : return NULL;
6090 : }
6091 6 : 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 0 : 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 6 : 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 604598 : if (p->error_indicator) {
6107 3 : p->level--;
6108 3 : return NULL;
6109 : }
6110 604595 : 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 604595 : if (
6115 604595 : (_keyword = _PyPegen_expect_token(p, 637)) // token='else'
6116 68392 : &&
6117 68392 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6118 68391 : &&
6119 68391 : (b = block_rule(p)) // block
6120 : )
6121 : {
6122 68370 : D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' &&':' block"));
6123 68370 : _res = b;
6124 68370 : if (_res == NULL && PyErr_Occurred()) {
6125 0 : p->error_indicator = 1;
6126 0 : p->level--;
6127 0 : return NULL;
6128 : }
6129 68370 : goto done;
6130 : }
6131 536225 : p->mark = _mark;
6132 536225 : 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 536225 : _res = NULL;
6136 604595 : done:
6137 604595 : p->level--;
6138 604595 : return _res;
6139 : }
6140 :
6141 : // while_stmt: invalid_while_stmt | 'while' named_expression ':' block else_block?
6142 : static stmt_ty
6143 11785 : while_stmt_rule(Parser *p)
6144 : {
6145 11785 : if (p->level++ == MAXSTACK) {
6146 0 : p->error_indicator = 1;
6147 0 : PyErr_NoMemory();
6148 : }
6149 11785 : if (p->error_indicator) {
6150 0 : p->level--;
6151 0 : return NULL;
6152 : }
6153 11785 : stmt_ty _res = NULL;
6154 11785 : int _mark = p->mark;
6155 11785 : 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 11785 : int _start_lineno = p->tokens[_mark]->lineno;
6161 : UNUSED(_start_lineno); // Only used by EXTRA macro
6162 11785 : int _start_col_offset = p->tokens[_mark]->col_offset;
6163 : UNUSED(_start_col_offset); // Only used by EXTRA macro
6164 11785 : if (p->call_invalid_rules) { // invalid_while_stmt
6165 23 : if (p->error_indicator) {
6166 0 : p->level--;
6167 0 : return NULL;
6168 : }
6169 23 : 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 0 : 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 23 : 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 11785 : if (p->error_indicator) {
6185 4 : p->level--;
6186 4 : return NULL;
6187 : }
6188 11781 : 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 11781 : if (
6195 11781 : (_keyword = _PyPegen_expect_token(p, 639)) // token='while'
6196 11781 : &&
6197 11781 : (a = named_expression_rule(p)) // named_expression
6198 11779 : &&
6199 11779 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6200 11776 : &&
6201 11776 : (b = block_rule(p)) // block
6202 11737 : &&
6203 11737 : (c = else_block_rule(p), !p->error_indicator) // else_block?
6204 : )
6205 : {
6206 11737 : D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?"));
6207 11737 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6208 11737 : if (_token == NULL) {
6209 0 : p->level--;
6210 0 : return NULL;
6211 : }
6212 11737 : int _end_lineno = _token->end_lineno;
6213 : UNUSED(_end_lineno); // Only used by EXTRA macro
6214 11737 : int _end_col_offset = _token->end_col_offset;
6215 : UNUSED(_end_col_offset); // Only used by EXTRA macro
6216 11737 : _res = _PyAST_While ( a , b , c , EXTRA );
6217 11737 : if (_res == NULL && PyErr_Occurred()) {
6218 0 : p->error_indicator = 1;
6219 0 : p->level--;
6220 0 : return NULL;
6221 : }
6222 11737 : goto done;
6223 : }
6224 44 : p->mark = _mark;
6225 44 : 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 11781 : done:
6230 11781 : p->level--;
6231 11781 : 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 61778 : for_stmt_rule(Parser *p)
6241 : {
6242 61778 : if (p->level++ == MAXSTACK) {
6243 0 : p->error_indicator = 1;
6244 0 : PyErr_NoMemory();
6245 : }
6246 61778 : if (p->error_indicator) {
6247 0 : p->level--;
6248 0 : return NULL;
6249 : }
6250 61778 : stmt_ty _res = NULL;
6251 61778 : int _mark = p->mark;
6252 61778 : 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 61778 : int _start_lineno = p->tokens[_mark]->lineno;
6258 : UNUSED(_start_lineno); // Only used by EXTRA macro
6259 61778 : int _start_col_offset = p->tokens[_mark]->col_offset;
6260 : UNUSED(_start_col_offset); // Only used by EXTRA macro
6261 61778 : if (p->call_invalid_rules) { // invalid_for_stmt
6262 54 : if (p->error_indicator) {
6263 0 : p->level--;
6264 0 : return NULL;
6265 : }
6266 54 : 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 0 : 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 54 : 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 61778 : if (p->error_indicator) {
6282 3 : p->level--;
6283 3 : return NULL;
6284 : }
6285 61775 : 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 61775 : 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 61775 : if (
6296 61775 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
6297 61500 : &&
6298 61500 : (t = star_targets_rule(p)) // star_targets
6299 61482 : &&
6300 61482 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
6301 : &&
6302 61470 : (_cut_var = 1)
6303 61470 : &&
6304 61470 : (ex = star_expressions_rule(p)) // star_expressions
6305 61470 : &&
6306 61470 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6307 61467 : &&
6308 61467 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6309 61467 : &&
6310 61467 : (b = block_rule(p)) // block
6311 61461 : &&
6312 61461 : (el = else_block_rule(p), !p->error_indicator) // else_block?
6313 : )
6314 : {
6315 61460 : 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 61460 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6317 61460 : if (_token == NULL) {
6318 0 : p->level--;
6319 0 : return NULL;
6320 : }
6321 61460 : int _end_lineno = _token->end_lineno;
6322 : UNUSED(_end_lineno); // Only used by EXTRA macro
6323 61460 : int _end_col_offset = _token->end_col_offset;
6324 : UNUSED(_end_col_offset); // Only used by EXTRA macro
6325 61460 : _res = _PyAST_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
6326 61460 : if (_res == NULL && PyErr_Occurred()) {
6327 0 : p->error_indicator = 1;
6328 0 : p->level--;
6329 0 : return NULL;
6330 : }
6331 61460 : goto done;
6332 : }
6333 315 : p->mark = _mark;
6334 315 : 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 305 : 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 191 : 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 114 : 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 47 : 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 0 : 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 47 : 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 61763 : done:
6426 61763 : p->level--;
6427 61763 : 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 39289 : with_stmt_rule(Parser *p)
6439 : {
6440 39289 : if (p->level++ == MAXSTACK) {
6441 0 : p->error_indicator = 1;
6442 0 : PyErr_NoMemory();
6443 : }
6444 39289 : if (p->error_indicator) {
6445 0 : p->level--;
6446 0 : return NULL;
6447 : }
6448 39289 : stmt_ty _res = NULL;
6449 39289 : int _mark = p->mark;
6450 39289 : 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 39289 : int _start_lineno = p->tokens[_mark]->lineno;
6456 : UNUSED(_start_lineno); // Only used by EXTRA macro
6457 39289 : int _start_col_offset = p->tokens[_mark]->col_offset;
6458 : UNUSED(_start_col_offset); // Only used by EXTRA macro
6459 39289 : 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 63 : 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 0 : 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 63 : 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 39289 : if (p->error_indicator) {
6480 7 : p->level--;
6481 7 : return NULL;
6482 : }
6483 39282 : 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 39282 : if (
6493 39282 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
6494 38635 : &&
6495 38635 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
6496 69 : &&
6497 69 : (a = (asdl_withitem_seq*)_gather_51_rule(p)) // ','.with_item+
6498 68 : &&
6499 68 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
6500 68 : &&
6501 68 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
6502 68 : &&
6503 68 : (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
6504 32 : &&
6505 32 : (b = block_rule(p)) // block
6506 : )
6507 : {
6508 31 : D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block"));
6509 31 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6510 31 : if (_token == NULL) {
6511 0 : p->level--;
6512 0 : return NULL;
6513 : }
6514 31 : int _end_lineno = _token->end_lineno;
6515 : UNUSED(_end_lineno); // Only used by EXTRA macro
6516 31 : int _end_col_offset = _token->end_col_offset;
6517 : UNUSED(_end_col_offset); // Only used by EXTRA macro
6518 31 : _res = _PyAST_With ( a , b , NULL , EXTRA );
6519 31 : if (_res == NULL && PyErr_Occurred()) {
6520 0 : p->error_indicator = 1;
6521 0 : p->level--;
6522 0 : return NULL;
6523 : }
6524 31 : goto done;
6525 : }
6526 39251 : p->mark = _mark;
6527 39251 : 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 39251 : if (p->error_indicator) {
6532 0 : p->level--;
6533 0 : return NULL;
6534 : }
6535 39251 : 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 39251 : if (
6542 39251 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
6543 38604 : &&
6544 38604 : (a = (asdl_withitem_seq*)_gather_53_rule(p)) // ','.with_item+
6545 38584 : &&
6546 38584 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6547 38558 : &&
6548 38558 : (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6549 38558 : &&
6550 38558 : (b = block_rule(p)) // block
6551 : )
6552 : {
6553 38552 : D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
6554 38552 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6555 38552 : if (_token == NULL) {
6556 0 : p->level--;
6557 0 : return NULL;
6558 : }
6559 38552 : int _end_lineno = _token->end_lineno;
6560 : UNUSED(_end_lineno); // Only used by EXTRA macro
6561 38552 : int _end_col_offset = _token->end_col_offset;
6562 : UNUSED(_end_col_offset); // Only used by EXTRA macro
6563 38552 : _res = _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
6564 38552 : if (_res == NULL && PyErr_Occurred()) {
6565 0 : p->error_indicator = 1;
6566 0 : p->level--;
6567 0 : return NULL;
6568 : }
6569 38552 : goto done;
6570 : }
6571 699 : p->mark = _mark;
6572 699 : 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 688 : 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 0 : 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 688 : 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 688 : 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 371 : 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 317 : 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 45 : 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 0 : 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 45 : 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 39271 : done:
6699 39271 : p->level--;
6700 39271 : return _res;
6701 : }
6702 :
6703 : // with_item:
6704 : // | expression 'as' star_target &(',' | ')' | ':')
6705 : // | invalid_with_item
6706 : // | expression
6707 : static withitem_ty
6708 39873 : with_item_rule(Parser *p)
6709 : {
6710 39873 : if (p->level++ == MAXSTACK) {
6711 0 : p->error_indicator = 1;
6712 0 : PyErr_NoMemory();
6713 : }
6714 39873 : if (p->error_indicator) {
6715 0 : p->level--;
6716 0 : return NULL;
6717 : }
6718 39873 : withitem_ty _res = NULL;
6719 39873 : int _mark = p->mark;
6720 : { // expression 'as' star_target &(',' | ')' | ':')
6721 39873 : if (p->error_indicator) {
6722 0 : p->level--;
6723 0 : return NULL;
6724 : }
6725 39873 : 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 39873 : if (
6730 39873 : (e = expression_rule(p)) // expression
6731 39852 : &&
6732 39852 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
6733 16863 : &&
6734 16863 : (t = star_target_rule(p)) // star_target
6735 16845 : &&
6736 16845 : _PyPegen_lookahead(1, _tmp_59_rule, p)
6737 : )
6738 : {
6739 16835 : D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
6740 16835 : _res = _PyAST_withitem ( e , t , p -> arena );
6741 16835 : if (_res == NULL && PyErr_Occurred()) {
6742 0 : p->error_indicator = 1;
6743 0 : p->level--;
6744 0 : return NULL;
6745 : }
6746 16835 : goto done;
6747 : }
6748 23038 : p->mark = _mark;
6749 23038 : 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 23038 : if (p->call_invalid_rules) { // invalid_with_item
6753 28 : if (p->error_indicator) {
6754 0 : p->level--;
6755 0 : return NULL;
6756 : }
6757 28 : 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 0 : 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 28 : 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 23038 : if (p->error_indicator) {
6773 11 : p->level--;
6774 11 : return NULL;
6775 : }
6776 23027 : D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
6777 : expr_ty e;
6778 23027 : if (
6779 23027 : (e = expression_rule(p)) // expression
6780 : )
6781 : {
6782 23006 : D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
6783 23006 : _res = _PyAST_withitem ( e , NULL , p -> arena );
6784 23006 : if (_res == NULL && PyErr_Occurred()) {
6785 0 : p->error_indicator = 1;
6786 0 : p->level--;
6787 0 : return NULL;
6788 : }
6789 23006 : goto done;
6790 : }
6791 21 : p->mark = _mark;
6792 21 : 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 39862 : done:
6797 39862 : p->level--;
6798 39862 : 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 49660 : try_stmt_rule(Parser *p)
6808 : {
6809 49660 : if (p->level++ == MAXSTACK) {
6810 0 : p->error_indicator = 1;
6811 0 : PyErr_NoMemory();
6812 : }
6813 49660 : if (p->error_indicator) {
6814 0 : p->level--;
6815 0 : return NULL;
6816 : }
6817 49660 : stmt_ty _res = NULL;
6818 49660 : int _mark = p->mark;
6819 49660 : 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 49660 : int _start_lineno = p->tokens[_mark]->lineno;
6825 : UNUSED(_start_lineno); // Only used by EXTRA macro
6826 49660 : int _start_col_offset = p->tokens[_mark]->col_offset;
6827 : UNUSED(_start_col_offset); // Only used by EXTRA macro
6828 49660 : if (p->call_invalid_rules) { // invalid_try_stmt
6829 51 : if (p->error_indicator) {
6830 0 : p->level--;
6831 0 : return NULL;
6832 : }
6833 51 : 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 0 : 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 51 : 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 49660 : if (p->error_indicator) {
6849 29 : p->level--;
6850 29 : return NULL;
6851 : }
6852 49631 : 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 49631 : if (
6858 49631 : (_keyword = _PyPegen_expect_token(p, 618)) // token='try'
6859 49631 : &&
6860 49631 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6861 49628 : &&
6862 49628 : (b = block_rule(p)) // block
6863 49606 : &&
6864 49606 : (f = finally_block_rule(p)) // finally_block
6865 : )
6866 : {
6867 7449 : D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &&':' block finally_block"));
6868 7449 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6869 7449 : if (_token == NULL) {
6870 0 : p->level--;
6871 0 : return NULL;
6872 : }
6873 7449 : int _end_lineno = _token->end_lineno;
6874 : UNUSED(_end_lineno); // Only used by EXTRA macro
6875 7449 : int _end_col_offset = _token->end_col_offset;
6876 : UNUSED(_end_col_offset); // Only used by EXTRA macro
6877 7449 : _res = _PyAST_Try ( b , NULL , NULL , f , EXTRA );
6878 7449 : if (_res == NULL && PyErr_Occurred()) {
6879 0 : p->error_indicator = 1;
6880 0 : p->level--;
6881 0 : return NULL;
6882 : }
6883 7449 : goto done;
6884 : }
6885 42182 : p->mark = _mark;
6886 42182 : 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 42182 : if (p->error_indicator) {
6891 4 : p->level--;
6892 4 : return NULL;
6893 : }
6894 42178 : 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 42178 : if (
6902 42178 : (_keyword = _PyPegen_expect_token(p, 618)) // token='try'
6903 42178 : &&
6904 42178 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6905 42178 : &&
6906 42178 : (b = block_rule(p)) // block
6907 42157 : &&
6908 42157 : (ex = (asdl_excepthandler_seq*)_loop1_60_rule(p)) // except_block+
6909 41860 : &&
6910 41860 : (el = else_block_rule(p), !p->error_indicator) // else_block?
6911 41860 : &&
6912 41860 : (f = finally_block_rule(p), !p->error_indicator) // finally_block?
6913 : )
6914 : {
6915 41859 : 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 41859 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6917 41859 : if (_token == NULL) {
6918 0 : p->level--;
6919 0 : return NULL;
6920 : }
6921 41859 : int _end_lineno = _token->end_lineno;
6922 : UNUSED(_end_lineno); // Only used by EXTRA macro
6923 41859 : int _end_col_offset = _token->end_col_offset;
6924 : UNUSED(_end_col_offset); // Only used by EXTRA macro
6925 41859 : _res = _PyAST_Try ( b , ex , el , f , EXTRA );
6926 41859 : if (_res == NULL && PyErr_Occurred()) {
6927 0 : p->error_indicator = 1;
6928 0 : p->level--;
6929 0 : return NULL;
6930 : }
6931 41859 : goto done;
6932 : }
6933 319 : p->mark = _mark;
6934 319 : 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 318 : 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 255 : 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 63 : 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 49626 : done:
6987 49626 : p->level--;
6988 49626 : 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 86737 : except_block_rule(Parser *p)
6998 : {
6999 86737 : if (p->level++ == MAXSTACK) {
7000 0 : p->error_indicator = 1;
7001 0 : PyErr_NoMemory();
7002 : }
7003 86737 : if (p->error_indicator) {
7004 0 : p->level--;
7005 0 : return NULL;
7006 : }
7007 86737 : excepthandler_ty _res = NULL;
7008 86737 : int _mark = p->mark;
7009 86737 : 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 86737 : int _start_lineno = p->tokens[_mark]->lineno;
7015 : UNUSED(_start_lineno); // Only used by EXTRA macro
7016 86737 : int _start_col_offset = p->tokens[_mark]->col_offset;
7017 : UNUSED(_start_col_offset); // Only used by EXTRA macro
7018 86737 : 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 78 : 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 0 : 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 78 : 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 86737 : if (p->error_indicator) {
7039 2 : p->level--;
7040 2 : return NULL;
7041 : }
7042 86735 : 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 86735 : if (
7049 86735 : (_keyword = _PyPegen_expect_token(p, 629)) // token='except'
7050 44840 : &&
7051 44840 : (e = expression_rule(p)) // expression
7052 42367 : &&
7053 42367 : (t = _tmp_62_rule(p), !p->error_indicator) // ['as' NAME]
7054 42367 : &&
7055 42367 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7056 42356 : &&
7057 42356 : (b = block_rule(p)) // block
7058 : )
7059 : {
7060 42355 : D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
7061 42355 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7062 42355 : if (_token == NULL) {
7063 0 : p->level--;
7064 0 : return NULL;
7065 : }
7066 42355 : int _end_lineno = _token->end_lineno;
7067 : UNUSED(_end_lineno); // Only used by EXTRA macro
7068 42355 : int _end_col_offset = _token->end_col_offset;
7069 : UNUSED(_end_col_offset); // Only used by EXTRA macro
7070 42355 : _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
7071 42355 : if (_res == NULL && PyErr_Occurred()) {
7072 0 : p->error_indicator = 1;
7073 0 : p->level--;
7074 0 : return NULL;
7075 : }
7076 42355 : goto done;
7077 : }
7078 44380 : p->mark = _mark;
7079 44380 : 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 44380 : if (p->error_indicator) {
7084 0 : p->level--;
7085 0 : return NULL;
7086 : }
7087 44380 : 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 44380 : if (
7092 44380 : (_keyword = _PyPegen_expect_token(p, 629)) // token='except'
7093 2485 : &&
7094 2485 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7095 2178 : &&
7096 2178 : (b = block_rule(p)) // block
7097 : )
7098 : {
7099 2175 : D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' block"));
7100 2175 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7101 2175 : if (_token == NULL) {
7102 0 : p->level--;
7103 0 : return NULL;
7104 : }
7105 2175 : int _end_lineno = _token->end_lineno;
7106 : UNUSED(_end_lineno); // Only used by EXTRA macro
7107 2175 : int _end_col_offset = _token->end_col_offset;
7108 : UNUSED(_end_col_offset); // Only used by EXTRA macro
7109 2175 : _res = _PyAST_ExceptHandler ( NULL , NULL , b , EXTRA );
7110 2175 : if (_res == NULL && PyErr_Occurred()) {
7111 0 : p->error_indicator = 1;
7112 0 : p->level--;
7113 0 : return NULL;
7114 : }
7115 2175 : goto done;
7116 : }
7117 42205 : p->mark = _mark;
7118 42205 : 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 42205 : if (p->call_invalid_rules) { // invalid_except_stmt
7122 61 : if (p->error_indicator) {
7123 0 : p->level--;
7124 0 : return NULL;
7125 : }
7126 61 : 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 0 : 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 61 : 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 42205 : _res = NULL;
7141 86735 : done:
7142 86735 : p->level--;
7143 86735 : 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 0 : 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 58 : 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 0 : 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 58 : 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 658 : 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 331 : 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 327 : 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 42 : 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 0 : 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 42 : 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 91722 : finally_block_rule(Parser *p)
7267 : {
7268 91722 : if (p->level++ == MAXSTACK) {
7269 0 : p->error_indicator = 1;
7270 0 : PyErr_NoMemory();
7271 : }
7272 91722 : if (p->error_indicator) {
7273 0 : p->level--;
7274 0 : return NULL;
7275 : }
7276 91722 : asdl_stmt_seq* _res = NULL;
7277 91722 : int _mark = p->mark;
7278 91722 : if (p->call_invalid_rules) { // invalid_finally_stmt
7279 15 : if (p->error_indicator) {
7280 0 : p->level--;
7281 0 : return NULL;
7282 : }
7283 15 : 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 0 : 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 15 : 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 91722 : if (p->error_indicator) {
7299 2 : p->level--;
7300 2 : return NULL;
7301 : }
7302 91720 : 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 91720 : if (
7307 91720 : (_keyword = _PyPegen_expect_token(p, 625)) // token='finally'
7308 8156 : &&
7309 8156 : (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
7310 8156 : &&
7311 8156 : (a = block_rule(p)) // block
7312 : )
7313 : {
7314 8132 : D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally' &&':' block"));
7315 8132 : _res = a;
7316 8132 : if (_res == NULL && PyErr_Occurred()) {
7317 0 : p->error_indicator = 1;
7318 0 : p->level--;
7319 0 : return NULL;
7320 : }
7321 8132 : goto done;
7322 : }
7323 83588 : p->mark = _mark;
7324 83588 : 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 83588 : _res = NULL;
7328 91720 : done:
7329 91720 : p->level--;
7330 91720 : 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 3011970 : match_stmt_rule(Parser *p)
7338 : {
7339 3011970 : if (p->level++ == MAXSTACK) {
7340 0 : p->error_indicator = 1;
7341 0 : PyErr_NoMemory();
7342 : }
7343 3011970 : if (p->error_indicator) {
7344 0 : p->level--;
7345 0 : return NULL;
7346 : }
7347 3011970 : stmt_ty _res = NULL;
7348 3011970 : int _mark = p->mark;
7349 3011970 : 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 3011970 : int _start_lineno = p->tokens[_mark]->lineno;
7355 : UNUSED(_start_lineno); // Only used by EXTRA macro
7356 3011970 : 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 3011970 : if (p->error_indicator) {
7360 0 : p->level--;
7361 0 : return NULL;
7362 : }
7363 3011970 : 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 3011970 : if (
7372 3011970 : (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"'
7373 2356 : &&
7374 2356 : (subject = subject_expr_rule(p)) // subject_expr
7375 1271 : &&
7376 1271 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7377 1266 : &&
7378 1266 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
7379 1266 : &&
7380 1266 : (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT'
7381 1264 : &&
7382 1264 : (cases = (asdl_match_case_seq*)_loop1_64_rule(p)) // case_block+
7383 1219 : &&
7384 1219 : (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT'
7385 : )
7386 : {
7387 1218 : 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 1218 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7389 1218 : if (_token == NULL) {
7390 0 : p->level--;
7391 0 : return NULL;
7392 : }
7393 1218 : int _end_lineno = _token->end_lineno;
7394 : UNUSED(_end_lineno); // Only used by EXTRA macro
7395 1218 : int _end_col_offset = _token->end_col_offset;
7396 : UNUSED(_end_col_offset); // Only used by EXTRA macro
7397 1218 : _res = CHECK_VERSION ( stmt_ty , 10 , "Pattern matching is" , _PyAST_Match ( subject , cases , EXTRA ) );
7398 1218 : if (_res == NULL && PyErr_Occurred()) {
7399 0 : p->error_indicator = 1;
7400 0 : p->level--;
7401 0 : return NULL;
7402 : }
7403 1218 : goto done;
7404 : }
7405 3010750 : p->mark = _mark;
7406 3010750 : 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 3010750 : if (p->call_invalid_rules) { // invalid_match_stmt
7410 840 : if (p->error_indicator) {
7411 11 : p->level--;
7412 11 : return NULL;
7413 : }
7414 829 : 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 0 : 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 829 : 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 3010740 : _res = NULL;
7429 3011960 : done:
7430 3011960 : p->level--;
7431 3011960 : return _res;
7432 : }
7433 :
7434 : // subject_expr: star_named_expression ',' star_named_expressions? | named_expression
7435 : static expr_ty
7436 2379 : subject_expr_rule(Parser *p)
7437 : {
7438 2379 : if (p->level++ == MAXSTACK) {
7439 0 : p->error_indicator = 1;
7440 0 : PyErr_NoMemory();
7441 : }
7442 2379 : if (p->error_indicator) {
7443 0 : p->level--;
7444 0 : return NULL;
7445 : }
7446 2379 : expr_ty _res = NULL;
7447 2379 : int _mark = p->mark;
7448 2379 : 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 2379 : int _start_lineno = p->tokens[_mark]->lineno;
7454 : UNUSED(_start_lineno); // Only used by EXTRA macro
7455 2379 : 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 2379 : if (p->error_indicator) {
7459 0 : p->level--;
7460 0 : return NULL;
7461 : }
7462 2379 : 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 2379 : if (
7467 2379 : (value = star_named_expression_rule(p)) // star_named_expression
7468 1294 : &&
7469 1294 : (_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 12 : 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 2367 : p->mark = _mark;
7493 2367 : 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 2367 : if (p->error_indicator) {
7498 0 : p->level--;
7499 0 : return NULL;
7500 : }
7501 2367 : D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
7502 : expr_ty named_expression_var;
7503 2367 : if (
7504 2367 : (named_expression_var = named_expression_rule(p)) // named_expression
7505 : )
7506 : {
7507 1282 : D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
7508 1282 : _res = named_expression_var;
7509 1282 : goto done;
7510 : }
7511 1085 : p->mark = _mark;
7512 1085 : 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 1085 : _res = NULL;
7516 2379 : done:
7517 2379 : p->level--;
7518 2379 : return _res;
7519 : }
7520 :
7521 : // case_block: invalid_case_block | "case" patterns guard? ':' block
7522 : static match_case_ty
7523 3039 : case_block_rule(Parser *p)
7524 : {
7525 3039 : if (p->level++ == MAXSTACK) {
7526 0 : p->error_indicator = 1;
7527 0 : PyErr_NoMemory();
7528 : }
7529 3039 : if (p->error_indicator) {
7530 0 : p->level--;
7531 0 : return NULL;
7532 : }
7533 3039 : match_case_ty _res = NULL;
7534 3039 : int _mark = p->mark;
7535 3039 : if (p->call_invalid_rules) { // invalid_case_block
7536 21 : if (p->error_indicator) {
7537 0 : p->level--;
7538 0 : return NULL;
7539 : }
7540 21 : 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 0 : 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 21 : 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 3039 : if (p->error_indicator) {
7556 11 : p->level--;
7557 11 : return NULL;
7558 : }
7559 3028 : 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 3028 : if (
7566 3028 : (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"'
7567 1808 : &&
7568 1808 : (pattern = patterns_rule(p)) // patterns
7569 1784 : &&
7570 1784 : (guard = guard_rule(p), !p->error_indicator) // guard?
7571 1784 : &&
7572 1784 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7573 1779 : &&
7574 1779 : (body = block_rule(p)) // block
7575 : )
7576 : {
7577 1775 : D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' block"));
7578 1775 : _res = _PyAST_match_case ( pattern , guard , body , p -> arena );
7579 1775 : if (_res == NULL && PyErr_Occurred()) {
7580 0 : p->error_indicator = 1;
7581 0 : p->level--;
7582 0 : return NULL;
7583 : }
7584 1775 : goto done;
7585 : }
7586 1253 : p->mark = _mark;
7587 1253 : 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 1253 : _res = NULL;
7591 3028 : done:
7592 3028 : p->level--;
7593 3028 : return _res;
7594 : }
7595 :
7596 : // guard: 'if' named_expression
7597 : static expr_ty
7598 1794 : guard_rule(Parser *p)
7599 : {
7600 1794 : if (p->level++ == MAXSTACK) {
7601 0 : p->error_indicator = 1;
7602 0 : PyErr_NoMemory();
7603 : }
7604 1794 : if (p->error_indicator) {
7605 0 : p->level--;
7606 0 : return NULL;
7607 : }
7608 1794 : expr_ty _res = NULL;
7609 1794 : int _mark = p->mark;
7610 : { // 'if' named_expression
7611 1794 : if (p->error_indicator) {
7612 0 : p->level--;
7613 0 : return NULL;
7614 : }
7615 1794 : 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 1794 : if (
7619 1794 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
7620 207 : &&
7621 207 : (guard = named_expression_rule(p)) // named_expression
7622 : )
7623 : {
7624 207 : 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 1587 : p->mark = _mark;
7634 1587 : 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 1587 : _res = NULL;
7638 1794 : done:
7639 1794 : p->level--;
7640 1794 : return _res;
7641 : }
7642 :
7643 : // patterns: open_sequence_pattern | pattern
7644 : static pattern_ty
7645 1839 : patterns_rule(Parser *p)
7646 : {
7647 1839 : if (p->level++ == MAXSTACK) {
7648 0 : p->error_indicator = 1;
7649 0 : PyErr_NoMemory();
7650 : }
7651 1839 : if (p->error_indicator) {
7652 0 : p->level--;
7653 0 : return NULL;
7654 : }
7655 1839 : pattern_ty _res = NULL;
7656 1839 : int _mark = p->mark;
7657 1839 : 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 1839 : int _start_lineno = p->tokens[_mark]->lineno;
7663 : UNUSED(_start_lineno); // Only used by EXTRA macro
7664 1839 : int _start_col_offset = p->tokens[_mark]->col_offset;
7665 : UNUSED(_start_col_offset); // Only used by EXTRA macro
7666 : { // open_sequence_pattern
7667 1839 : if (p->error_indicator) {
7668 0 : p->level--;
7669 0 : return NULL;
7670 : }
7671 1839 : D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "open_sequence_pattern"));
7672 : asdl_pattern_seq* patterns;
7673 1839 : if (
7674 1839 : (patterns = (asdl_pattern_seq*)open_sequence_pattern_rule(p)) // open_sequence_pattern
7675 : )
7676 : {
7677 74 : 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 1765 : p->mark = _mark;
7696 1765 : 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 1765 : if (p->error_indicator) {
7701 13 : p->level--;
7702 13 : return NULL;
7703 : }
7704 1752 : D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern"));
7705 : pattern_ty pattern_var;
7706 1752 : if (
7707 1752 : (pattern_var = pattern_rule(p)) // pattern
7708 : )
7709 : {
7710 1720 : D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern"));
7711 1720 : _res = pattern_var;
7712 1720 : goto done;
7713 : }
7714 32 : p->mark = _mark;
7715 32 : 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 1826 : done:
7720 1826 : p->level--;
7721 1826 : return _res;
7722 : }
7723 :
7724 : // pattern: as_pattern | or_pattern
7725 : static pattern_ty
7726 6743 : pattern_rule(Parser *p)
7727 : {
7728 6743 : if (p->level++ == MAXSTACK) {
7729 0 : p->error_indicator = 1;
7730 0 : PyErr_NoMemory();
7731 : }
7732 6743 : if (p->error_indicator) {
7733 0 : p->level--;
7734 0 : return NULL;
7735 : }
7736 6743 : pattern_ty _res = NULL;
7737 6743 : int _mark = p->mark;
7738 : { // as_pattern
7739 6743 : if (p->error_indicator) {
7740 0 : p->level--;
7741 0 : return NULL;
7742 : }
7743 6743 : D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "as_pattern"));
7744 : pattern_ty as_pattern_var;
7745 6743 : if (
7746 6743 : (as_pattern_var = as_pattern_rule(p)) // as_pattern
7747 : )
7748 : {
7749 228 : 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 6515 : p->mark = _mark;
7754 6515 : 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 6515 : if (p->error_indicator) {
7759 13 : p->level--;
7760 13 : return NULL;
7761 : }
7762 6502 : D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern"));
7763 : pattern_ty or_pattern_var;
7764 6502 : if (
7765 6502 : (or_pattern_var = or_pattern_rule(p)) // or_pattern
7766 : )
7767 : {
7768 6133 : D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern"));
7769 6133 : _res = or_pattern_var;
7770 6133 : goto done;
7771 : }
7772 369 : p->mark = _mark;
7773 369 : 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 369 : _res = NULL;
7777 6730 : done:
7778 6730 : p->level--;
7779 6730 : return _res;
7780 : }
7781 :
7782 : // as_pattern: or_pattern 'as' pattern_capture_target | invalid_as_pattern
7783 : static pattern_ty
7784 6743 : as_pattern_rule(Parser *p)
7785 : {
7786 6743 : if (p->level++ == MAXSTACK) {
7787 0 : p->error_indicator = 1;
7788 0 : PyErr_NoMemory();
7789 : }
7790 6743 : if (p->error_indicator) {
7791 0 : p->level--;
7792 0 : return NULL;
7793 : }
7794 6743 : pattern_ty _res = NULL;
7795 6743 : int _mark = p->mark;
7796 6743 : 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 6743 : int _start_lineno = p->tokens[_mark]->lineno;
7802 : UNUSED(_start_lineno); // Only used by EXTRA macro
7803 6743 : 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 6743 : if (p->error_indicator) {
7807 0 : p->level--;
7808 0 : return NULL;
7809 : }
7810 6743 : 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 6743 : if (
7815 6743 : (pattern = or_pattern_rule(p)) // or_pattern
7816 6364 : &&
7817 6364 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
7818 237 : &&
7819 237 : (target = pattern_capture_target_rule(p)) // pattern_capture_target
7820 : )
7821 : {
7822 228 : 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 6515 : p->mark = _mark;
7841 6515 : 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 6515 : if (p->call_invalid_rules) { // invalid_as_pattern
7845 111 : if (p->error_indicator) {
7846 4 : p->level--;
7847 4 : return NULL;
7848 : }
7849 107 : 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 0 : 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 107 : 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 6511 : _res = NULL;
7864 6739 : done:
7865 6739 : p->level--;
7866 6739 : return _res;
7867 : }
7868 :
7869 : // or_pattern: '|'.closed_pattern+
7870 : static pattern_ty
7871 13457 : or_pattern_rule(Parser *p)
7872 : {
7873 13457 : if (p->level++ == MAXSTACK) {
7874 0 : p->error_indicator = 1;
7875 0 : PyErr_NoMemory();
7876 : }
7877 13457 : if (p->error_indicator) {
7878 0 : p->level--;
7879 0 : return NULL;
7880 : }
7881 13457 : pattern_ty _res = NULL;
7882 13457 : int _mark = p->mark;
7883 13457 : 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 13457 : int _start_lineno = p->tokens[_mark]->lineno;
7889 : UNUSED(_start_lineno); // Only used by EXTRA macro
7890 13457 : int _start_col_offset = p->tokens[_mark]->col_offset;
7891 : UNUSED(_start_col_offset); // Only used by EXTRA macro
7892 : { // '|'.closed_pattern+
7893 13457 : if (p->error_indicator) {
7894 0 : p->level--;
7895 0 : return NULL;
7896 : }
7897 13457 : D(fprintf(stderr, "%*c> or_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+"));
7898 : asdl_pattern_seq* patterns;
7899 13457 : if (
7900 13457 : (patterns = (asdl_pattern_seq*)_gather_65_rule(p)) // '|'.closed_pattern+
7901 : )
7902 : {
7903 12593 : D(fprintf(stderr, "%*c+ or_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+"));
7904 12593 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7905 12593 : if (_token == NULL) {
7906 0 : p->level--;
7907 0 : return NULL;
7908 : }
7909 12593 : int _end_lineno = _token->end_lineno;
7910 : UNUSED(_end_lineno); // Only used by EXTRA macro
7911 12593 : int _end_col_offset = _token->end_col_offset;
7912 : UNUSED(_end_col_offset); // Only used by EXTRA macro
7913 12593 : _res = asdl_seq_LEN ( patterns ) == 1 ? asdl_seq_GET ( patterns , 0 ) : _PyAST_MatchOr ( patterns , EXTRA );
7914 12593 : if (_res == NULL && PyErr_Occurred()) {
7915 0 : p->error_indicator = 1;
7916 0 : p->level--;
7917 0 : return NULL;
7918 : }
7919 12593 : goto done;
7920 : }
7921 864 : p->mark = _mark;
7922 864 : 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 864 : _res = NULL;
7926 13457 : done:
7927 13457 : p->level--;
7928 13457 : 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 14685 : closed_pattern_rule(Parser *p)
7942 : {
7943 14685 : if (p->level++ == MAXSTACK) {
7944 0 : p->error_indicator = 1;
7945 0 : PyErr_NoMemory();
7946 : }
7947 14685 : if (p->error_indicator) {
7948 0 : p->level--;
7949 0 : return NULL;
7950 : }
7951 14685 : pattern_ty _res = NULL;
7952 14685 : if (_PyPegen_is_memoized(p, closed_pattern_type, &_res)) {
7953 9907 : p->level--;
7954 9907 : return _res;
7955 : }
7956 4778 : int _mark = p->mark;
7957 : { // literal_pattern
7958 4778 : if (p->error_indicator) {
7959 0 : p->level--;
7960 0 : return NULL;
7961 : }
7962 4778 : D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_pattern"));
7963 : pattern_ty literal_pattern_var;
7964 4778 : if (
7965 4778 : (literal_pattern_var = literal_pattern_rule(p)) // literal_pattern
7966 : )
7967 : {
7968 1548 : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_pattern"));
7969 1548 : _res = literal_pattern_var;
7970 1548 : goto done;
7971 : }
7972 3230 : p->mark = _mark;
7973 3230 : 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 3230 : if (p->error_indicator) {
7978 3 : p->level--;
7979 3 : return NULL;
7980 : }
7981 3227 : D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "capture_pattern"));
7982 : pattern_ty capture_pattern_var;
7983 3227 : if (
7984 3227 : (capture_pattern_var = capture_pattern_rule(p)) // capture_pattern
7985 : )
7986 : {
7987 992 : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "capture_pattern"));
7988 992 : _res = capture_pattern_var;
7989 992 : goto done;
7990 : }
7991 2235 : p->mark = _mark;
7992 2235 : 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 2235 : if (p->error_indicator) {
7997 0 : p->level--;
7998 0 : return NULL;
7999 : }
8000 2235 : D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "wildcard_pattern"));
8001 : pattern_ty wildcard_pattern_var;
8002 2235 : if (
8003 2235 : (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern
8004 : )
8005 : {
8006 250 : 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 1985 : p->mark = _mark;
8011 1985 : 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 1985 : if (p->error_indicator) {
8016 0 : p->level--;
8017 0 : return NULL;
8018 : }
8019 1985 : D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "value_pattern"));
8020 : pattern_ty value_pattern_var;
8021 1985 : if (
8022 1985 : (value_pattern_var = value_pattern_rule(p)) // value_pattern
8023 : )
8024 : {
8025 60 : 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 1925 : p->mark = _mark;
8030 1925 : 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 1925 : if (p->error_indicator) {
8035 0 : p->level--;
8036 0 : return NULL;
8037 : }
8038 1925 : D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group_pattern"));
8039 : pattern_ty group_pattern_var;
8040 1925 : if (
8041 1925 : (group_pattern_var = group_pattern_rule(p)) // group_pattern
8042 : )
8043 : {
8044 257 : 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 1668 : p->mark = _mark;
8049 1668 : 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 1668 : if (p->error_indicator) {
8054 0 : p->level--;
8055 0 : return NULL;
8056 : }
8057 1668 : D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sequence_pattern"));
8058 : pattern_ty sequence_pattern_var;
8059 1668 : if (
8060 1668 : (sequence_pattern_var = sequence_pattern_rule(p)) // sequence_pattern
8061 : )
8062 : {
8063 684 : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sequence_pattern"));
8064 684 : _res = sequence_pattern_var;
8065 684 : goto done;
8066 : }
8067 984 : p->mark = _mark;
8068 984 : 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 984 : if (p->error_indicator) {
8073 0 : p->level--;
8074 0 : return NULL;
8075 : }
8076 984 : D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "mapping_pattern"));
8077 : pattern_ty mapping_pattern_var;
8078 984 : if (
8079 984 : (mapping_pattern_var = mapping_pattern_rule(p)) // mapping_pattern
8080 : )
8081 : {
8082 429 : 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 555 : p->mark = _mark;
8087 555 : 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 555 : if (p->error_indicator) {
8092 3 : p->level--;
8093 3 : return NULL;
8094 : }
8095 552 : D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_pattern"));
8096 : pattern_ty class_pattern_var;
8097 552 : if (
8098 552 : (class_pattern_var = class_pattern_rule(p)) // class_pattern
8099 : )
8100 : {
8101 288 : D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_pattern"));
8102 288 : _res = class_pattern_var;
8103 288 : goto done;
8104 : }
8105 264 : p->mark = _mark;
8106 264 : 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 264 : _res = NULL;
8110 4772 : done:
8111 4772 : _PyPegen_insert_memo(p, _mark, closed_pattern_type, _res);
8112 4772 : p->level--;
8113 4772 : 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 4778 : literal_pattern_rule(Parser *p)
8125 : {
8126 4778 : if (p->level++ == MAXSTACK) {
8127 0 : p->error_indicator = 1;
8128 0 : PyErr_NoMemory();
8129 : }
8130 4778 : if (p->error_indicator) {
8131 0 : p->level--;
8132 0 : return NULL;
8133 : }
8134 4778 : pattern_ty _res = NULL;
8135 4778 : int _mark = p->mark;
8136 4778 : 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 4778 : int _start_lineno = p->tokens[_mark]->lineno;
8142 : UNUSED(_start_lineno); // Only used by EXTRA macro
8143 4778 : int _start_col_offset = p->tokens[_mark]->col_offset;
8144 : UNUSED(_start_col_offset); // Only used by EXTRA macro
8145 : { // signed_number !('+' | '-')
8146 4778 : if (p->error_indicator) {
8147 0 : p->level--;
8148 0 : return NULL;
8149 : }
8150 4778 : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')"));
8151 : expr_ty value;
8152 4778 : if (
8153 4778 : (value = signed_number_rule(p)) // signed_number
8154 1353 : &&
8155 1353 : _PyPegen_lookahead(0, _tmp_67_rule, p)
8156 : )
8157 : {
8158 1310 : 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 3468 : p->mark = _mark;
8177 3468 : 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 3468 : if (p->error_indicator) {
8182 0 : p->level--;
8183 0 : return NULL;
8184 : }
8185 3468 : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number"));
8186 : expr_ty value;
8187 3468 : if (
8188 3468 : (value = complex_number_rule(p)) // complex_number
8189 : )
8190 : {
8191 40 : 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 3428 : p->mark = _mark;
8210 3428 : 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 3428 : if (p->error_indicator) {
8215 3 : p->level--;
8216 3 : return NULL;
8217 : }
8218 3425 : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings"));
8219 : expr_ty value;
8220 3425 : if (
8221 3425 : (value = strings_rule(p)) // strings
8222 : )
8223 : {
8224 136 : D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings"));
8225 136 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8226 136 : if (_token == NULL) {
8227 0 : p->level--;
8228 0 : return NULL;
8229 : }
8230 136 : int _end_lineno = _token->end_lineno;
8231 : UNUSED(_end_lineno); // Only used by EXTRA macro
8232 136 : int _end_col_offset = _token->end_col_offset;
8233 : UNUSED(_end_col_offset); // Only used by EXTRA macro
8234 136 : _res = _PyAST_MatchValue ( value , EXTRA );
8235 136 : if (_res == NULL && PyErr_Occurred()) {
8236 0 : p->error_indicator = 1;
8237 0 : p->level--;
8238 0 : return NULL;
8239 : }
8240 136 : goto done;
8241 : }
8242 3289 : p->mark = _mark;
8243 3289 : 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 3289 : if (p->error_indicator) {
8248 0 : p->level--;
8249 0 : return NULL;
8250 : }
8251 3289 : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
8252 : Token * _keyword;
8253 3289 : if (
8254 3289 : (_keyword = _PyPegen_expect_token(p, 601)) // token='None'
8255 : )
8256 : {
8257 32 : 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 3257 : p->mark = _mark;
8276 3257 : 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 3257 : if (p->error_indicator) {
8281 0 : p->level--;
8282 0 : return NULL;
8283 : }
8284 3257 : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
8285 : Token * _keyword;
8286 3257 : if (
8287 3257 : (_keyword = _PyPegen_expect_token(p, 600)) // token='True'
8288 : )
8289 : {
8290 13 : 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 3244 : p->mark = _mark;
8309 3244 : 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 3244 : if (p->error_indicator) {
8314 0 : p->level--;
8315 0 : return NULL;
8316 : }
8317 3244 : D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
8318 : Token * _keyword;
8319 3244 : if (
8320 3244 : (_keyword = _PyPegen_expect_token(p, 602)) // token='False'
8321 : )
8322 : {
8323 17 : 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 3227 : p->mark = _mark;
8342 3227 : 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 3227 : _res = NULL;
8346 4775 : done:
8347 4775 : p->level--;
8348 4775 : 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 0 : 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 809 : 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 570 : 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 239 : 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 239 : 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 8 : 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 231 : 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 228 : 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 174 : 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 54 : 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 54 : 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 0 : 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 54 : 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 54 : 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 0 : 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 54 : 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 54 : 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 2 : 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 52 : 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 3707 : complex_number_rule(Parser *p)
8549 : {
8550 3707 : if (p->level++ == MAXSTACK) {
8551 0 : p->error_indicator = 1;
8552 0 : PyErr_NoMemory();
8553 : }
8554 3707 : if (p->error_indicator) {
8555 0 : p->level--;
8556 0 : return NULL;
8557 : }
8558 3707 : expr_ty _res = NULL;
8559 3707 : int _mark = p->mark;
8560 3707 : 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 3707 : int _start_lineno = p->tokens[_mark]->lineno;
8566 : UNUSED(_start_lineno); // Only used by EXTRA macro
8567 3707 : 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 3707 : if (p->error_indicator) {
8571 0 : p->level--;
8572 0 : return NULL;
8573 : }
8574 3707 : 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 3707 : if (
8579 3707 : (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 20 : 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 3687 : p->mark = _mark;
8605 3687 : 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 3687 : if (p->error_indicator) {
8610 6 : p->level--;
8611 6 : return NULL;
8612 : }
8613 3681 : 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 3681 : if (
8618 3681 : (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 28 : 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 3653 : p->mark = _mark;
8644 3653 : 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 3653 : _res = NULL;
8648 3701 : done:
8649 3701 : p->level--;
8650 3701 : return _res;
8651 : }
8652 :
8653 : // signed_number: NUMBER | '-' NUMBER
8654 : static expr_ty
8655 5587 : signed_number_rule(Parser *p)
8656 : {
8657 5587 : if (p->level++ == MAXSTACK) {
8658 0 : p->error_indicator = 1;
8659 0 : PyErr_NoMemory();
8660 : }
8661 5587 : if (p->error_indicator) {
8662 0 : p->level--;
8663 0 : return NULL;
8664 : }
8665 5587 : expr_ty _res = NULL;
8666 5587 : int _mark = p->mark;
8667 5587 : 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 5587 : int _start_lineno = p->tokens[_mark]->lineno;
8673 : UNUSED(_start_lineno); // Only used by EXTRA macro
8674 5587 : int _start_col_offset = p->tokens[_mark]->col_offset;
8675 : UNUSED(_start_col_offset); // Only used by EXTRA macro
8676 : { // NUMBER
8677 5587 : if (p->error_indicator) {
8678 0 : p->level--;
8679 0 : return NULL;
8680 : }
8681 5587 : D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8682 : expr_ty number_var;
8683 5587 : if (
8684 5587 : (number_var = _PyPegen_number_token(p)) // NUMBER
8685 : )
8686 : {
8687 1856 : 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 3731 : p->mark = _mark;
8692 3731 : 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 3731 : if (p->error_indicator) {
8697 0 : p->level--;
8698 0 : return NULL;
8699 : }
8700 3731 : D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' NUMBER"));
8701 : Token * _literal;
8702 : expr_ty number;
8703 3731 : if (
8704 3731 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
8705 78 : &&
8706 78 : (number = _PyPegen_number_token(p)) // NUMBER
8707 : )
8708 : {
8709 78 : 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 3653 : p->mark = _mark;
8728 3653 : 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 3653 : _res = NULL;
8732 5587 : done:
8733 5587 : p->level--;
8734 5587 : return _res;
8735 : }
8736 :
8737 : // signed_real_number: real_number | '-' real_number
8738 : static expr_ty
8739 7388 : signed_real_number_rule(Parser *p)
8740 : {
8741 7388 : if (p->level++ == MAXSTACK) {
8742 0 : p->error_indicator = 1;
8743 0 : PyErr_NoMemory();
8744 : }
8745 7388 : if (p->error_indicator) {
8746 0 : p->level--;
8747 0 : return NULL;
8748 : }
8749 7388 : expr_ty _res = NULL;
8750 7388 : int _mark = p->mark;
8751 7388 : 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 7388 : int _start_lineno = p->tokens[_mark]->lineno;
8757 : UNUSED(_start_lineno); // Only used by EXTRA macro
8758 7388 : int _start_col_offset = p->tokens[_mark]->col_offset;
8759 : UNUSED(_start_col_offset); // Only used by EXTRA macro
8760 : { // real_number
8761 7388 : if (p->error_indicator) {
8762 0 : p->level--;
8763 0 : return NULL;
8764 : }
8765 7388 : 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 7388 : if (
8768 7388 : (real_number_var = real_number_rule(p)) // real_number
8769 : )
8770 : {
8771 38 : 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 7350 : p->mark = _mark;
8776 7350 : 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 7350 : if (p->error_indicator) {
8781 4 : p->level--;
8782 4 : return NULL;
8783 : }
8784 7346 : 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 7346 : if (
8788 7346 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
8789 40 : &&
8790 40 : (real = real_number_rule(p)) // real_number
8791 : )
8792 : {
8793 40 : 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 7306 : p->mark = _mark;
8812 7306 : 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 7306 : _res = NULL;
8816 7384 : done:
8817 7384 : p->level--;
8818 7384 : return _res;
8819 : }
8820 :
8821 : // real_number: NUMBER
8822 : static expr_ty
8823 7428 : real_number_rule(Parser *p)
8824 : {
8825 7428 : if (p->level++ == MAXSTACK) {
8826 0 : p->error_indicator = 1;
8827 0 : PyErr_NoMemory();
8828 : }
8829 7428 : if (p->error_indicator) {
8830 0 : p->level--;
8831 0 : return NULL;
8832 : }
8833 7428 : expr_ty _res = NULL;
8834 7428 : int _mark = p->mark;
8835 : { // NUMBER
8836 7428 : if (p->error_indicator) {
8837 0 : p->level--;
8838 0 : return NULL;
8839 : }
8840 7428 : D(fprintf(stderr, "%*c> real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8841 : expr_ty real;
8842 7428 : if (
8843 7428 : (real = _PyPegen_number_token(p)) // NUMBER
8844 : )
8845 : {
8846 82 : 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 7346 : p->mark = _mark;
8856 7346 : 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 7346 : _res = NULL;
8860 7424 : done:
8861 7424 : p->level--;
8862 7424 : 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 0 : 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 50 : 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 50 : 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 0 : 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 3227 : capture_pattern_rule(Parser *p)
8912 : {
8913 3227 : if (p->level++ == MAXSTACK) {
8914 0 : p->error_indicator = 1;
8915 0 : PyErr_NoMemory();
8916 : }
8917 3227 : if (p->error_indicator) {
8918 0 : p->level--;
8919 0 : return NULL;
8920 : }
8921 3227 : pattern_ty _res = NULL;
8922 3227 : int _mark = p->mark;
8923 3227 : 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 3227 : int _start_lineno = p->tokens[_mark]->lineno;
8929 : UNUSED(_start_lineno); // Only used by EXTRA macro
8930 3227 : int _start_col_offset = p->tokens[_mark]->col_offset;
8931 : UNUSED(_start_col_offset); // Only used by EXTRA macro
8932 : { // pattern_capture_target
8933 3227 : if (p->error_indicator) {
8934 0 : p->level--;
8935 0 : return NULL;
8936 : }
8937 3227 : D(fprintf(stderr, "%*c> capture_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern_capture_target"));
8938 : expr_ty target;
8939 3227 : if (
8940 3227 : (target = pattern_capture_target_rule(p)) // pattern_capture_target
8941 : )
8942 : {
8943 992 : D(fprintf(stderr, "%*c+ capture_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern_capture_target"));
8944 992 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8945 992 : if (_token == NULL) {
8946 0 : p->level--;
8947 0 : return NULL;
8948 : }
8949 992 : int _end_lineno = _token->end_lineno;
8950 : UNUSED(_end_lineno); // Only used by EXTRA macro
8951 992 : int _end_col_offset = _token->end_col_offset;
8952 : UNUSED(_end_col_offset); // Only used by EXTRA macro
8953 992 : _res = _PyAST_MatchAs ( NULL , target -> v . Name . id , EXTRA );
8954 992 : if (_res == NULL && PyErr_Occurred()) {
8955 0 : p->error_indicator = 1;
8956 0 : p->level--;
8957 0 : return NULL;
8958 : }
8959 992 : goto done;
8960 : }
8961 2235 : p->mark = _mark;
8962 2235 : 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 2235 : _res = NULL;
8966 3227 : done:
8967 3227 : p->level--;
8968 3227 : return _res;
8969 : }
8970 :
8971 : // pattern_capture_target: !"_" NAME !('.' | '(' | '=')
8972 : static expr_ty
8973 3682 : pattern_capture_target_rule(Parser *p)
8974 : {
8975 3682 : if (p->level++ == MAXSTACK) {
8976 0 : p->error_indicator = 1;
8977 0 : PyErr_NoMemory();
8978 : }
8979 3682 : if (p->error_indicator) {
8980 0 : p->level--;
8981 0 : return NULL;
8982 : }
8983 3682 : expr_ty _res = NULL;
8984 3682 : int _mark = p->mark;
8985 : { // !"_" NAME !('.' | '(' | '=')
8986 3682 : if (p->error_indicator) {
8987 0 : p->level--;
8988 0 : return NULL;
8989 : }
8990 3682 : D(fprintf(stderr, "%*c> pattern_capture_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')"));
8991 : expr_ty name;
8992 3682 : if (
8993 3682 : _PyPegen_lookahead_with_string(0, _PyPegen_expect_soft_keyword, p, "_")
8994 3366 : &&
8995 3366 : (name = _PyPegen_name_token(p)) // NAME
8996 1807 : &&
8997 1807 : _PyPegen_lookahead(0, _tmp_69_rule, p)
8998 : )
8999 : {
9000 1378 : D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')"));
9001 1378 : _res = _PyPegen_set_expr_context ( p , name , Store );
9002 1378 : if (_res == NULL && PyErr_Occurred()) {
9003 0 : p->error_indicator = 1;
9004 0 : p->level--;
9005 0 : return NULL;
9006 : }
9007 1378 : goto done;
9008 : }
9009 2304 : p->mark = _mark;
9010 2304 : 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 2304 : _res = NULL;
9014 3682 : done:
9015 3682 : p->level--;
9016 3682 : return _res;
9017 : }
9018 :
9019 : // wildcard_pattern: "_"
9020 : static pattern_ty
9021 2291 : wildcard_pattern_rule(Parser *p)
9022 : {
9023 2291 : if (p->level++ == MAXSTACK) {
9024 0 : p->error_indicator = 1;
9025 0 : PyErr_NoMemory();
9026 : }
9027 2291 : if (p->error_indicator) {
9028 0 : p->level--;
9029 0 : return NULL;
9030 : }
9031 2291 : pattern_ty _res = NULL;
9032 2291 : int _mark = p->mark;
9033 2291 : 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 2291 : int _start_lineno = p->tokens[_mark]->lineno;
9039 : UNUSED(_start_lineno); // Only used by EXTRA macro
9040 2291 : int _start_col_offset = p->tokens[_mark]->col_offset;
9041 : UNUSED(_start_col_offset); // Only used by EXTRA macro
9042 : { // "_"
9043 2291 : if (p->error_indicator) {
9044 0 : p->level--;
9045 0 : return NULL;
9046 : }
9047 2291 : D(fprintf(stderr, "%*c> wildcard_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"_\""));
9048 : expr_ty _keyword;
9049 2291 : if (
9050 2291 : (_keyword = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"'
9051 : )
9052 : {
9053 306 : 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 1985 : p->mark = _mark;
9072 1985 : D(fprintf(stderr, "%*c%s wildcard_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9073 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"_\""));
9074 : }
9075 1985 : _res = NULL;
9076 2291 : done:
9077 2291 : p->level--;
9078 2291 : return _res;
9079 : }
9080 :
9081 : // value_pattern: attr !('.' | '(' | '=')
9082 : static pattern_ty
9083 1985 : value_pattern_rule(Parser *p)
9084 : {
9085 1985 : if (p->level++ == MAXSTACK) {
9086 0 : p->error_indicator = 1;
9087 0 : PyErr_NoMemory();
9088 : }
9089 1985 : if (p->error_indicator) {
9090 0 : p->level--;
9091 0 : return NULL;
9092 : }
9093 1985 : pattern_ty _res = NULL;
9094 1985 : int _mark = p->mark;
9095 1985 : 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 1985 : int _start_lineno = p->tokens[_mark]->lineno;
9101 : UNUSED(_start_lineno); // Only used by EXTRA macro
9102 1985 : int _start_col_offset = p->tokens[_mark]->col_offset;
9103 : UNUSED(_start_col_offset); // Only used by EXTRA macro
9104 : { // attr !('.' | '(' | '=')
9105 1985 : if (p->error_indicator) {
9106 0 : p->level--;
9107 0 : return NULL;
9108 : }
9109 1985 : D(fprintf(stderr, "%*c> value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr !('.' | '(' | '=')"));
9110 : expr_ty attr;
9111 1985 : if (
9112 1985 : (attr = attr_rule(p)) // attr
9113 111 : &&
9114 111 : _PyPegen_lookahead(0, _tmp_70_rule, p)
9115 : )
9116 : {
9117 60 : 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 1925 : p->mark = _mark;
9136 1925 : 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 1925 : _res = NULL;
9140 1985 : done:
9141 1985 : p->level--;
9142 1985 : 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 5924 : attr_rule(Parser *p)
9150 : {
9151 5924 : if (p->level++ == MAXSTACK) {
9152 0 : p->error_indicator = 1;
9153 0 : PyErr_NoMemory();
9154 : }
9155 5924 : expr_ty _res = NULL;
9156 5924 : if (_PyPegen_is_memoized(p, attr_type, &_res)) {
9157 3903 : p->level--;
9158 3903 : return _res;
9159 : }
9160 2021 : int _mark = p->mark;
9161 2021 : int _resmark = p->mark;
9162 151 : while (1) {
9163 2172 : int tmpvar_1 = _PyPegen_update_memo(p, _mark, attr_type, _res);
9164 2172 : if (tmpvar_1) {
9165 0 : p->level--;
9166 0 : return _res;
9167 : }
9168 2172 : p->mark = _mark;
9169 2172 : void *_raw = attr_raw(p);
9170 2172 : if (p->error_indicator) {
9171 0 : p->level--;
9172 0 : return NULL;
9173 : }
9174 2172 : if (_raw == NULL || p->mark <= _resmark)
9175 : break;
9176 151 : _resmark = p->mark;
9177 151 : _res = _raw;
9178 : }
9179 2021 : p->mark = _resmark;
9180 2021 : p->level--;
9181 2021 : return _res;
9182 : }
9183 : static expr_ty
9184 2172 : attr_raw(Parser *p)
9185 : {
9186 2172 : if (p->level++ == MAXSTACK) {
9187 0 : p->error_indicator = 1;
9188 0 : PyErr_NoMemory();
9189 : }
9190 2172 : if (p->error_indicator) {
9191 0 : p->level--;
9192 0 : return NULL;
9193 : }
9194 2172 : expr_ty _res = NULL;
9195 2172 : int _mark = p->mark;
9196 2172 : 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 2172 : int _start_lineno = p->tokens[_mark]->lineno;
9202 : UNUSED(_start_lineno); // Only used by EXTRA macro
9203 2172 : 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 2172 : if (p->error_indicator) {
9207 0 : p->level--;
9208 0 : return NULL;
9209 : }
9210 2172 : 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 2172 : if (
9215 2172 : (value = name_or_attr_rule(p)) // name_or_attr
9216 584 : &&
9217 584 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
9218 151 : &&
9219 151 : (attr = _PyPegen_name_token(p)) // NAME
9220 : )
9221 : {
9222 151 : 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 2021 : p->mark = _mark;
9241 2021 : 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 2021 : _res = NULL;
9245 2172 : done:
9246 2172 : p->level--;
9247 2172 : return _res;
9248 : }
9249 :
9250 : // Left-recursive
9251 : // name_or_attr: attr | NAME
9252 : static expr_ty
9253 3887 : name_or_attr_rule(Parser *p)
9254 : {
9255 3887 : if (p->level++ == MAXSTACK) {
9256 0 : p->error_indicator = 1;
9257 0 : PyErr_NoMemory();
9258 : }
9259 3887 : if (p->error_indicator) {
9260 0 : p->level--;
9261 0 : return NULL;
9262 : }
9263 3887 : expr_ty _res = NULL;
9264 3887 : int _mark = p->mark;
9265 : { // attr
9266 3887 : if (p->error_indicator) {
9267 0 : p->level--;
9268 0 : return NULL;
9269 : }
9270 3887 : D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr"));
9271 : expr_ty attr_var;
9272 3887 : if (
9273 3887 : (attr_var = attr_rule(p)) // attr
9274 : )
9275 : {
9276 219 : 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 3668 : p->mark = _mark;
9281 3668 : 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 3668 : if (p->error_indicator) {
9286 0 : p->level--;
9287 0 : return NULL;
9288 : }
9289 3668 : D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
9290 : expr_ty name_var;
9291 3668 : if (
9292 3668 : (name_var = _PyPegen_name_token(p)) // NAME
9293 : )
9294 : {
9295 1339 : D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
9296 1339 : _res = name_var;
9297 1339 : goto done;
9298 : }
9299 2329 : p->mark = _mark;
9300 2329 : 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 2329 : _res = NULL;
9304 3887 : done:
9305 3887 : p->level--;
9306 3887 : return _res;
9307 : }
9308 :
9309 : // group_pattern: '(' pattern ')'
9310 : static pattern_ty
9311 1925 : group_pattern_rule(Parser *p)
9312 : {
9313 1925 : if (p->level++ == MAXSTACK) {
9314 0 : p->error_indicator = 1;
9315 0 : PyErr_NoMemory();
9316 : }
9317 1925 : if (p->error_indicator) {
9318 0 : p->level--;
9319 0 : return NULL;
9320 : }
9321 1925 : pattern_ty _res = NULL;
9322 1925 : int _mark = p->mark;
9323 : { // '(' pattern ')'
9324 1925 : if (p->error_indicator) {
9325 0 : p->level--;
9326 0 : return NULL;
9327 : }
9328 1925 : 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 1925 : if (
9333 1925 : (_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 257 : 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 1668 : p->mark = _mark;
9350 1668 : 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 1668 : _res = NULL;
9354 1925 : done:
9355 1925 : p->level--;
9356 1925 : return _res;
9357 : }
9358 :
9359 : // sequence_pattern: '[' maybe_sequence_pattern? ']' | '(' open_sequence_pattern? ')'
9360 : static pattern_ty
9361 1668 : sequence_pattern_rule(Parser *p)
9362 : {
9363 1668 : if (p->level++ == MAXSTACK) {
9364 0 : p->error_indicator = 1;
9365 0 : PyErr_NoMemory();
9366 : }
9367 1668 : if (p->error_indicator) {
9368 0 : p->level--;
9369 0 : return NULL;
9370 : }
9371 1668 : pattern_ty _res = NULL;
9372 1668 : int _mark = p->mark;
9373 1668 : 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 1668 : int _start_lineno = p->tokens[_mark]->lineno;
9379 : UNUSED(_start_lineno); // Only used by EXTRA macro
9380 1668 : int _start_col_offset = p->tokens[_mark]->col_offset;
9381 : UNUSED(_start_col_offset); // Only used by EXTRA macro
9382 : { // '[' maybe_sequence_pattern? ']'
9383 1668 : if (p->error_indicator) {
9384 0 : p->level--;
9385 0 : return NULL;
9386 : }
9387 1668 : 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 1668 : if (
9392 1668 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
9393 599 : &&
9394 599 : (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator) // maybe_sequence_pattern?
9395 599 : &&
9396 599 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
9397 : )
9398 : {
9399 599 : D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' maybe_sequence_pattern? ']'"));
9400 599 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9401 599 : if (_token == NULL) {
9402 0 : p->level--;
9403 0 : return NULL;
9404 : }
9405 599 : int _end_lineno = _token->end_lineno;
9406 : UNUSED(_end_lineno); // Only used by EXTRA macro
9407 599 : int _end_col_offset = _token->end_col_offset;
9408 : UNUSED(_end_col_offset); // Only used by EXTRA macro
9409 599 : _res = _PyAST_MatchSequence ( patterns , EXTRA );
9410 599 : if (_res == NULL && PyErr_Occurred()) {
9411 0 : p->error_indicator = 1;
9412 0 : p->level--;
9413 0 : return NULL;
9414 : }
9415 599 : goto done;
9416 : }
9417 1069 : p->mark = _mark;
9418 1069 : 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 1069 : if (p->error_indicator) {
9423 0 : p->level--;
9424 0 : return NULL;
9425 : }
9426 1069 : 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 1069 : if (
9431 1069 : (_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 85 : 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 984 : p->mark = _mark;
9457 984 : 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 984 : _res = NULL;
9461 1668 : done:
9462 1668 : p->level--;
9463 1668 : return _res;
9464 : }
9465 :
9466 : // open_sequence_pattern: maybe_star_pattern ',' maybe_sequence_pattern?
9467 : static asdl_seq*
9468 1924 : open_sequence_pattern_rule(Parser *p)
9469 : {
9470 1924 : if (p->level++ == MAXSTACK) {
9471 0 : p->error_indicator = 1;
9472 0 : PyErr_NoMemory();
9473 : }
9474 1924 : if (p->error_indicator) {
9475 0 : p->level--;
9476 0 : return NULL;
9477 : }
9478 1924 : asdl_seq* _res = NULL;
9479 1924 : int _mark = p->mark;
9480 : { // maybe_star_pattern ',' maybe_sequence_pattern?
9481 1924 : if (p->error_indicator) {
9482 0 : p->level--;
9483 0 : return NULL;
9484 : }
9485 1924 : 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 1924 : if (
9490 1924 : (pattern = maybe_star_pattern_rule(p)) // maybe_star_pattern
9491 1869 : &&
9492 1869 : (_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 149 : 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 1775 : p->mark = _mark;
9507 1775 : 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 1775 : _res = NULL;
9511 1924 : done:
9512 1924 : p->level--;
9513 1924 : return _res;
9514 : }
9515 :
9516 : // maybe_sequence_pattern: ','.maybe_star_pattern+ ','?
9517 : static asdl_seq*
9518 748 : maybe_sequence_pattern_rule(Parser *p)
9519 : {
9520 748 : if (p->level++ == MAXSTACK) {
9521 0 : p->error_indicator = 1;
9522 0 : PyErr_NoMemory();
9523 : }
9524 748 : if (p->error_indicator) {
9525 0 : p->level--;
9526 0 : return NULL;
9527 : }
9528 748 : asdl_seq* _res = NULL;
9529 748 : int _mark = p->mark;
9530 : { // ','.maybe_star_pattern+ ','?
9531 748 : if (p->error_indicator) {
9532 0 : p->level--;
9533 0 : return NULL;
9534 : }
9535 748 : 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 748 : if (
9540 748 : (patterns = _gather_71_rule(p)) // ','.maybe_star_pattern+
9541 622 : &&
9542 622 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9543 : )
9544 : {
9545 622 : D(fprintf(stderr, "%*c+ maybe_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.maybe_star_pattern+ ','?"));
9546 622 : _res = patterns;
9547 622 : if (_res == NULL && PyErr_Occurred()) {
9548 0 : p->error_indicator = 1;
9549 0 : p->level--;
9550 0 : return NULL;
9551 : }
9552 622 : goto done;
9553 : }
9554 126 : p->mark = _mark;
9555 126 : 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 748 : done:
9560 748 : p->level--;
9561 748 : return _res;
9562 : }
9563 :
9564 : // maybe_star_pattern: star_pattern | pattern
9565 : static pattern_ty
9566 3443 : maybe_star_pattern_rule(Parser *p)
9567 : {
9568 3443 : if (p->level++ == MAXSTACK) {
9569 0 : p->error_indicator = 1;
9570 0 : PyErr_NoMemory();
9571 : }
9572 3443 : if (p->error_indicator) {
9573 0 : p->level--;
9574 0 : return NULL;
9575 : }
9576 3443 : pattern_ty _res = NULL;
9577 3443 : int _mark = p->mark;
9578 : { // star_pattern
9579 3443 : if (p->error_indicator) {
9580 0 : p->level--;
9581 0 : return NULL;
9582 : }
9583 3443 : 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 3443 : if (
9586 3443 : (star_pattern_var = star_pattern_rule(p)) // star_pattern
9587 : )
9588 : {
9589 174 : D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_pattern"));
9590 174 : _res = star_pattern_var;
9591 174 : goto done;
9592 : }
9593 3269 : p->mark = _mark;
9594 3269 : 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 3269 : if (p->error_indicator) {
9599 0 : p->level--;
9600 0 : return NULL;
9601 : }
9602 3269 : D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern"));
9603 : pattern_ty pattern_var;
9604 3269 : if (
9605 3269 : (pattern_var = pattern_rule(p)) // pattern
9606 : )
9607 : {
9608 3061 : D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern"));
9609 3061 : _res = pattern_var;
9610 3061 : goto done;
9611 : }
9612 208 : p->mark = _mark;
9613 208 : 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 3443 : done:
9618 3443 : p->level--;
9619 3443 : return _res;
9620 : }
9621 :
9622 : // star_pattern: '*' pattern_capture_target | '*' wildcard_pattern
9623 : static pattern_ty
9624 3443 : star_pattern_rule(Parser *p)
9625 : {
9626 3443 : if (p->level++ == MAXSTACK) {
9627 0 : p->error_indicator = 1;
9628 0 : PyErr_NoMemory();
9629 : }
9630 3443 : if (p->error_indicator) {
9631 0 : p->level--;
9632 0 : return NULL;
9633 : }
9634 3443 : pattern_ty _res = NULL;
9635 3443 : if (_PyPegen_is_memoized(p, star_pattern_type, &_res)) {
9636 20 : p->level--;
9637 20 : return _res;
9638 : }
9639 3423 : int _mark = p->mark;
9640 3423 : 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 3423 : int _start_lineno = p->tokens[_mark]->lineno;
9646 : UNUSED(_start_lineno); // Only used by EXTRA macro
9647 3423 : int _start_col_offset = p->tokens[_mark]->col_offset;
9648 : UNUSED(_start_col_offset); // Only used by EXTRA macro
9649 : { // '*' pattern_capture_target
9650 3423 : if (p->error_indicator) {
9651 0 : p->level--;
9652 0 : return NULL;
9653 : }
9654 3423 : 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 3423 : if (
9658 3423 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
9659 174 : &&
9660 174 : (target = pattern_capture_target_rule(p)) // pattern_capture_target
9661 : )
9662 : {
9663 118 : D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' pattern_capture_target"));
9664 118 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9665 118 : if (_token == NULL) {
9666 0 : p->level--;
9667 0 : return NULL;
9668 : }
9669 118 : int _end_lineno = _token->end_lineno;
9670 : UNUSED(_end_lineno); // Only used by EXTRA macro
9671 118 : int _end_col_offset = _token->end_col_offset;
9672 : UNUSED(_end_col_offset); // Only used by EXTRA macro
9673 118 : _res = _PyAST_MatchStar ( target -> v . Name . id , EXTRA );
9674 118 : if (_res == NULL && PyErr_Occurred()) {
9675 0 : p->error_indicator = 1;
9676 0 : p->level--;
9677 0 : return NULL;
9678 : }
9679 118 : goto done;
9680 : }
9681 3305 : p->mark = _mark;
9682 3305 : 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 3305 : if (p->error_indicator) {
9687 0 : p->level--;
9688 0 : return NULL;
9689 : }
9690 3305 : 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 3305 : if (
9694 3305 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
9695 56 : &&
9696 56 : (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern
9697 : )
9698 : {
9699 56 : 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 3249 : p->mark = _mark;
9718 3249 : 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 3249 : _res = NULL;
9722 3423 : done:
9723 3423 : _PyPegen_insert_memo(p, _mark, star_pattern_type, _res);
9724 3423 : p->level--;
9725 3423 : 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 984 : mapping_pattern_rule(Parser *p)
9735 : {
9736 984 : if (p->level++ == MAXSTACK) {
9737 0 : p->error_indicator = 1;
9738 0 : PyErr_NoMemory();
9739 : }
9740 984 : if (p->error_indicator) {
9741 0 : p->level--;
9742 0 : return NULL;
9743 : }
9744 984 : pattern_ty _res = NULL;
9745 984 : int _mark = p->mark;
9746 984 : 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 984 : int _start_lineno = p->tokens[_mark]->lineno;
9752 : UNUSED(_start_lineno); // Only used by EXTRA macro
9753 984 : int _start_col_offset = p->tokens[_mark]->col_offset;
9754 : UNUSED(_start_col_offset); // Only used by EXTRA macro
9755 : { // '{' '}'
9756 984 : if (p->error_indicator) {
9757 0 : p->level--;
9758 0 : return NULL;
9759 : }
9760 984 : D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'"));
9761 : Token * _literal;
9762 : Token * _literal_1;
9763 984 : if (
9764 984 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9765 444 : &&
9766 444 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
9767 : )
9768 : {
9769 98 : 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 886 : p->mark = _mark;
9788 886 : 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 886 : if (p->error_indicator) {
9793 0 : p->level--;
9794 0 : return NULL;
9795 : }
9796 886 : 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 886 : if (
9803 886 : (_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 12 : 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 874 : p->mark = _mark;
9831 874 : 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 874 : if (p->error_indicator) {
9836 0 : p->level--;
9837 0 : return NULL;
9838 : }
9839 874 : 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 874 : if (
9848 874 : (_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 20 : 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 854 : p->mark = _mark;
9880 854 : 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 854 : if (p->error_indicator) {
9885 3 : p->level--;
9886 3 : return NULL;
9887 : }
9888 851 : 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 851 : if (
9895 851 : (_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 299 : 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 552 : p->mark = _mark;
9923 552 : 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 552 : _res = NULL;
9927 981 : done:
9928 981 : p->level--;
9929 981 : 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 0 : 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 645 : 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 622 : 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 23 : 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 0 : 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 809 : 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 762 : 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 47 : 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 0 : 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 368 : 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 40 : 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 328 : 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 552 : class_pattern_rule(Parser *p)
10076 : {
10077 552 : if (p->level++ == MAXSTACK) {
10078 0 : p->error_indicator = 1;
10079 0 : PyErr_NoMemory();
10080 : }
10081 552 : if (p->error_indicator) {
10082 0 : p->level--;
10083 0 : return NULL;
10084 : }
10085 552 : pattern_ty _res = NULL;
10086 552 : int _mark = p->mark;
10087 552 : 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 552 : int _start_lineno = p->tokens[_mark]->lineno;
10093 : UNUSED(_start_lineno); // Only used by EXTRA macro
10094 552 : int _start_col_offset = p->tokens[_mark]->col_offset;
10095 : UNUSED(_start_col_offset); // Only used by EXTRA macro
10096 : { // name_or_attr '(' ')'
10097 552 : if (p->error_indicator) {
10098 0 : p->level--;
10099 0 : return NULL;
10100 : }
10101 552 : 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 552 : if (
10106 552 : (cls = name_or_attr_rule(p)) // name_or_attr
10107 369 : &&
10108 369 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
10109 296 : &&
10110 296 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
10111 : )
10112 : {
10113 40 : 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 512 : p->mark = _mark;
10132 512 : 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 512 : if (p->error_indicator) {
10137 0 : p->level--;
10138 0 : return NULL;
10139 : }
10140 512 : 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 512 : if (
10148 512 : (cls = name_or_attr_rule(p)) // name_or_attr
10149 329 : &&
10150 329 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
10151 256 : &&
10152 256 : (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 185 : 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 327 : p->mark = _mark;
10178 327 : 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 327 : if (p->error_indicator) {
10183 0 : p->level--;
10184 0 : return NULL;
10185 : }
10186 327 : 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 327 : if (
10194 327 : (cls = name_or_attr_rule(p)) // name_or_attr
10195 144 : &&
10196 144 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
10197 71 : &&
10198 71 : (keywords = keyword_patterns_rule(p)) // keyword_patterns
10199 28 : &&
10200 28 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10201 28 : &&
10202 28 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
10203 : )
10204 : {
10205 22 : D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'"));
10206 22 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10207 22 : if (_token == NULL) {
10208 0 : p->level--;
10209 0 : return NULL;
10210 : }
10211 22 : int _end_lineno = _token->end_lineno;
10212 : UNUSED(_end_lineno); // Only used by EXTRA macro
10213 22 : int _end_col_offset = _token->end_col_offset;
10214 : UNUSED(_end_col_offset); // Only used by EXTRA macro
10215 22 : _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 22 : if (_res == NULL && PyErr_Occurred()) {
10217 0 : p->error_indicator = 1;
10218 0 : p->level--;
10219 0 : return NULL;
10220 : }
10221 22 : goto done;
10222 : }
10223 305 : p->mark = _mark;
10224 305 : 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 305 : if (p->error_indicator) {
10229 0 : p->level--;
10230 0 : return NULL;
10231 : }
10232 305 : 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 305 : if (
10242 305 : (cls = name_or_attr_rule(p)) // name_or_attr
10243 122 : &&
10244 122 : (_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 41 : 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 264 : p->mark = _mark;
10276 264 : 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 264 : if (p->call_invalid_rules) { // invalid_class_pattern
10280 19 : if (p->error_indicator) {
10281 0 : p->level--;
10282 0 : return NULL;
10283 : }
10284 19 : 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 0 : 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 19 : 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 264 : _res = NULL;
10299 552 : done:
10300 552 : p->level--;
10301 552 : return _res;
10302 : }
10303 :
10304 : // positional_patterns: ','.pattern+
10305 : static asdl_pattern_seq*
10306 313 : positional_patterns_rule(Parser *p)
10307 : {
10308 313 : if (p->level++ == MAXSTACK) {
10309 0 : p->error_indicator = 1;
10310 0 : PyErr_NoMemory();
10311 : }
10312 313 : if (p->error_indicator) {
10313 0 : p->level--;
10314 0 : return NULL;
10315 : }
10316 313 : asdl_pattern_seq* _res = NULL;
10317 313 : int _mark = p->mark;
10318 : { // ','.pattern+
10319 313 : if (p->error_indicator) {
10320 0 : p->level--;
10321 0 : return NULL;
10322 : }
10323 313 : D(fprintf(stderr, "%*c> positional_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.pattern+"));
10324 : asdl_pattern_seq* args;
10325 313 : if (
10326 313 : (args = (asdl_pattern_seq*)_gather_76_rule(p)) // ','.pattern+
10327 : )
10328 : {
10329 276 : 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 37 : p->mark = _mark;
10339 37 : 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 37 : _res = NULL;
10343 313 : done:
10344 313 : p->level--;
10345 313 : return _res;
10346 : }
10347 :
10348 : // keyword_patterns: ','.keyword_pattern+
10349 : static asdl_seq*
10350 118 : keyword_patterns_rule(Parser *p)
10351 : {
10352 118 : if (p->level++ == MAXSTACK) {
10353 0 : p->error_indicator = 1;
10354 0 : PyErr_NoMemory();
10355 : }
10356 118 : if (p->error_indicator) {
10357 0 : p->level--;
10358 0 : return NULL;
10359 : }
10360 118 : asdl_seq* _res = NULL;
10361 118 : int _mark = p->mark;
10362 : { // ','.keyword_pattern+
10363 118 : if (p->error_indicator) {
10364 0 : p->level--;
10365 0 : return NULL;
10366 : }
10367 118 : D(fprintf(stderr, "%*c> keyword_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+"));
10368 : asdl_seq * _gather_78_var;
10369 118 : if (
10370 118 : (_gather_78_var = _gather_78_rule(p)) // ','.keyword_pattern+
10371 : )
10372 : {
10373 75 : D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+"));
10374 75 : _res = _gather_78_var;
10375 75 : goto done;
10376 : }
10377 43 : p->mark = _mark;
10378 43 : 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 118 : done:
10383 118 : p->level--;
10384 118 : return _res;
10385 : }
10386 :
10387 : // keyword_pattern: NAME '=' pattern
10388 : static KeyPatternPair*
10389 174 : keyword_pattern_rule(Parser *p)
10390 : {
10391 174 : if (p->level++ == MAXSTACK) {
10392 0 : p->error_indicator = 1;
10393 0 : PyErr_NoMemory();
10394 : }
10395 174 : if (p->error_indicator) {
10396 0 : p->level--;
10397 0 : return NULL;
10398 : }
10399 174 : KeyPatternPair* _res = NULL;
10400 174 : int _mark = p->mark;
10401 : { // NAME '=' pattern
10402 174 : if (p->error_indicator) {
10403 0 : p->level--;
10404 0 : return NULL;
10405 : }
10406 174 : 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 174 : if (
10411 174 : (arg = _PyPegen_name_token(p)) // NAME
10412 170 : &&
10413 170 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
10414 119 : &&
10415 119 : (value = pattern_rule(p)) // pattern
10416 : )
10417 : {
10418 119 : D(fprintf(stderr, "%*c+ keyword_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' pattern"));
10419 119 : _res = _PyPegen_key_pattern_pair ( p , arg , value );
10420 119 : if (_res == NULL && PyErr_Occurred()) {
10421 0 : p->error_indicator = 1;
10422 0 : p->level--;
10423 0 : return NULL;
10424 : }
10425 119 : goto done;
10426 : }
10427 55 : p->mark = _mark;
10428 55 : 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 174 : done:
10433 174 : p->level--;
10434 174 : return _res;
10435 : }
10436 :
10437 : // expressions: expression ((',' expression))+ ','? | expression ',' | expression
10438 : static expr_ty
10439 74328 : expressions_rule(Parser *p)
10440 : {
10441 74328 : if (p->level++ == MAXSTACK) {
10442 0 : p->error_indicator = 1;
10443 0 : PyErr_NoMemory();
10444 : }
10445 74328 : if (p->error_indicator) {
10446 0 : p->level--;
10447 0 : return NULL;
10448 : }
10449 74328 : expr_ty _res = NULL;
10450 74328 : int _mark = p->mark;
10451 74328 : 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 74242 : int _start_lineno = p->tokens[_mark]->lineno;
10457 : UNUSED(_start_lineno); // Only used by EXTRA macro
10458 74242 : int _start_col_offset = p->tokens[_mark]->col_offset;
10459 : UNUSED(_start_col_offset); // Only used by EXTRA macro
10460 : { // expression ((',' expression))+ ','?
10461 74242 : if (p->error_indicator) {
10462 0 : p->level--;
10463 0 : return NULL;
10464 : }
10465 74242 : 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 74242 : if (
10471 74242 : (a = expression_rule(p)) // expression
10472 73442 : &&
10473 73442 : (b = _loop1_80_rule(p)) // ((',' expression))+
10474 217 : &&
10475 217 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10476 : )
10477 : {
10478 217 : D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?"));
10479 217 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10480 217 : if (_token == NULL) {
10481 0 : p->level--;
10482 0 : return NULL;
10483 : }
10484 217 : int _end_lineno = _token->end_lineno;
10485 : UNUSED(_end_lineno); // Only used by EXTRA macro
10486 217 : int _end_col_offset = _token->end_col_offset;
10487 : UNUSED(_end_col_offset); // Only used by EXTRA macro
10488 217 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
10489 217 : if (_res == NULL && PyErr_Occurred()) {
10490 0 : p->error_indicator = 1;
10491 0 : p->level--;
10492 0 : return NULL;
10493 : }
10494 217 : goto done;
10495 : }
10496 74025 : p->mark = _mark;
10497 74025 : 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 74025 : if (p->error_indicator) {
10502 769 : p->level--;
10503 769 : return NULL;
10504 : }
10505 73256 : D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ','"));
10506 : Token * _literal;
10507 : expr_ty a;
10508 73256 : if (
10509 73256 : (a = expression_rule(p)) // expression
10510 73225 : &&
10511 73225 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
10512 : )
10513 : {
10514 0 : 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 73256 : p->mark = _mark;
10533 73256 : 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 73256 : if (p->error_indicator) {
10538 0 : p->level--;
10539 0 : return NULL;
10540 : }
10541 73256 : D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
10542 : expr_ty expression_var;
10543 73256 : if (
10544 73256 : (expression_var = expression_rule(p)) // expression
10545 : )
10546 : {
10547 73225 : D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
10548 73225 : _res = expression_var;
10549 73225 : goto done;
10550 : }
10551 31 : p->mark = _mark;
10552 31 : 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 73473 : done:
10557 73473 : p->level--;
10558 73473 : 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 22849400 : expression_rule(Parser *p)
10569 : {
10570 22849400 : if (p->level++ == MAXSTACK) {
10571 0 : p->error_indicator = 1;
10572 0 : PyErr_NoMemory();
10573 : }
10574 22849400 : if (p->error_indicator) {
10575 0 : p->level--;
10576 0 : return NULL;
10577 : }
10578 22849400 : expr_ty _res = NULL;
10579 22849400 : if (_PyPegen_is_memoized(p, expression_type, &_res)) {
10580 10837000 : p->level--;
10581 10837000 : return _res;
10582 : }
10583 12012400 : int _mark = p->mark;
10584 12012400 : 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 12012400 : int _start_lineno = p->tokens[_mark]->lineno;
10590 : UNUSED(_start_lineno); // Only used by EXTRA macro
10591 12012400 : int _start_col_offset = p->tokens[_mark]->col_offset;
10592 : UNUSED(_start_col_offset); // Only used by EXTRA macro
10593 12012400 : if (p->call_invalid_rules) { // invalid_expression
10594 2706 : if (p->error_indicator) {
10595 0 : p->level--;
10596 0 : return NULL;
10597 : }
10598 2706 : 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 0 : 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 2706 : 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 12012400 : if (p->call_invalid_rules) { // invalid_legacy_expression
10613 2706 : if (p->error_indicator) {
10614 32 : p->level--;
10615 32 : return NULL;
10616 : }
10617 2674 : 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 0 : 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 2674 : 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 12012400 : if (p->error_indicator) {
10633 27 : p->level--;
10634 27 : return NULL;
10635 : }
10636 12012400 : 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 12012400 : if (
10643 12012400 : (a = disjunction_rule(p)) // disjunction
10644 9707560 : &&
10645 9707560 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
10646 11117 : &&
10647 11117 : (b = disjunction_rule(p)) // disjunction
10648 11107 : &&
10649 11107 : (_keyword_1 = _PyPegen_expect_token(p, 637)) // token='else'
10650 11101 : &&
10651 11101 : (c = expression_rule(p)) // expression
10652 : )
10653 : {
10654 11101 : D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
10655 11101 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10656 11101 : if (_token == NULL) {
10657 0 : p->level--;
10658 0 : return NULL;
10659 : }
10660 11101 : int _end_lineno = _token->end_lineno;
10661 : UNUSED(_end_lineno); // Only used by EXTRA macro
10662 11101 : int _end_col_offset = _token->end_col_offset;
10663 : UNUSED(_end_col_offset); // Only used by EXTRA macro
10664 11101 : _res = _PyAST_IfExp ( b , a , c , EXTRA );
10665 11101 : if (_res == NULL && PyErr_Occurred()) {
10666 0 : p->error_indicator = 1;
10667 0 : p->level--;
10668 0 : return NULL;
10669 : }
10670 11101 : goto done;
10671 : }
10672 12001300 : p->mark = _mark;
10673 12001300 : 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 12001300 : if (p->error_indicator) {
10678 839 : p->level--;
10679 839 : return NULL;
10680 : }
10681 12000400 : D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction"));
10682 : expr_ty disjunction_var;
10683 12000400 : if (
10684 12000400 : (disjunction_var = disjunction_rule(p)) // disjunction
10685 : )
10686 : {
10687 9696450 : D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction"));
10688 9696450 : _res = disjunction_var;
10689 9696450 : goto done;
10690 : }
10691 2303970 : p->mark = _mark;
10692 2303970 : 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 2303970 : if (p->error_indicator) {
10697 0 : p->level--;
10698 0 : return NULL;
10699 : }
10700 2303970 : D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef"));
10701 : expr_ty lambdef_var;
10702 2303970 : if (
10703 2303970 : (lambdef_var = lambdef_rule(p)) // lambdef
10704 : )
10705 : {
10706 37490 : D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef"));
10707 37490 : _res = lambdef_var;
10708 37490 : goto done;
10709 : }
10710 2266480 : p->mark = _mark;
10711 2266480 : D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
10712 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef"));
10713 : }
10714 2266480 : _res = NULL;
10715 12011500 : done:
10716 12011500 : _PyPegen_insert_memo(p, _mark, expression_type, _res);
10717 12011500 : p->level--;
10718 12011500 : return _res;
10719 : }
10720 :
10721 : // yield_expr: 'yield' 'from' expression | 'yield' star_expressions?
10722 : static expr_ty
10723 1151340 : yield_expr_rule(Parser *p)
10724 : {
10725 1151340 : if (p->level++ == MAXSTACK) {
10726 0 : p->error_indicator = 1;
10727 0 : PyErr_NoMemory();
10728 : }
10729 1151340 : if (p->error_indicator) {
10730 0 : p->level--;
10731 0 : return NULL;
10732 : }
10733 1151340 : expr_ty _res = NULL;
10734 1151340 : int _mark = p->mark;
10735 1151340 : 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 1151340 : int _start_lineno = p->tokens[_mark]->lineno;
10741 : UNUSED(_start_lineno); // Only used by EXTRA macro
10742 1151340 : int _start_col_offset = p->tokens[_mark]->col_offset;
10743 : UNUSED(_start_col_offset); // Only used by EXTRA macro
10744 : { // 'yield' 'from' expression
10745 1151340 : if (p->error_indicator) {
10746 0 : p->level--;
10747 0 : return NULL;
10748 : }
10749 1151340 : 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 1151340 : if (
10754 1151340 : (_keyword = _PyPegen_expect_token(p, 573)) // token='yield'
10755 16059 : &&
10756 16059 : (_keyword_1 = _PyPegen_expect_token(p, 572)) // token='from'
10757 2271 : &&
10758 2271 : (a = expression_rule(p)) // expression
10759 : )
10760 : {
10761 2268 : D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression"));
10762 2268 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10763 2268 : if (_token == NULL) {
10764 0 : p->level--;
10765 0 : return NULL;
10766 : }
10767 2268 : int _end_lineno = _token->end_lineno;
10768 : UNUSED(_end_lineno); // Only used by EXTRA macro
10769 2268 : int _end_col_offset = _token->end_col_offset;
10770 : UNUSED(_end_col_offset); // Only used by EXTRA macro
10771 2268 : _res = _PyAST_YieldFrom ( a , EXTRA );
10772 2268 : if (_res == NULL && PyErr_Occurred()) {
10773 0 : p->error_indicator = 1;
10774 0 : p->level--;
10775 0 : return NULL;
10776 : }
10777 2268 : goto done;
10778 : }
10779 1149080 : p->mark = _mark;
10780 1149080 : 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 1149080 : if (p->error_indicator) {
10785 0 : p->level--;
10786 0 : return NULL;
10787 : }
10788 1149080 : 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 1149080 : if (
10792 1149080 : (_keyword = _PyPegen_expect_token(p, 573)) // token='yield'
10793 13791 : &&
10794 13791 : (a = star_expressions_rule(p), !p->error_indicator) // star_expressions?
10795 : )
10796 : {
10797 13791 : D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?"));
10798 13791 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10799 13791 : if (_token == NULL) {
10800 0 : p->level--;
10801 0 : return NULL;
10802 : }
10803 13791 : int _end_lineno = _token->end_lineno;
10804 : UNUSED(_end_lineno); // Only used by EXTRA macro
10805 13791 : int _end_col_offset = _token->end_col_offset;
10806 : UNUSED(_end_col_offset); // Only used by EXTRA macro
10807 13791 : _res = _PyAST_Yield ( a , EXTRA );
10808 13791 : if (_res == NULL && PyErr_Occurred()) {
10809 0 : p->error_indicator = 1;
10810 0 : p->level--;
10811 0 : return NULL;
10812 : }
10813 13791 : goto done;
10814 : }
10815 1135280 : p->mark = _mark;
10816 1135280 : 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 1135280 : _res = NULL;
10820 1151340 : done:
10821 1151340 : p->level--;
10822 1151340 : return _res;
10823 : }
10824 :
10825 : // star_expressions:
10826 : // | star_expression ((',' star_expression))+ ','?
10827 : // | star_expression ','
10828 : // | star_expression
10829 : static expr_ty
10830 3641140 : star_expressions_rule(Parser *p)
10831 : {
10832 3641140 : if (p->level++ == MAXSTACK) {
10833 0 : p->error_indicator = 1;
10834 0 : PyErr_NoMemory();
10835 : }
10836 3641140 : if (p->error_indicator) {
10837 0 : p->level--;
10838 0 : return NULL;
10839 : }
10840 3641140 : expr_ty _res = NULL;
10841 3641140 : int _mark = p->mark;
10842 3641140 : 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 3641140 : int _start_lineno = p->tokens[_mark]->lineno;
10848 : UNUSED(_start_lineno); // Only used by EXTRA macro
10849 3641140 : 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 3641140 : if (p->error_indicator) {
10853 0 : p->level--;
10854 0 : return NULL;
10855 : }
10856 3641140 : 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 3641140 : if (
10862 3641140 : (a = star_expression_rule(p)) // star_expression
10863 2105940 : &&
10864 2105940 : (b = _loop1_81_rule(p)) // ((',' star_expression))+
10865 19674 : &&
10866 19674 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10867 : )
10868 : {
10869 19674 : D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
10870 19674 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10871 19674 : if (_token == NULL) {
10872 0 : p->level--;
10873 0 : return NULL;
10874 : }
10875 19674 : int _end_lineno = _token->end_lineno;
10876 : UNUSED(_end_lineno); // Only used by EXTRA macro
10877 19674 : int _end_col_offset = _token->end_col_offset;
10878 : UNUSED(_end_col_offset); // Only used by EXTRA macro
10879 19674 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
10880 19674 : if (_res == NULL && PyErr_Occurred()) {
10881 0 : p->error_indicator = 1;
10882 0 : p->level--;
10883 0 : return NULL;
10884 : }
10885 19674 : goto done;
10886 : }
10887 3621470 : p->mark = _mark;
10888 3621470 : 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 3621470 : if (p->error_indicator) {
10893 28 : p->level--;
10894 28 : return NULL;
10895 : }
10896 3621440 : 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 3621440 : if (
10900 3621440 : (a = star_expression_rule(p)) // star_expression
10901 2086260 : &&
10902 2086260 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
10903 : )
10904 : {
10905 229 : D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ','"));
10906 229 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10907 229 : if (_token == NULL) {
10908 0 : p->level--;
10909 0 : return NULL;
10910 : }
10911 229 : int _end_lineno = _token->end_lineno;
10912 : UNUSED(_end_lineno); // Only used by EXTRA macro
10913 229 : int _end_col_offset = _token->end_col_offset;
10914 : UNUSED(_end_col_offset); // Only used by EXTRA macro
10915 229 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
10916 229 : if (_res == NULL && PyErr_Occurred()) {
10917 0 : p->error_indicator = 1;
10918 0 : p->level--;
10919 0 : return NULL;
10920 : }
10921 229 : goto done;
10922 : }
10923 3621210 : p->mark = _mark;
10924 3621210 : 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 3621210 : if (p->error_indicator) {
10929 0 : p->level--;
10930 0 : return NULL;
10931 : }
10932 3621210 : D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression"));
10933 : expr_ty star_expression_var;
10934 3621210 : if (
10935 3621210 : (star_expression_var = star_expression_rule(p)) // star_expression
10936 : )
10937 : {
10938 2086040 : D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression"));
10939 2086040 : _res = star_expression_var;
10940 2086040 : goto done;
10941 : }
10942 1535180 : p->mark = _mark;
10943 1535180 : 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 1535180 : _res = NULL;
10947 3641120 : done:
10948 3641120 : p->level--;
10949 3641120 : return _res;
10950 : }
10951 :
10952 : // star_expression: '*' bitwise_or | expression
10953 : static expr_ty
10954 10912300 : star_expression_rule(Parser *p)
10955 : {
10956 10912300 : if (p->level++ == MAXSTACK) {
10957 0 : p->error_indicator = 1;
10958 0 : PyErr_NoMemory();
10959 : }
10960 10912300 : if (p->error_indicator) {
10961 0 : p->level--;
10962 0 : return NULL;
10963 : }
10964 10912300 : expr_ty _res = NULL;
10965 10912300 : if (_PyPegen_is_memoized(p, star_expression_type, &_res)) {
10966 7244440 : p->level--;
10967 7244440 : return _res;
10968 : }
10969 3667850 : int _mark = p->mark;
10970 3667850 : 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 3667850 : int _start_lineno = p->tokens[_mark]->lineno;
10976 : UNUSED(_start_lineno); // Only used by EXTRA macro
10977 3667850 : int _start_col_offset = p->tokens[_mark]->col_offset;
10978 : UNUSED(_start_col_offset); // Only used by EXTRA macro
10979 : { // '*' bitwise_or
10980 3667850 : if (p->error_indicator) {
10981 0 : p->level--;
10982 0 : return NULL;
10983 : }
10984 3667850 : 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 3667850 : if (
10988 3667850 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
10989 52 : &&
10990 52 : (a = bitwise_or_rule(p)) // bitwise_or
10991 : )
10992 : {
10993 52 : 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 3667800 : p->mark = _mark;
11012 3667800 : 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 3667800 : if (p->error_indicator) {
11017 0 : p->level--;
11018 0 : return NULL;
11019 : }
11020 3667800 : D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
11021 : expr_ty expression_var;
11022 3667800 : if (
11023 3667800 : (expression_var = expression_rule(p)) // expression
11024 : )
11025 : {
11026 2133680 : D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
11027 2133680 : _res = expression_var;
11028 2133680 : goto done;
11029 : }
11030 1534120 : p->mark = _mark;
11031 1534120 : 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 1534120 : _res = NULL;
11035 3667850 : done:
11036 3667850 : _PyPegen_insert_memo(p, _mark, star_expression_type, _res);
11037 3667850 : p->level--;
11038 3667850 : return _res;
11039 : }
11040 :
11041 : // star_named_expressions: ','.star_named_expression+ ','?
11042 : static asdl_expr_seq*
11043 826180 : star_named_expressions_rule(Parser *p)
11044 : {
11045 826180 : if (p->level++ == MAXSTACK) {
11046 0 : p->error_indicator = 1;
11047 0 : PyErr_NoMemory();
11048 : }
11049 826180 : if (p->error_indicator) {
11050 0 : p->level--;
11051 0 : return NULL;
11052 : }
11053 826180 : asdl_expr_seq* _res = NULL;
11054 826180 : int _mark = p->mark;
11055 : { // ','.star_named_expression+ ','?
11056 826180 : if (p->error_indicator) {
11057 0 : p->level--;
11058 0 : return NULL;
11059 : }
11060 826180 : 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 826180 : if (
11065 826180 : (a = (asdl_expr_seq*)_gather_82_rule(p)) // ','.star_named_expression+
11066 650587 : &&
11067 650587 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
11068 : )
11069 : {
11070 650560 : D(fprintf(stderr, "%*c+ star_named_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?"));
11071 650560 : _res = a;
11072 650560 : if (_res == NULL && PyErr_Occurred()) {
11073 0 : p->error_indicator = 1;
11074 0 : p->level--;
11075 0 : return NULL;
11076 : }
11077 650560 : goto done;
11078 : }
11079 175620 : p->mark = _mark;
11080 175620 : 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 175620 : _res = NULL;
11084 826180 : done:
11085 826180 : p->level--;
11086 826180 : return _res;
11087 : }
11088 :
11089 : // star_named_expression: '*' bitwise_or | named_expression
11090 : static expr_ty
11091 4674380 : star_named_expression_rule(Parser *p)
11092 : {
11093 4674380 : if (p->level++ == MAXSTACK) {
11094 0 : p->error_indicator = 1;
11095 0 : PyErr_NoMemory();
11096 : }
11097 4674380 : if (p->error_indicator) {
11098 0 : p->level--;
11099 0 : return NULL;
11100 : }
11101 4674380 : expr_ty _res = NULL;
11102 4674380 : int _mark = p->mark;
11103 4674380 : 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 4674330 : int _start_lineno = p->tokens[_mark]->lineno;
11109 : UNUSED(_start_lineno); // Only used by EXTRA macro
11110 4674330 : int _start_col_offset = p->tokens[_mark]->col_offset;
11111 : UNUSED(_start_col_offset); // Only used by EXTRA macro
11112 : { // '*' bitwise_or
11113 4674330 : if (p->error_indicator) {
11114 0 : p->level--;
11115 0 : return NULL;
11116 : }
11117 4674330 : 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 4674330 : if (
11121 4674330 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
11122 2676 : &&
11123 2676 : (a = bitwise_or_rule(p)) // bitwise_or
11124 : )
11125 : {
11126 2651 : D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
11127 2651 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11128 2651 : if (_token == NULL) {
11129 0 : p->level--;
11130 0 : return NULL;
11131 : }
11132 2651 : int _end_lineno = _token->end_lineno;
11133 : UNUSED(_end_lineno); // Only used by EXTRA macro
11134 2651 : int _end_col_offset = _token->end_col_offset;
11135 : UNUSED(_end_col_offset); // Only used by EXTRA macro
11136 2651 : _res = _PyAST_Starred ( a , Load , EXTRA );
11137 2651 : if (_res == NULL && PyErr_Occurred()) {
11138 0 : p->error_indicator = 1;
11139 0 : p->level--;
11140 0 : return NULL;
11141 : }
11142 2651 : goto done;
11143 : }
11144 4671680 : p->mark = _mark;
11145 4671680 : 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 4671680 : if (p->error_indicator) {
11150 0 : p->level--;
11151 0 : return NULL;
11152 : }
11153 4671680 : 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 4671680 : if (
11156 4671680 : (named_expression_var = named_expression_rule(p)) // named_expression
11157 : )
11158 : {
11159 4447710 : D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
11160 4447710 : _res = named_expression_var;
11161 4447710 : goto done;
11162 : }
11163 223967 : p->mark = _mark;
11164 223967 : 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 223967 : _res = NULL;
11168 4674330 : done:
11169 4674330 : p->level--;
11170 4674330 : return _res;
11171 : }
11172 :
11173 : // assignment_expression: NAME ':=' ~ expression
11174 : static expr_ty
11175 12893000 : assignment_expression_rule(Parser *p)
11176 : {
11177 12893000 : if (p->level++ == MAXSTACK) {
11178 0 : p->error_indicator = 1;
11179 0 : PyErr_NoMemory();
11180 : }
11181 12893000 : if (p->error_indicator) {
11182 0 : p->level--;
11183 0 : return NULL;
11184 : }
11185 12893000 : expr_ty _res = NULL;
11186 12893000 : int _mark = p->mark;
11187 12893000 : 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 12893000 : int _start_lineno = p->tokens[_mark]->lineno;
11193 : UNUSED(_start_lineno); // Only used by EXTRA macro
11194 12893000 : int _start_col_offset = p->tokens[_mark]->col_offset;
11195 : UNUSED(_start_col_offset); // Only used by EXTRA macro
11196 : { // NAME ':=' ~ expression
11197 12893000 : if (p->error_indicator) {
11198 0 : p->level--;
11199 0 : return NULL;
11200 : }
11201 12893000 : D(fprintf(stderr, "%*c> assignment_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
11202 12893000 : int _cut_var = 0;
11203 : Token * _literal;
11204 : expr_ty a;
11205 : expr_ty b;
11206 12893000 : if (
11207 12893000 : (a = _PyPegen_name_token(p)) // NAME
11208 5423750 : &&
11209 5423750 : (_literal = _PyPegen_expect_token(p, 53)) // token=':='
11210 : &&
11211 3709 : (_cut_var = 1)
11212 3709 : &&
11213 3709 : (b = expression_rule(p)) // expression
11214 : )
11215 : {
11216 3709 : D(fprintf(stderr, "%*c+ assignment_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
11217 3709 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11218 3709 : if (_token == NULL) {
11219 0 : p->level--;
11220 0 : return NULL;
11221 : }
11222 3709 : int _end_lineno = _token->end_lineno;
11223 : UNUSED(_end_lineno); // Only used by EXTRA macro
11224 3709 : int _end_col_offset = _token->end_col_offset;
11225 : UNUSED(_end_col_offset); // Only used by EXTRA macro
11226 3709 : _res = _PyAST_NamedExpr ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA );
11227 3709 : if (_res == NULL && PyErr_Occurred()) {
11228 0 : p->error_indicator = 1;
11229 0 : p->level--;
11230 0 : return NULL;
11231 : }
11232 3709 : goto done;
11233 : }
11234 12889300 : p->mark = _mark;
11235 12889300 : 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 12889300 : if (_cut_var) {
11238 0 : p->level--;
11239 0 : return NULL;
11240 : }
11241 : }
11242 12889300 : _res = NULL;
11243 12893000 : done:
11244 12893000 : p->level--;
11245 12893000 : return _res;
11246 : }
11247 :
11248 : // named_expression: assignment_expression | invalid_named_expression | expression !':='
11249 : static expr_ty
11250 7043630 : named_expression_rule(Parser *p)
11251 : {
11252 7043630 : if (p->level++ == MAXSTACK) {
11253 0 : p->error_indicator = 1;
11254 0 : PyErr_NoMemory();
11255 : }
11256 7043630 : if (p->error_indicator) {
11257 0 : p->level--;
11258 0 : return NULL;
11259 : }
11260 7043630 : expr_ty _res = NULL;
11261 7043630 : int _mark = p->mark;
11262 : { // assignment_expression
11263 7043630 : if (p->error_indicator) {
11264 0 : p->level--;
11265 0 : return NULL;
11266 : }
11267 7043630 : D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
11268 : expr_ty assignment_expression_var;
11269 7043630 : if (
11270 7043630 : (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
11271 : )
11272 : {
11273 3618 : D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
11274 3618 : _res = assignment_expression_var;
11275 3618 : goto done;
11276 : }
11277 7040010 : p->mark = _mark;
11278 7040010 : 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 7040010 : if (p->call_invalid_rules) { // invalid_named_expression
11282 2435 : if (p->error_indicator) {
11283 0 : p->level--;
11284 0 : return NULL;
11285 : }
11286 2435 : 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 0 : 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 2435 : 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 7040010 : if (p->error_indicator) {
11302 131 : p->level--;
11303 131 : return NULL;
11304 : }
11305 7039880 : D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
11306 : expr_ty expression_var;
11307 7039880 : if (
11308 7039880 : (expression_var = expression_rule(p)) // expression
11309 6811820 : &&
11310 6811820 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
11311 : )
11312 : {
11313 6811800 : D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
11314 6811800 : _res = expression_var;
11315 6811800 : goto done;
11316 : }
11317 228077 : p->mark = _mark;
11318 228077 : 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 228077 : _res = NULL;
11322 7043500 : done:
11323 7043500 : p->level--;
11324 7043500 : return _res;
11325 : }
11326 :
11327 : // disjunction: conjunction (('or' conjunction))+ | conjunction
11328 : static expr_ty
11329 24096000 : disjunction_rule(Parser *p)
11330 : {
11331 24096000 : if (p->level++ == MAXSTACK) {
11332 0 : p->error_indicator = 1;
11333 0 : PyErr_NoMemory();
11334 : }
11335 24096000 : if (p->error_indicator) {
11336 0 : p->level--;
11337 0 : return NULL;
11338 : }
11339 24096000 : expr_ty _res = NULL;
11340 24096000 : if (_PyPegen_is_memoized(p, disjunction_type, &_res)) {
11341 12043500 : p->level--;
11342 12043500 : return _res;
11343 : }
11344 12052500 : int _mark = p->mark;
11345 12052500 : 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 12052500 : int _start_lineno = p->tokens[_mark]->lineno;
11351 : UNUSED(_start_lineno); // Only used by EXTRA macro
11352 12052500 : int _start_col_offset = p->tokens[_mark]->col_offset;
11353 : UNUSED(_start_col_offset); // Only used by EXTRA macro
11354 : { // conjunction (('or' conjunction))+
11355 12052500 : if (p->error_indicator) {
11356 0 : p->level--;
11357 0 : return NULL;
11358 : }
11359 12052500 : 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 12052500 : if (
11363 12052500 : (a = conjunction_rule(p)) // conjunction
11364 9747010 : &&
11365 9747010 : (b = _loop1_84_rule(p)) // (('or' conjunction))+
11366 : )
11367 : {
11368 26195 : D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+"));
11369 26195 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11370 26195 : if (_token == NULL) {
11371 0 : p->level--;
11372 0 : return NULL;
11373 : }
11374 26195 : int _end_lineno = _token->end_lineno;
11375 : UNUSED(_end_lineno); // Only used by EXTRA macro
11376 26195 : int _end_col_offset = _token->end_col_offset;
11377 : UNUSED(_end_col_offset); // Only used by EXTRA macro
11378 26195 : _res = _PyAST_BoolOp ( Or , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
11379 26195 : if (_res == NULL && PyErr_Occurred()) {
11380 0 : p->error_indicator = 1;
11381 0 : p->level--;
11382 0 : return NULL;
11383 : }
11384 26195 : goto done;
11385 : }
11386 12026300 : p->mark = _mark;
11387 12026300 : 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 12026300 : if (p->error_indicator) {
11392 851 : p->level--;
11393 851 : return NULL;
11394 : }
11395 12025400 : D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction"));
11396 : expr_ty conjunction_var;
11397 12025400 : if (
11398 12025400 : (conjunction_var = conjunction_rule(p)) // conjunction
11399 : )
11400 : {
11401 9720810 : D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction"));
11402 9720810 : _res = conjunction_var;
11403 9720810 : goto done;
11404 : }
11405 2304620 : p->mark = _mark;
11406 2304620 : D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ',
11407 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction"));
11408 : }
11409 2304620 : _res = NULL;
11410 12051600 : done:
11411 12051600 : _PyPegen_insert_memo(p, _mark, disjunction_type, _res);
11412 12051600 : p->level--;
11413 12051600 : return _res;
11414 : }
11415 :
11416 : // conjunction: inversion (('and' inversion))+ | inversion
11417 : static expr_ty
11418 24106900 : conjunction_rule(Parser *p)
11419 : {
11420 24106900 : if (p->level++ == MAXSTACK) {
11421 0 : p->error_indicator = 1;
11422 0 : PyErr_NoMemory();
11423 : }
11424 24106900 : if (p->error_indicator) {
11425 0 : p->level--;
11426 0 : return NULL;
11427 : }
11428 24106900 : expr_ty _res = NULL;
11429 24106900 : if (_PyPegen_is_memoized(p, conjunction_type, &_res)) {
11430 12025400 : p->level--;
11431 12025400 : return _res;
11432 : }
11433 12081400 : int _mark = p->mark;
11434 12081400 : 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 12081400 : int _start_lineno = p->tokens[_mark]->lineno;
11440 : UNUSED(_start_lineno); // Only used by EXTRA macro
11441 12081400 : int _start_col_offset = p->tokens[_mark]->col_offset;
11442 : UNUSED(_start_col_offset); // Only used by EXTRA macro
11443 : { // inversion (('and' inversion))+
11444 12081400 : if (p->error_indicator) {
11445 0 : p->level--;
11446 0 : return NULL;
11447 : }
11448 12081400 : 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 12081400 : if (
11452 12081400 : (a = inversion_rule(p)) // inversion
11453 9775950 : &&
11454 9775950 : (b = _loop1_85_rule(p)) // (('and' inversion))+
11455 : )
11456 : {
11457 39371 : D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+"));
11458 39371 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11459 39371 : if (_token == NULL) {
11460 0 : p->level--;
11461 0 : return NULL;
11462 : }
11463 39371 : int _end_lineno = _token->end_lineno;
11464 : UNUSED(_end_lineno); // Only used by EXTRA macro
11465 39371 : int _end_col_offset = _token->end_col_offset;
11466 : UNUSED(_end_col_offset); // Only used by EXTRA macro
11467 39371 : _res = _PyAST_BoolOp ( And , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
11468 39371 : if (_res == NULL && PyErr_Occurred()) {
11469 0 : p->error_indicator = 1;
11470 0 : p->level--;
11471 0 : return NULL;
11472 : }
11473 39371 : goto done;
11474 : }
11475 12042100 : p->mark = _mark;
11476 12042100 : 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 12042100 : if (p->error_indicator) {
11481 851 : p->level--;
11482 851 : return NULL;
11483 : }
11484 12041200 : D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion"));
11485 : expr_ty inversion_var;
11486 12041200 : if (
11487 12041200 : (inversion_var = inversion_rule(p)) // inversion
11488 : )
11489 : {
11490 9736580 : D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion"));
11491 9736580 : _res = inversion_var;
11492 9736580 : goto done;
11493 : }
11494 2304620 : p->mark = _mark;
11495 2304620 : D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ',
11496 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion"));
11497 : }
11498 2304620 : _res = NULL;
11499 12080600 : done:
11500 12080600 : _PyPegen_insert_memo(p, _mark, conjunction_type, _res);
11501 12080600 : p->level--;
11502 12080600 : return _res;
11503 : }
11504 :
11505 : // inversion: 'not' inversion | comparison
11506 : static expr_ty
11507 24226300 : inversion_rule(Parser *p)
11508 : {
11509 24226300 : if (p->level++ == MAXSTACK) {
11510 0 : p->error_indicator = 1;
11511 0 : PyErr_NoMemory();
11512 : }
11513 24226300 : if (p->error_indicator) {
11514 0 : p->level--;
11515 0 : return NULL;
11516 : }
11517 24226300 : expr_ty _res = NULL;
11518 24226300 : if (_PyPegen_is_memoized(p, inversion_type, &_res)) {
11519 12041200 : p->level--;
11520 12041200 : return _res;
11521 : }
11522 12185100 : int _mark = p->mark;
11523 12185100 : 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 12185100 : int _start_lineno = p->tokens[_mark]->lineno;
11529 : UNUSED(_start_lineno); // Only used by EXTRA macro
11530 12185100 : int _start_col_offset = p->tokens[_mark]->col_offset;
11531 : UNUSED(_start_col_offset); // Only used by EXTRA macro
11532 : { // 'not' inversion
11533 12185100 : if (p->error_indicator) {
11534 0 : p->level--;
11535 0 : return NULL;
11536 : }
11537 12185100 : D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
11538 : Token * _keyword;
11539 : expr_ty a;
11540 12185100 : if (
11541 12185100 : (_keyword = _PyPegen_expect_token(p, 581)) // token='not'
11542 57435 : &&
11543 57435 : (a = inversion_rule(p)) // inversion
11544 : )
11545 : {
11546 57433 : D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
11547 57433 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11548 57433 : if (_token == NULL) {
11549 0 : p->level--;
11550 0 : return NULL;
11551 : }
11552 57433 : int _end_lineno = _token->end_lineno;
11553 : UNUSED(_end_lineno); // Only used by EXTRA macro
11554 57433 : int _end_col_offset = _token->end_col_offset;
11555 : UNUSED(_end_col_offset); // Only used by EXTRA macro
11556 57433 : _res = _PyAST_UnaryOp ( Not , a , EXTRA );
11557 57433 : if (_res == NULL && PyErr_Occurred()) {
11558 0 : p->error_indicator = 1;
11559 0 : p->level--;
11560 0 : return NULL;
11561 : }
11562 57433 : goto done;
11563 : }
11564 12127700 : p->mark = _mark;
11565 12127700 : 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 12127700 : if (p->error_indicator) {
11570 0 : p->level--;
11571 0 : return NULL;
11572 : }
11573 12127700 : D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "comparison"));
11574 : expr_ty comparison_var;
11575 12127700 : if (
11576 12127700 : (comparison_var = comparison_rule(p)) // comparison
11577 : )
11578 : {
11579 9822190 : D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "comparison"));
11580 9822190 : _res = comparison_var;
11581 9822190 : goto done;
11582 : }
11583 2305480 : p->mark = _mark;
11584 2305480 : D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',
11585 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison"));
11586 : }
11587 2305480 : _res = NULL;
11588 12185100 : done:
11589 12185100 : _PyPegen_insert_memo(p, _mark, inversion_type, _res);
11590 12185100 : p->level--;
11591 12185100 : return _res;
11592 : }
11593 :
11594 : // comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or
11595 : static expr_ty
11596 12127700 : comparison_rule(Parser *p)
11597 : {
11598 12127700 : if (p->level++ == MAXSTACK) {
11599 0 : p->error_indicator = 1;
11600 0 : PyErr_NoMemory();
11601 : }
11602 12127700 : if (p->error_indicator) {
11603 0 : p->level--;
11604 0 : return NULL;
11605 : }
11606 12127700 : expr_ty _res = NULL;
11607 12127700 : int _mark = p->mark;
11608 12127700 : 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 12127700 : int _start_lineno = p->tokens[_mark]->lineno;
11614 : UNUSED(_start_lineno); // Only used by EXTRA macro
11615 12127700 : 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 12127700 : if (p->error_indicator) {
11619 0 : p->level--;
11620 0 : return NULL;
11621 : }
11622 12127700 : 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 12127700 : if (
11626 12127700 : (a = bitwise_or_rule(p)) // bitwise_or
11627 9822190 : &&
11628 9822190 : (b = _loop1_86_rule(p)) // compare_op_bitwise_or_pair+
11629 : )
11630 : {
11631 242788 : D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
11632 242788 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11633 242788 : if (_token == NULL) {
11634 0 : p->level--;
11635 0 : return NULL;
11636 : }
11637 242788 : int _end_lineno = _token->end_lineno;
11638 : UNUSED(_end_lineno); // Only used by EXTRA macro
11639 242788 : int _end_col_offset = _token->end_col_offset;
11640 : UNUSED(_end_col_offset); // Only used by EXTRA macro
11641 242788 : _res = _PyAST_Compare ( a , CHECK ( asdl_int_seq* , _PyPegen_get_cmpops ( p , b ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_exprs ( p , b ) ) , EXTRA );
11642 242788 : if (_res == NULL && PyErr_Occurred()) {
11643 0 : p->error_indicator = 1;
11644 0 : p->level--;
11645 0 : return NULL;
11646 : }
11647 242788 : goto done;
11648 : }
11649 11884900 : p->mark = _mark;
11650 11884900 : 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 11884900 : if (p->error_indicator) {
11655 851 : p->level--;
11656 851 : return NULL;
11657 : }
11658 11884000 : D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or"));
11659 : expr_ty bitwise_or_var;
11660 11884000 : if (
11661 11884000 : (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
11662 : )
11663 : {
11664 9579400 : D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or"));
11665 9579400 : _res = bitwise_or_var;
11666 9579400 : goto done;
11667 : }
11668 2304630 : p->mark = _mark;
11669 2304630 : 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 2304630 : _res = NULL;
11673 12126800 : done:
11674 12126800 : p->level--;
11675 12126800 : 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 10068300 : compare_op_bitwise_or_pair_rule(Parser *p)
11691 : {
11692 10068300 : if (p->level++ == MAXSTACK) {
11693 0 : p->error_indicator = 1;
11694 0 : PyErr_NoMemory();
11695 : }
11696 10068300 : if (p->error_indicator) {
11697 0 : p->level--;
11698 0 : return NULL;
11699 : }
11700 10068300 : CmpopExprPair* _res = NULL;
11701 10068300 : int _mark = p->mark;
11702 : { // eq_bitwise_or
11703 10068300 : if (p->error_indicator) {
11704 0 : p->level--;
11705 0 : return NULL;
11706 : }
11707 10068300 : 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 10068300 : if (
11710 10068300 : (eq_bitwise_or_var = eq_bitwise_or_rule(p)) // eq_bitwise_or
11711 : )
11712 : {
11713 71614 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or"));
11714 71614 : _res = eq_bitwise_or_var;
11715 71614 : goto done;
11716 : }
11717 9996680 : p->mark = _mark;
11718 9996680 : 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 9996680 : if (p->error_indicator) {
11723 0 : p->level--;
11724 0 : return NULL;
11725 : }
11726 9996680 : 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 9996680 : if (
11729 9996680 : (noteq_bitwise_or_var = noteq_bitwise_or_rule(p)) // noteq_bitwise_or
11730 : )
11731 : {
11732 17658 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or"));
11733 17658 : _res = noteq_bitwise_or_var;
11734 17658 : goto done;
11735 : }
11736 9979020 : p->mark = _mark;
11737 9979020 : 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 9979020 : if (p->error_indicator) {
11742 1 : p->level--;
11743 1 : return NULL;
11744 : }
11745 9979020 : 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 9979020 : if (
11748 9979020 : (lte_bitwise_or_var = lte_bitwise_or_rule(p)) // lte_bitwise_or
11749 : )
11750 : {
11751 8794 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or"));
11752 8794 : _res = lte_bitwise_or_var;
11753 8794 : goto done;
11754 : }
11755 9970220 : p->mark = _mark;
11756 9970220 : 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 9970220 : if (p->error_indicator) {
11761 0 : p->level--;
11762 0 : return NULL;
11763 : }
11764 9970220 : 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 9970220 : if (
11767 9970220 : (lt_bitwise_or_var = lt_bitwise_or_rule(p)) // lt_bitwise_or
11768 : )
11769 : {
11770 15067 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or"));
11771 15067 : _res = lt_bitwise_or_var;
11772 15067 : goto done;
11773 : }
11774 9955160 : p->mark = _mark;
11775 9955160 : 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 9955160 : if (p->error_indicator) {
11780 0 : p->level--;
11781 0 : return NULL;
11782 : }
11783 9955160 : 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 9955160 : if (
11786 9955160 : (gte_bitwise_or_var = gte_bitwise_or_rule(p)) // gte_bitwise_or
11787 : )
11788 : {
11789 8171 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or"));
11790 8171 : _res = gte_bitwise_or_var;
11791 8171 : goto done;
11792 : }
11793 9946980 : p->mark = _mark;
11794 9946980 : 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 9946980 : if (p->error_indicator) {
11799 0 : p->level--;
11800 0 : return NULL;
11801 : }
11802 9946980 : 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 9946980 : if (
11805 9946980 : (gt_bitwise_or_var = gt_bitwise_or_rule(p)) // gt_bitwise_or
11806 : )
11807 : {
11808 13354 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or"));
11809 13354 : _res = gt_bitwise_or_var;
11810 13354 : goto done;
11811 : }
11812 9933630 : p->mark = _mark;
11813 9933630 : 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 9933630 : if (p->error_indicator) {
11818 0 : p->level--;
11819 0 : return NULL;
11820 : }
11821 9933630 : 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 9933630 : if (
11824 9933630 : (notin_bitwise_or_var = notin_bitwise_or_rule(p)) // notin_bitwise_or
11825 : )
11826 : {
11827 10940 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or"));
11828 10940 : _res = notin_bitwise_or_var;
11829 10940 : goto done;
11830 : }
11831 9922690 : p->mark = _mark;
11832 9922690 : 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 9922690 : if (p->error_indicator) {
11837 0 : p->level--;
11838 0 : return NULL;
11839 : }
11840 9922690 : 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 9922690 : if (
11843 9922690 : (in_bitwise_or_var = in_bitwise_or_rule(p)) // in_bitwise_or
11844 : )
11845 : {
11846 32118 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in_bitwise_or"));
11847 32118 : _res = in_bitwise_or_var;
11848 32118 : goto done;
11849 : }
11850 9890570 : p->mark = _mark;
11851 9890570 : 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 9890570 : if (p->error_indicator) {
11856 0 : p->level--;
11857 0 : return NULL;
11858 : }
11859 9890570 : 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 9890570 : if (
11862 9890570 : (isnot_bitwise_or_var = isnot_bitwise_or_rule(p)) // isnot_bitwise_or
11863 : )
11864 : {
11865 28396 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or"));
11866 28396 : _res = isnot_bitwise_or_var;
11867 28396 : goto done;
11868 : }
11869 9862180 : p->mark = _mark;
11870 9862180 : 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 9862180 : if (p->error_indicator) {
11875 0 : p->level--;
11876 0 : return NULL;
11877 : }
11878 9862180 : 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 9862180 : if (
11881 9862180 : (is_bitwise_or_var = is_bitwise_or_rule(p)) // is_bitwise_or
11882 : )
11883 : {
11884 39989 : D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "is_bitwise_or"));
11885 39989 : _res = is_bitwise_or_var;
11886 39989 : goto done;
11887 : }
11888 9822190 : p->mark = _mark;
11889 9822190 : 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 9822190 : _res = NULL;
11893 10068300 : done:
11894 10068300 : p->level--;
11895 10068300 : return _res;
11896 : }
11897 :
11898 : // eq_bitwise_or: '==' bitwise_or
11899 : static CmpopExprPair*
11900 10068300 : eq_bitwise_or_rule(Parser *p)
11901 : {
11902 10068300 : if (p->level++ == MAXSTACK) {
11903 0 : p->error_indicator = 1;
11904 0 : PyErr_NoMemory();
11905 : }
11906 10068300 : if (p->error_indicator) {
11907 0 : p->level--;
11908 0 : return NULL;
11909 : }
11910 10068300 : CmpopExprPair* _res = NULL;
11911 10068300 : int _mark = p->mark;
11912 : { // '==' bitwise_or
11913 10068300 : if (p->error_indicator) {
11914 0 : p->level--;
11915 0 : return NULL;
11916 : }
11917 10068300 : 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 10068300 : if (
11921 10068300 : (_literal = _PyPegen_expect_token(p, 27)) // token='=='
11922 71614 : &&
11923 71614 : (a = bitwise_or_rule(p)) // bitwise_or
11924 : )
11925 : {
11926 71614 : D(fprintf(stderr, "%*c+ eq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or"));
11927 71614 : _res = _PyPegen_cmpop_expr_pair ( p , Eq , a );
11928 71614 : if (_res == NULL && PyErr_Occurred()) {
11929 0 : p->error_indicator = 1;
11930 0 : p->level--;
11931 0 : return NULL;
11932 : }
11933 71614 : goto done;
11934 : }
11935 9996680 : p->mark = _mark;
11936 9996680 : 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 9996680 : _res = NULL;
11940 10068300 : done:
11941 10068300 : p->level--;
11942 10068300 : return _res;
11943 : }
11944 :
11945 : // noteq_bitwise_or: ('!=') bitwise_or
11946 : static CmpopExprPair*
11947 9996680 : noteq_bitwise_or_rule(Parser *p)
11948 : {
11949 9996680 : if (p->level++ == MAXSTACK) {
11950 0 : p->error_indicator = 1;
11951 0 : PyErr_NoMemory();
11952 : }
11953 9996680 : if (p->error_indicator) {
11954 0 : p->level--;
11955 0 : return NULL;
11956 : }
11957 9996680 : CmpopExprPair* _res = NULL;
11958 9996680 : int _mark = p->mark;
11959 : { // ('!=') bitwise_or
11960 9996680 : if (p->error_indicator) {
11961 0 : p->level--;
11962 0 : return NULL;
11963 : }
11964 9996680 : 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 9996680 : if (
11968 9996680 : (_tmp_87_var = _tmp_87_rule(p)) // '!='
11969 17658 : &&
11970 17658 : (a = bitwise_or_rule(p)) // bitwise_or
11971 : )
11972 : {
11973 17658 : D(fprintf(stderr, "%*c+ noteq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or"));
11974 17658 : _res = _PyPegen_cmpop_expr_pair ( p , NotEq , a );
11975 17658 : if (_res == NULL && PyErr_Occurred()) {
11976 0 : p->error_indicator = 1;
11977 0 : p->level--;
11978 0 : return NULL;
11979 : }
11980 17658 : goto done;
11981 : }
11982 9979020 : p->mark = _mark;
11983 9979020 : 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 9979020 : _res = NULL;
11987 9996680 : done:
11988 9996680 : p->level--;
11989 9996680 : return _res;
11990 : }
11991 :
11992 : // lte_bitwise_or: '<=' bitwise_or
11993 : static CmpopExprPair*
11994 9979020 : lte_bitwise_or_rule(Parser *p)
11995 : {
11996 9979020 : if (p->level++ == MAXSTACK) {
11997 0 : p->error_indicator = 1;
11998 0 : PyErr_NoMemory();
11999 : }
12000 9979020 : if (p->error_indicator) {
12001 0 : p->level--;
12002 0 : return NULL;
12003 : }
12004 9979020 : CmpopExprPair* _res = NULL;
12005 9979020 : int _mark = p->mark;
12006 : { // '<=' bitwise_or
12007 9979020 : if (p->error_indicator) {
12008 0 : p->level--;
12009 0 : return NULL;
12010 : }
12011 9979020 : 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 9979020 : if (
12015 9979020 : (_literal = _PyPegen_expect_token(p, 29)) // token='<='
12016 8794 : &&
12017 8794 : (a = bitwise_or_rule(p)) // bitwise_or
12018 : )
12019 : {
12020 8794 : D(fprintf(stderr, "%*c+ lte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or"));
12021 8794 : _res = _PyPegen_cmpop_expr_pair ( p , LtE , a );
12022 8794 : if (_res == NULL && PyErr_Occurred()) {
12023 0 : p->error_indicator = 1;
12024 0 : p->level--;
12025 0 : return NULL;
12026 : }
12027 8794 : goto done;
12028 : }
12029 9970220 : p->mark = _mark;
12030 9970220 : 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 9970220 : _res = NULL;
12034 9979020 : done:
12035 9979020 : p->level--;
12036 9979020 : return _res;
12037 : }
12038 :
12039 : // lt_bitwise_or: '<' bitwise_or
12040 : static CmpopExprPair*
12041 9970220 : lt_bitwise_or_rule(Parser *p)
12042 : {
12043 9970220 : if (p->level++ == MAXSTACK) {
12044 0 : p->error_indicator = 1;
12045 0 : PyErr_NoMemory();
12046 : }
12047 9970220 : if (p->error_indicator) {
12048 0 : p->level--;
12049 0 : return NULL;
12050 : }
12051 9970220 : CmpopExprPair* _res = NULL;
12052 9970220 : int _mark = p->mark;
12053 : { // '<' bitwise_or
12054 9970220 : if (p->error_indicator) {
12055 0 : p->level--;
12056 0 : return NULL;
12057 : }
12058 9970220 : 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 9970220 : if (
12062 9970220 : (_literal = _PyPegen_expect_token(p, 20)) // token='<'
12063 15067 : &&
12064 15067 : (a = bitwise_or_rule(p)) // bitwise_or
12065 : )
12066 : {
12067 15067 : D(fprintf(stderr, "%*c+ lt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or"));
12068 15067 : _res = _PyPegen_cmpop_expr_pair ( p , Lt , a );
12069 15067 : if (_res == NULL && PyErr_Occurred()) {
12070 0 : p->error_indicator = 1;
12071 0 : p->level--;
12072 0 : return NULL;
12073 : }
12074 15067 : goto done;
12075 : }
12076 9955160 : p->mark = _mark;
12077 9955160 : 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 9955160 : _res = NULL;
12081 9970220 : done:
12082 9970220 : p->level--;
12083 9970220 : return _res;
12084 : }
12085 :
12086 : // gte_bitwise_or: '>=' bitwise_or
12087 : static CmpopExprPair*
12088 9955160 : gte_bitwise_or_rule(Parser *p)
12089 : {
12090 9955160 : if (p->level++ == MAXSTACK) {
12091 0 : p->error_indicator = 1;
12092 0 : PyErr_NoMemory();
12093 : }
12094 9955160 : if (p->error_indicator) {
12095 0 : p->level--;
12096 0 : return NULL;
12097 : }
12098 9955160 : CmpopExprPair* _res = NULL;
12099 9955160 : int _mark = p->mark;
12100 : { // '>=' bitwise_or
12101 9955160 : if (p->error_indicator) {
12102 0 : p->level--;
12103 0 : return NULL;
12104 : }
12105 9955160 : 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 9955160 : if (
12109 9955160 : (_literal = _PyPegen_expect_token(p, 30)) // token='>='
12110 8171 : &&
12111 8171 : (a = bitwise_or_rule(p)) // bitwise_or
12112 : )
12113 : {
12114 8171 : D(fprintf(stderr, "%*c+ gte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or"));
12115 8171 : _res = _PyPegen_cmpop_expr_pair ( p , GtE , a );
12116 8171 : if (_res == NULL && PyErr_Occurred()) {
12117 0 : p->error_indicator = 1;
12118 0 : p->level--;
12119 0 : return NULL;
12120 : }
12121 8171 : goto done;
12122 : }
12123 9946980 : p->mark = _mark;
12124 9946980 : 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 9946980 : _res = NULL;
12128 9955160 : done:
12129 9955160 : p->level--;
12130 9955160 : return _res;
12131 : }
12132 :
12133 : // gt_bitwise_or: '>' bitwise_or
12134 : static CmpopExprPair*
12135 9946980 : gt_bitwise_or_rule(Parser *p)
12136 : {
12137 9946980 : if (p->level++ == MAXSTACK) {
12138 0 : p->error_indicator = 1;
12139 0 : PyErr_NoMemory();
12140 : }
12141 9946980 : if (p->error_indicator) {
12142 0 : p->level--;
12143 0 : return NULL;
12144 : }
12145 9946980 : CmpopExprPair* _res = NULL;
12146 9946980 : int _mark = p->mark;
12147 : { // '>' bitwise_or
12148 9946980 : if (p->error_indicator) {
12149 0 : p->level--;
12150 0 : return NULL;
12151 : }
12152 9946980 : 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 9946980 : if (
12156 9946980 : (_literal = _PyPegen_expect_token(p, 21)) // token='>'
12157 13354 : &&
12158 13354 : (a = bitwise_or_rule(p)) // bitwise_or
12159 : )
12160 : {
12161 13354 : D(fprintf(stderr, "%*c+ gt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or"));
12162 13354 : _res = _PyPegen_cmpop_expr_pair ( p , Gt , a );
12163 13354 : if (_res == NULL && PyErr_Occurred()) {
12164 0 : p->error_indicator = 1;
12165 0 : p->level--;
12166 0 : return NULL;
12167 : }
12168 13354 : goto done;
12169 : }
12170 9933630 : p->mark = _mark;
12171 9933630 : 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 9933630 : _res = NULL;
12175 9946980 : done:
12176 9946980 : p->level--;
12177 9946980 : return _res;
12178 : }
12179 :
12180 : // notin_bitwise_or: 'not' 'in' bitwise_or
12181 : static CmpopExprPair*
12182 9933630 : notin_bitwise_or_rule(Parser *p)
12183 : {
12184 9933630 : if (p->level++ == MAXSTACK) {
12185 0 : p->error_indicator = 1;
12186 0 : PyErr_NoMemory();
12187 : }
12188 9933630 : if (p->error_indicator) {
12189 0 : p->level--;
12190 0 : return NULL;
12191 : }
12192 9933630 : CmpopExprPair* _res = NULL;
12193 9933630 : int _mark = p->mark;
12194 : { // 'not' 'in' bitwise_or
12195 9933630 : if (p->error_indicator) {
12196 0 : p->level--;
12197 0 : return NULL;
12198 : }
12199 9933630 : 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 9933630 : if (
12204 9933630 : (_keyword = _PyPegen_expect_token(p, 581)) // token='not'
12205 10940 : &&
12206 10940 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
12207 10940 : &&
12208 10940 : (a = bitwise_or_rule(p)) // bitwise_or
12209 : )
12210 : {
12211 10940 : D(fprintf(stderr, "%*c+ notin_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or"));
12212 10940 : _res = _PyPegen_cmpop_expr_pair ( p , NotIn , a );
12213 10940 : if (_res == NULL && PyErr_Occurred()) {
12214 0 : p->error_indicator = 1;
12215 0 : p->level--;
12216 0 : return NULL;
12217 : }
12218 10940 : goto done;
12219 : }
12220 9922690 : p->mark = _mark;
12221 9922690 : 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 9922690 : _res = NULL;
12225 9933630 : done:
12226 9933630 : p->level--;
12227 9933630 : return _res;
12228 : }
12229 :
12230 : // in_bitwise_or: 'in' bitwise_or
12231 : static CmpopExprPair*
12232 9922690 : in_bitwise_or_rule(Parser *p)
12233 : {
12234 9922690 : if (p->level++ == MAXSTACK) {
12235 0 : p->error_indicator = 1;
12236 0 : PyErr_NoMemory();
12237 : }
12238 9922690 : if (p->error_indicator) {
12239 0 : p->level--;
12240 0 : return NULL;
12241 : }
12242 9922690 : CmpopExprPair* _res = NULL;
12243 9922690 : int _mark = p->mark;
12244 : { // 'in' bitwise_or
12245 9922690 : if (p->error_indicator) {
12246 0 : p->level--;
12247 0 : return NULL;
12248 : }
12249 9922690 : 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 9922690 : if (
12253 9922690 : (_keyword = _PyPegen_expect_token(p, 643)) // token='in'
12254 32118 : &&
12255 32118 : (a = bitwise_or_rule(p)) // bitwise_or
12256 : )
12257 : {
12258 32118 : D(fprintf(stderr, "%*c+ in_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or"));
12259 32118 : _res = _PyPegen_cmpop_expr_pair ( p , In , a );
12260 32118 : if (_res == NULL && PyErr_Occurred()) {
12261 0 : p->error_indicator = 1;
12262 0 : p->level--;
12263 0 : return NULL;
12264 : }
12265 32118 : goto done;
12266 : }
12267 9890570 : p->mark = _mark;
12268 9890570 : 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 9890570 : _res = NULL;
12272 9922690 : done:
12273 9922690 : p->level--;
12274 9922690 : return _res;
12275 : }
12276 :
12277 : // isnot_bitwise_or: 'is' 'not' bitwise_or
12278 : static CmpopExprPair*
12279 9890570 : isnot_bitwise_or_rule(Parser *p)
12280 : {
12281 9890570 : if (p->level++ == MAXSTACK) {
12282 0 : p->error_indicator = 1;
12283 0 : PyErr_NoMemory();
12284 : }
12285 9890570 : if (p->error_indicator) {
12286 0 : p->level--;
12287 0 : return NULL;
12288 : }
12289 9890570 : CmpopExprPair* _res = NULL;
12290 9890570 : int _mark = p->mark;
12291 : { // 'is' 'not' bitwise_or
12292 9890570 : if (p->error_indicator) {
12293 0 : p->level--;
12294 0 : return NULL;
12295 : }
12296 9890570 : 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 9890570 : if (
12301 9890570 : (_keyword = _PyPegen_expect_token(p, 582)) // token='is'
12302 68385 : &&
12303 68385 : (_keyword_1 = _PyPegen_expect_token(p, 581)) // token='not'
12304 28396 : &&
12305 28396 : (a = bitwise_or_rule(p)) // bitwise_or
12306 : )
12307 : {
12308 28396 : D(fprintf(stderr, "%*c+ isnot_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or"));
12309 28396 : _res = _PyPegen_cmpop_expr_pair ( p , IsNot , a );
12310 28396 : if (_res == NULL && PyErr_Occurred()) {
12311 0 : p->error_indicator = 1;
12312 0 : p->level--;
12313 0 : return NULL;
12314 : }
12315 28396 : goto done;
12316 : }
12317 9862180 : p->mark = _mark;
12318 9862180 : 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 9862180 : _res = NULL;
12322 9890570 : done:
12323 9890570 : p->level--;
12324 9890570 : return _res;
12325 : }
12326 :
12327 : // is_bitwise_or: 'is' bitwise_or
12328 : static CmpopExprPair*
12329 9862180 : is_bitwise_or_rule(Parser *p)
12330 : {
12331 9862180 : if (p->level++ == MAXSTACK) {
12332 0 : p->error_indicator = 1;
12333 0 : PyErr_NoMemory();
12334 : }
12335 9862180 : if (p->error_indicator) {
12336 0 : p->level--;
12337 0 : return NULL;
12338 : }
12339 9862180 : CmpopExprPair* _res = NULL;
12340 9862180 : int _mark = p->mark;
12341 : { // 'is' bitwise_or
12342 9862180 : if (p->error_indicator) {
12343 0 : p->level--;
12344 0 : return NULL;
12345 : }
12346 9862180 : 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 9862180 : if (
12350 9862180 : (_keyword = _PyPegen_expect_token(p, 582)) // token='is'
12351 39989 : &&
12352 39989 : (a = bitwise_or_rule(p)) // bitwise_or
12353 : )
12354 : {
12355 39989 : D(fprintf(stderr, "%*c+ is_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or"));
12356 39989 : _res = _PyPegen_cmpop_expr_pair ( p , Is , a );
12357 39989 : if (_res == NULL && PyErr_Occurred()) {
12358 0 : p->error_indicator = 1;
12359 0 : p->level--;
12360 0 : return NULL;
12361 : }
12362 39989 : goto done;
12363 : }
12364 9822190 : p->mark = _mark;
12365 9822190 : 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 9822190 : _res = NULL;
12369 9862180 : done:
12370 9862180 : p->level--;
12371 9862180 : 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 46720000 : bitwise_or_rule(Parser *p)
12379 : {
12380 46720000 : if (p->level++ == MAXSTACK) {
12381 0 : p->error_indicator = 1;
12382 0 : PyErr_NoMemory();
12383 : }
12384 46720000 : expr_ty _res = NULL;
12385 46720000 : if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) {
12386 34343700 : p->level--;
12387 34343700 : return _res;
12388 : }
12389 12376300 : int _mark = p->mark;
12390 12376300 : int _resmark = p->mark;
12391 10078800 : while (1) {
12392 22455200 : int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res);
12393 22455200 : if (tmpvar_2) {
12394 0 : p->level--;
12395 0 : return _res;
12396 : }
12397 22455200 : p->mark = _mark;
12398 22455200 : void *_raw = bitwise_or_raw(p);
12399 22455200 : if (p->error_indicator) {
12400 850 : p->level--;
12401 850 : return NULL;
12402 : }
12403 22454300 : if (_raw == NULL || p->mark <= _resmark)
12404 : break;
12405 10078800 : _resmark = p->mark;
12406 10078800 : _res = _raw;
12407 : }
12408 12375500 : p->mark = _resmark;
12409 12375500 : p->level--;
12410 12375500 : return _res;
12411 : }
12412 : static expr_ty
12413 22455200 : bitwise_or_raw(Parser *p)
12414 : {
12415 22455200 : if (p->level++ == MAXSTACK) {
12416 0 : p->error_indicator = 1;
12417 0 : PyErr_NoMemory();
12418 : }
12419 22455200 : if (p->error_indicator) {
12420 0 : p->level--;
12421 0 : return NULL;
12422 : }
12423 22455200 : expr_ty _res = NULL;
12424 22455200 : int _mark = p->mark;
12425 22455200 : 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 22455200 : int _start_lineno = p->tokens[_mark]->lineno;
12431 : UNUSED(_start_lineno); // Only used by EXTRA macro
12432 22455200 : 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 22455200 : if (p->error_indicator) {
12436 0 : p->level--;
12437 0 : return NULL;
12438 : }
12439 22455200 : 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 22455200 : if (
12444 22455200 : (a = bitwise_or_rule(p)) // bitwise_or
12445 10078800 : &&
12446 10078800 : (_literal = _PyPegen_expect_token(p, 18)) // token='|'
12447 7994 : &&
12448 7994 : (b = bitwise_xor_rule(p)) // bitwise_xor
12449 : )
12450 : {
12451 7990 : D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor"));
12452 7990 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12453 7990 : if (_token == NULL) {
12454 0 : p->level--;
12455 0 : return NULL;
12456 : }
12457 7990 : int _end_lineno = _token->end_lineno;
12458 : UNUSED(_end_lineno); // Only used by EXTRA macro
12459 7990 : int _end_col_offset = _token->end_col_offset;
12460 : UNUSED(_end_col_offset); // Only used by EXTRA macro
12461 7990 : _res = _PyAST_BinOp ( a , BitOr , b , EXTRA );
12462 7990 : if (_res == NULL && PyErr_Occurred()) {
12463 0 : p->error_indicator = 1;
12464 0 : p->level--;
12465 0 : return NULL;
12466 : }
12467 7990 : goto done;
12468 : }
12469 22447200 : p->mark = _mark;
12470 22447200 : 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 22447200 : if (p->error_indicator) {
12475 0 : p->level--;
12476 0 : return NULL;
12477 : }
12478 22447200 : D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));
12479 : expr_ty bitwise_xor_var;
12480 22447200 : if (
12481 22447200 : (bitwise_xor_var = bitwise_xor_rule(p)) // bitwise_xor
12482 : )
12483 : {
12484 20141700 : D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));
12485 20141700 : _res = bitwise_xor_var;
12486 20141700 : goto done;
12487 : }
12488 2305480 : p->mark = _mark;
12489 2305480 : 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 2305480 : _res = NULL;
12493 22455200 : done:
12494 22455200 : p->level--;
12495 22455200 : 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 44919300 : bitwise_xor_rule(Parser *p)
12503 : {
12504 44919300 : if (p->level++ == MAXSTACK) {
12505 0 : p->error_indicator = 1;
12506 0 : PyErr_NoMemory();
12507 : }
12508 44919300 : expr_ty _res = NULL;
12509 44919300 : if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) {
12510 32535000 : p->level--;
12511 32535000 : return _res;
12512 : }
12513 12384300 : int _mark = p->mark;
12514 12384300 : int _resmark = p->mark;
12515 10079900 : while (1) {
12516 22464200 : int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res);
12517 22464200 : if (tmpvar_3) {
12518 0 : p->level--;
12519 0 : return _res;
12520 : }
12521 22464200 : p->mark = _mark;
12522 22464200 : void *_raw = bitwise_xor_raw(p);
12523 22464200 : if (p->error_indicator) {
12524 850 : p->level--;
12525 850 : return NULL;
12526 : }
12527 22463300 : if (_raw == NULL || p->mark <= _resmark)
12528 : break;
12529 10079900 : _resmark = p->mark;
12530 10079900 : _res = _raw;
12531 : }
12532 12383500 : p->mark = _resmark;
12533 12383500 : p->level--;
12534 12383500 : return _res;
12535 : }
12536 : static expr_ty
12537 22464200 : bitwise_xor_raw(Parser *p)
12538 : {
12539 22464200 : if (p->level++ == MAXSTACK) {
12540 0 : p->error_indicator = 1;
12541 0 : PyErr_NoMemory();
12542 : }
12543 22464200 : if (p->error_indicator) {
12544 0 : p->level--;
12545 0 : return NULL;
12546 : }
12547 22464200 : expr_ty _res = NULL;
12548 22464200 : int _mark = p->mark;
12549 22464200 : 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 22464200 : int _start_lineno = p->tokens[_mark]->lineno;
12555 : UNUSED(_start_lineno); // Only used by EXTRA macro
12556 22464200 : 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 22464200 : if (p->error_indicator) {
12560 0 : p->level--;
12561 0 : return NULL;
12562 : }
12563 22464200 : 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 22464200 : if (
12568 22464200 : (a = bitwise_xor_rule(p)) // bitwise_xor
12569 10079900 : &&
12570 10079900 : (_literal = _PyPegen_expect_token(p, 32)) // token='^'
12571 1034 : &&
12572 1034 : (b = bitwise_and_rule(p)) // bitwise_and
12573 : )
12574 : {
12575 1034 : D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and"));
12576 1034 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12577 1034 : if (_token == NULL) {
12578 0 : p->level--;
12579 0 : return NULL;
12580 : }
12581 1034 : int _end_lineno = _token->end_lineno;
12582 : UNUSED(_end_lineno); // Only used by EXTRA macro
12583 1034 : int _end_col_offset = _token->end_col_offset;
12584 : UNUSED(_end_col_offset); // Only used by EXTRA macro
12585 1034 : _res = _PyAST_BinOp ( a , BitXor , b , EXTRA );
12586 1034 : if (_res == NULL && PyErr_Occurred()) {
12587 0 : p->error_indicator = 1;
12588 0 : p->level--;
12589 0 : return NULL;
12590 : }
12591 1034 : goto done;
12592 : }
12593 22463200 : p->mark = _mark;
12594 22463200 : 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 22463200 : if (p->error_indicator) {
12599 0 : p->level--;
12600 0 : return NULL;
12601 : }
12602 22463200 : D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and"));
12603 : expr_ty bitwise_and_var;
12604 22463200 : if (
12605 22463200 : (bitwise_and_var = bitwise_and_rule(p)) // bitwise_and
12606 : )
12607 : {
12608 20157700 : D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and"));
12609 20157700 : _res = bitwise_and_var;
12610 20157700 : goto done;
12611 : }
12612 2305480 : p->mark = _mark;
12613 2305480 : 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 2305480 : _res = NULL;
12617 22464200 : done:
12618 22464200 : p->level--;
12619 22464200 : 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 44935800 : bitwise_and_rule(Parser *p)
12627 : {
12628 44935800 : if (p->level++ == MAXSTACK) {
12629 0 : p->error_indicator = 1;
12630 0 : PyErr_NoMemory();
12631 : }
12632 44935800 : expr_ty _res = NULL;
12633 44935800 : if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) {
12634 32550400 : p->level--;
12635 32550400 : return _res;
12636 : }
12637 12385400 : int _mark = p->mark;
12638 12385400 : int _resmark = p->mark;
12639 10086200 : while (1) {
12640 22471600 : int tmpvar_4 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res);
12641 22471600 : if (tmpvar_4) {
12642 0 : p->level--;
12643 0 : return _res;
12644 : }
12645 22471600 : p->mark = _mark;
12646 22471600 : void *_raw = bitwise_and_raw(p);
12647 22471600 : if (p->error_indicator) {
12648 850 : p->level--;
12649 850 : return NULL;
12650 : }
12651 22470700 : if (_raw == NULL || p->mark <= _resmark)
12652 : break;
12653 10086200 : _resmark = p->mark;
12654 10086200 : _res = _raw;
12655 : }
12656 12384500 : p->mark = _resmark;
12657 12384500 : p->level--;
12658 12384500 : return _res;
12659 : }
12660 : static expr_ty
12661 22471600 : bitwise_and_raw(Parser *p)
12662 : {
12663 22471600 : if (p->level++ == MAXSTACK) {
12664 0 : p->error_indicator = 1;
12665 0 : PyErr_NoMemory();
12666 : }
12667 22471600 : if (p->error_indicator) {
12668 0 : p->level--;
12669 0 : return NULL;
12670 : }
12671 22471600 : expr_ty _res = NULL;
12672 22471600 : int _mark = p->mark;
12673 22471600 : 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 22471600 : int _start_lineno = p->tokens[_mark]->lineno;
12679 : UNUSED(_start_lineno); // Only used by EXTRA macro
12680 22471600 : 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 22471600 : if (p->error_indicator) {
12684 0 : p->level--;
12685 0 : return NULL;
12686 : }
12687 22471600 : 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 22471600 : if (
12692 22471600 : (a = bitwise_and_rule(p)) // bitwise_and
12693 10086200 : &&
12694 10086200 : (_literal = _PyPegen_expect_token(p, 19)) // token='&'
12695 6370 : &&
12696 6370 : (b = shift_expr_rule(p)) // shift_expr
12697 : )
12698 : {
12699 6370 : D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr"));
12700 6370 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12701 6370 : if (_token == NULL) {
12702 0 : p->level--;
12703 0 : return NULL;
12704 : }
12705 6370 : int _end_lineno = _token->end_lineno;
12706 : UNUSED(_end_lineno); // Only used by EXTRA macro
12707 6370 : int _end_col_offset = _token->end_col_offset;
12708 : UNUSED(_end_col_offset); // Only used by EXTRA macro
12709 6370 : _res = _PyAST_BinOp ( a , BitAnd , b , EXTRA );
12710 6370 : if (_res == NULL && PyErr_Occurred()) {
12711 0 : p->error_indicator = 1;
12712 0 : p->level--;
12713 0 : return NULL;
12714 : }
12715 6370 : goto done;
12716 : }
12717 22465200 : p->mark = _mark;
12718 22465200 : 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 22465200 : if (p->error_indicator) {
12723 0 : p->level--;
12724 0 : return NULL;
12725 : }
12726 22465200 : D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr"));
12727 : expr_ty shift_expr_var;
12728 22465200 : if (
12729 22465200 : (shift_expr_var = shift_expr_rule(p)) // shift_expr
12730 : )
12731 : {
12732 20159700 : D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr"));
12733 20159700 : _res = shift_expr_var;
12734 20159700 : goto done;
12735 : }
12736 2305480 : p->mark = _mark;
12737 2305480 : 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 2305480 : _res = NULL;
12741 22471600 : done:
12742 22471600 : p->level--;
12743 22471600 : 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 67433700 : shift_expr_rule(Parser *p)
12751 : {
12752 67433700 : if (p->level++ == MAXSTACK) {
12753 0 : p->error_indicator = 1;
12754 0 : PyErr_NoMemory();
12755 : }
12756 67433700 : expr_ty _res = NULL;
12757 67433700 : if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) {
12758 55042000 : p->level--;
12759 55042000 : return _res;
12760 : }
12761 12391700 : int _mark = p->mark;
12762 12391700 : int _resmark = p->mark;
12763 10091100 : while (1) {
12764 22482800 : int tmpvar_5 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res);
12765 22482800 : if (tmpvar_5) {
12766 0 : p->level--;
12767 0 : return _res;
12768 : }
12769 22482800 : p->mark = _mark;
12770 22482800 : void *_raw = shift_expr_raw(p);
12771 22482800 : if (p->error_indicator) {
12772 850 : p->level--;
12773 850 : return NULL;
12774 : }
12775 22482000 : if (_raw == NULL || p->mark <= _resmark)
12776 : break;
12777 10091100 : _resmark = p->mark;
12778 10091100 : _res = _raw;
12779 : }
12780 12390900 : p->mark = _resmark;
12781 12390900 : p->level--;
12782 12390900 : return _res;
12783 : }
12784 : static expr_ty
12785 22482800 : shift_expr_raw(Parser *p)
12786 : {
12787 22482800 : if (p->level++ == MAXSTACK) {
12788 0 : p->error_indicator = 1;
12789 0 : PyErr_NoMemory();
12790 : }
12791 22482800 : if (p->error_indicator) {
12792 0 : p->level--;
12793 0 : return NULL;
12794 : }
12795 22482800 : expr_ty _res = NULL;
12796 22482800 : int _mark = p->mark;
12797 22482800 : 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 22482800 : int _start_lineno = p->tokens[_mark]->lineno;
12803 : UNUSED(_start_lineno); // Only used by EXTRA macro
12804 22482800 : int _start_col_offset = p->tokens[_mark]->col_offset;
12805 : UNUSED(_start_col_offset); // Only used by EXTRA macro
12806 : { // shift_expr '<<' sum
12807 22482800 : if (p->error_indicator) {
12808 0 : p->level--;
12809 0 : return NULL;
12810 : }
12811 22482800 : 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 22482800 : if (
12816 22482800 : (a = shift_expr_rule(p)) // shift_expr
12817 10091100 : &&
12818 10091100 : (_literal = _PyPegen_expect_token(p, 33)) // token='<<'
12819 3533 : &&
12820 3533 : (b = sum_rule(p)) // sum
12821 : )
12822 : {
12823 3533 : D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum"));
12824 3533 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12825 3533 : if (_token == NULL) {
12826 0 : p->level--;
12827 0 : return NULL;
12828 : }
12829 3533 : int _end_lineno = _token->end_lineno;
12830 : UNUSED(_end_lineno); // Only used by EXTRA macro
12831 3533 : int _end_col_offset = _token->end_col_offset;
12832 : UNUSED(_end_col_offset); // Only used by EXTRA macro
12833 3533 : _res = _PyAST_BinOp ( a , LShift , b , EXTRA );
12834 3533 : if (_res == NULL && PyErr_Occurred()) {
12835 0 : p->error_indicator = 1;
12836 0 : p->level--;
12837 0 : return NULL;
12838 : }
12839 3533 : goto done;
12840 : }
12841 22479300 : p->mark = _mark;
12842 22479300 : 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 22479300 : if (p->error_indicator) {
12847 0 : p->level--;
12848 0 : return NULL;
12849 : }
12850 22479300 : 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 22479300 : if (
12855 22479300 : (a = shift_expr_rule(p)) // shift_expr
12856 10087600 : &&
12857 10087600 : (_literal = _PyPegen_expect_token(p, 34)) // token='>>'
12858 1328 : &&
12859 1328 : (b = sum_rule(p)) // sum
12860 : )
12861 : {
12862 1328 : D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum"));
12863 1328 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12864 1328 : if (_token == NULL) {
12865 0 : p->level--;
12866 0 : return NULL;
12867 : }
12868 1328 : int _end_lineno = _token->end_lineno;
12869 : UNUSED(_end_lineno); // Only used by EXTRA macro
12870 1328 : int _end_col_offset = _token->end_col_offset;
12871 : UNUSED(_end_col_offset); // Only used by EXTRA macro
12872 1328 : _res = _PyAST_BinOp ( a , RShift , b , EXTRA );
12873 1328 : if (_res == NULL && PyErr_Occurred()) {
12874 0 : p->error_indicator = 1;
12875 0 : p->level--;
12876 0 : return NULL;
12877 : }
12878 1328 : goto done;
12879 : }
12880 22478000 : p->mark = _mark;
12881 22478000 : 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 22478000 : if (p->error_indicator) {
12886 0 : p->level--;
12887 0 : return NULL;
12888 : }
12889 22478000 : D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum"));
12890 : expr_ty sum_var;
12891 22478000 : if (
12892 22478000 : (sum_var = sum_rule(p)) // sum
12893 : )
12894 : {
12895 20172500 : D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum"));
12896 20172500 : _res = sum_var;
12897 20172500 : goto done;
12898 : }
12899 2305480 : p->mark = _mark;
12900 2305480 : 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 2305480 : _res = NULL;
12904 22482800 : done:
12905 22482800 : p->level--;
12906 22482800 : 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 67649600 : sum_rule(Parser *p)
12914 : {
12915 67649600 : if (p->level++ == MAXSTACK) {
12916 0 : p->error_indicator = 1;
12917 0 : PyErr_NoMemory();
12918 : }
12919 67649600 : expr_ty _res = NULL;
12920 67649600 : if (_PyPegen_is_memoized(p, sum_type, &_res)) {
12921 55253000 : p->level--;
12922 55253000 : return _res;
12923 : }
12924 12396600 : int _mark = p->mark;
12925 12396600 : int _resmark = p->mark;
12926 10233800 : while (1) {
12927 22630400 : int tmpvar_6 = _PyPegen_update_memo(p, _mark, sum_type, _res);
12928 22630400 : if (tmpvar_6) {
12929 0 : p->level--;
12930 0 : return _res;
12931 : }
12932 22630400 : p->mark = _mark;
12933 22630400 : void *_raw = sum_raw(p);
12934 22630400 : if (p->error_indicator) {
12935 850 : p->level--;
12936 850 : return NULL;
12937 : }
12938 22629600 : if (_raw == NULL || p->mark <= _resmark)
12939 : break;
12940 10233800 : _resmark = p->mark;
12941 10233800 : _res = _raw;
12942 : }
12943 12395700 : p->mark = _resmark;
12944 12395700 : p->level--;
12945 12395700 : return _res;
12946 : }
12947 : static expr_ty
12948 22630400 : sum_raw(Parser *p)
12949 : {
12950 22630400 : if (p->level++ == MAXSTACK) {
12951 0 : p->error_indicator = 1;
12952 0 : PyErr_NoMemory();
12953 : }
12954 22630400 : if (p->error_indicator) {
12955 0 : p->level--;
12956 0 : return NULL;
12957 : }
12958 22630400 : expr_ty _res = NULL;
12959 22630400 : int _mark = p->mark;
12960 22630400 : 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 22630400 : int _start_lineno = p->tokens[_mark]->lineno;
12966 : UNUSED(_start_lineno); // Only used by EXTRA macro
12967 22630400 : int _start_col_offset = p->tokens[_mark]->col_offset;
12968 : UNUSED(_start_col_offset); // Only used by EXTRA macro
12969 : { // sum '+' term
12970 22630400 : if (p->error_indicator) {
12971 0 : p->level--;
12972 0 : return NULL;
12973 : }
12974 22630400 : 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 22630400 : if (
12979 22630400 : (a = sum_rule(p)) // sum
12980 10233800 : &&
12981 10233800 : (_literal = _PyPegen_expect_token(p, 14)) // token='+'
12982 94055 : &&
12983 94055 : (b = term_rule(p)) // term
12984 : )
12985 : {
12986 94007 : D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term"));
12987 94007 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12988 94007 : if (_token == NULL) {
12989 0 : p->level--;
12990 0 : return NULL;
12991 : }
12992 94007 : int _end_lineno = _token->end_lineno;
12993 : UNUSED(_end_lineno); // Only used by EXTRA macro
12994 94007 : int _end_col_offset = _token->end_col_offset;
12995 : UNUSED(_end_col_offset); // Only used by EXTRA macro
12996 94007 : _res = _PyAST_BinOp ( a , Add , b , EXTRA );
12997 94007 : if (_res == NULL && PyErr_Occurred()) {
12998 0 : p->error_indicator = 1;
12999 0 : p->level--;
13000 0 : return NULL;
13001 : }
13002 94007 : goto done;
13003 : }
13004 22536400 : p->mark = _mark;
13005 22536400 : 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 22536400 : if (p->error_indicator) {
13010 16 : p->level--;
13011 16 : return NULL;
13012 : }
13013 22536400 : 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 22536400 : if (
13018 22536400 : (a = sum_rule(p)) // sum
13019 10139800 : &&
13020 10139800 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
13021 48703 : &&
13022 48703 : (b = term_rule(p)) // term
13023 : )
13024 : {
13025 48702 : D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term"));
13026 48702 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13027 48702 : if (_token == NULL) {
13028 0 : p->level--;
13029 0 : return NULL;
13030 : }
13031 48702 : int _end_lineno = _token->end_lineno;
13032 : UNUSED(_end_lineno); // Only used by EXTRA macro
13033 48702 : int _end_col_offset = _token->end_col_offset;
13034 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13035 48702 : _res = _PyAST_BinOp ( a , Sub , b , EXTRA );
13036 48702 : if (_res == NULL && PyErr_Occurred()) {
13037 0 : p->error_indicator = 1;
13038 0 : p->level--;
13039 0 : return NULL;
13040 : }
13041 48702 : goto done;
13042 : }
13043 22487700 : p->mark = _mark;
13044 22487700 : 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 22487700 : if (p->error_indicator) {
13049 1 : p->level--;
13050 1 : return NULL;
13051 : }
13052 22487700 : D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term"));
13053 : expr_ty term_var;
13054 22487700 : if (
13055 22487700 : (term_var = term_rule(p)) // term
13056 : )
13057 : {
13058 20182200 : D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term"));
13059 20182200 : _res = term_var;
13060 20182200 : goto done;
13061 : }
13062 2305460 : p->mark = _mark;
13063 2305460 : D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',
13064 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term"));
13065 : }
13066 2305460 : _res = NULL;
13067 22630400 : done:
13068 22630400 : p->level--;
13069 22630400 : 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 137113000 : term_rule(Parser *p)
13083 : {
13084 137113000 : if (p->level++ == MAXSTACK) {
13085 0 : p->error_indicator = 1;
13086 0 : PyErr_NoMemory();
13087 : }
13088 137113000 : expr_ty _res = NULL;
13089 137113000 : if (_PyPegen_is_memoized(p, term_type, &_res)) {
13090 124574000 : p->level--;
13091 124574000 : return _res;
13092 : }
13093 12539300 : int _mark = p->mark;
13094 12539300 : int _resmark = p->mark;
13095 10640500 : while (1) {
13096 23179800 : int tmpvar_7 = _PyPegen_update_memo(p, _mark, term_type, _res);
13097 23179800 : if (tmpvar_7) {
13098 0 : p->level--;
13099 0 : return _res;
13100 : }
13101 23179800 : p->mark = _mark;
13102 23179800 : void *_raw = term_raw(p);
13103 23179800 : if (p->error_indicator) {
13104 840 : p->level--;
13105 840 : return NULL;
13106 : }
13107 23179000 : if (_raw == NULL || p->mark <= _resmark)
13108 : break;
13109 10640500 : _resmark = p->mark;
13110 10640500 : _res = _raw;
13111 : }
13112 12538500 : p->mark = _resmark;
13113 12538500 : p->level--;
13114 12538500 : return _res;
13115 : }
13116 : static expr_ty
13117 23179800 : term_raw(Parser *p)
13118 : {
13119 23179800 : if (p->level++ == MAXSTACK) {
13120 0 : p->error_indicator = 1;
13121 0 : PyErr_NoMemory();
13122 : }
13123 23179800 : if (p->error_indicator) {
13124 0 : p->level--;
13125 0 : return NULL;
13126 : }
13127 23179800 : expr_ty _res = NULL;
13128 23179800 : int _mark = p->mark;
13129 23179800 : 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 23179800 : int _start_lineno = p->tokens[_mark]->lineno;
13135 : UNUSED(_start_lineno); // Only used by EXTRA macro
13136 23179800 : int _start_col_offset = p->tokens[_mark]->col_offset;
13137 : UNUSED(_start_col_offset); // Only used by EXTRA macro
13138 : { // term '*' factor
13139 23179800 : if (p->error_indicator) {
13140 0 : p->level--;
13141 0 : return NULL;
13142 : }
13143 23179800 : 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 23179800 : if (
13148 23179800 : (a = term_rule(p)) // term
13149 10640500 : &&
13150 10640500 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
13151 330764 : &&
13152 330764 : (b = factor_rule(p)) // factor
13153 : )
13154 : {
13155 330764 : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' factor"));
13156 330764 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13157 330764 : if (_token == NULL) {
13158 0 : p->level--;
13159 0 : return NULL;
13160 : }
13161 330764 : int _end_lineno = _token->end_lineno;
13162 : UNUSED(_end_lineno); // Only used by EXTRA macro
13163 330764 : int _end_col_offset = _token->end_col_offset;
13164 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13165 330764 : _res = _PyAST_BinOp ( a , Mult , b , EXTRA );
13166 330764 : if (_res == NULL && PyErr_Occurred()) {
13167 0 : p->error_indicator = 1;
13168 0 : p->level--;
13169 0 : return NULL;
13170 : }
13171 330764 : goto done;
13172 : }
13173 22849100 : p->mark = _mark;
13174 22849100 : 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 22849100 : if (p->error_indicator) {
13179 0 : p->level--;
13180 0 : return NULL;
13181 : }
13182 22849100 : 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 22849100 : if (
13187 22849100 : (a = term_rule(p)) // term
13188 10309700 : &&
13189 10309700 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
13190 7071 : &&
13191 7071 : (b = factor_rule(p)) // factor
13192 : )
13193 : {
13194 7065 : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' factor"));
13195 7065 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13196 7065 : if (_token == NULL) {
13197 0 : p->level--;
13198 0 : return NULL;
13199 : }
13200 7065 : int _end_lineno = _token->end_lineno;
13201 : UNUSED(_end_lineno); // Only used by EXTRA macro
13202 7065 : int _end_col_offset = _token->end_col_offset;
13203 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13204 7065 : _res = _PyAST_BinOp ( a , Div , b , EXTRA );
13205 7065 : if (_res == NULL && PyErr_Occurred()) {
13206 0 : p->error_indicator = 1;
13207 0 : p->level--;
13208 0 : return NULL;
13209 : }
13210 7065 : goto done;
13211 : }
13212 22842000 : p->mark = _mark;
13213 22842000 : 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 22842000 : if (p->error_indicator) {
13218 0 : p->level--;
13219 0 : return NULL;
13220 : }
13221 22842000 : 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 22842000 : if (
13226 22842000 : (a = term_rule(p)) // term
13227 10302700 : &&
13228 10302700 : (_literal = _PyPegen_expect_token(p, 47)) // token='//'
13229 3465 : &&
13230 3465 : (b = factor_rule(p)) // factor
13231 : )
13232 : {
13233 3465 : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' factor"));
13234 3465 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13235 3465 : if (_token == NULL) {
13236 0 : p->level--;
13237 0 : return NULL;
13238 : }
13239 3465 : int _end_lineno = _token->end_lineno;
13240 : UNUSED(_end_lineno); // Only used by EXTRA macro
13241 3465 : int _end_col_offset = _token->end_col_offset;
13242 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13243 3465 : _res = _PyAST_BinOp ( a , FloorDiv , b , EXTRA );
13244 3465 : if (_res == NULL && PyErr_Occurred()) {
13245 0 : p->error_indicator = 1;
13246 0 : p->level--;
13247 0 : return NULL;
13248 : }
13249 3465 : goto done;
13250 : }
13251 22838500 : p->mark = _mark;
13252 22838500 : 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 22838500 : if (p->error_indicator) {
13257 0 : p->level--;
13258 0 : return NULL;
13259 : }
13260 22838500 : 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 22838500 : if (
13265 22838500 : (a = term_rule(p)) // term
13266 10299200 : &&
13267 10299200 : (_literal = _PyPegen_expect_token(p, 24)) // token='%'
13268 65313 : &&
13269 65313 : (b = factor_rule(p)) // factor
13270 : )
13271 : {
13272 65313 : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' factor"));
13273 65313 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13274 65313 : if (_token == NULL) {
13275 0 : p->level--;
13276 0 : return NULL;
13277 : }
13278 65313 : int _end_lineno = _token->end_lineno;
13279 : UNUSED(_end_lineno); // Only used by EXTRA macro
13280 65313 : int _end_col_offset = _token->end_col_offset;
13281 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13282 65313 : _res = _PyAST_BinOp ( a , Mod , b , EXTRA );
13283 65313 : if (_res == NULL && PyErr_Occurred()) {
13284 0 : p->error_indicator = 1;
13285 0 : p->level--;
13286 0 : return NULL;
13287 : }
13288 65313 : goto done;
13289 : }
13290 22773200 : p->mark = _mark;
13291 22773200 : 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 22773200 : if (p->error_indicator) {
13296 0 : p->level--;
13297 0 : return NULL;
13298 : }
13299 22773200 : 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 22773200 : if (
13304 22773200 : (a = term_rule(p)) // term
13305 10233900 : &&
13306 10233900 : (_literal = _PyPegen_expect_token(p, 49)) // token='@'
13307 77 : &&
13308 77 : (b = factor_rule(p)) // factor
13309 : )
13310 : {
13311 72 : 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 22773200 : p->mark = _mark;
13330 22773200 : 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 22773200 : if (p->error_indicator) {
13335 0 : p->level--;
13336 0 : return NULL;
13337 : }
13338 22773200 : D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "factor"));
13339 : expr_ty factor_var;
13340 22773200 : if (
13341 22773200 : (factor_var = factor_rule(p)) // factor
13342 : )
13343 : {
13344 20467700 : D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "factor"));
13345 20467700 : _res = factor_var;
13346 20467700 : goto done;
13347 : }
13348 2305500 : p->mark = _mark;
13349 2305500 : D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
13350 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "factor"));
13351 : }
13352 2305500 : _res = NULL;
13353 23179800 : done:
13354 23179800 : p->level--;
13355 23179800 : return _res;
13356 : }
13357 :
13358 : // factor: '+' factor | '-' factor | '~' factor | power
13359 : static expr_ty
13360 23248900 : factor_rule(Parser *p)
13361 : {
13362 23248900 : if (p->level++ == MAXSTACK) {
13363 3 : p->error_indicator = 1;
13364 3 : PyErr_NoMemory();
13365 : }
13366 23248900 : if (p->error_indicator) {
13367 3 : p->level--;
13368 3 : return NULL;
13369 : }
13370 23248900 : expr_ty _res = NULL;
13371 23248900 : if (_PyPegen_is_memoized(p, factor_type, &_res)) {
13372 10233900 : p->level--;
13373 10233900 : return _res;
13374 : }
13375 13015100 : int _mark = p->mark;
13376 13015100 : 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 13015100 : int _start_lineno = p->tokens[_mark]->lineno;
13382 : UNUSED(_start_lineno); // Only used by EXTRA macro
13383 13015100 : int _start_col_offset = p->tokens[_mark]->col_offset;
13384 : UNUSED(_start_col_offset); // Only used by EXTRA macro
13385 : { // '+' factor
13386 13015100 : if (p->error_indicator) {
13387 0 : p->level--;
13388 0 : return NULL;
13389 : }
13390 13015100 : D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+' factor"));
13391 : Token * _literal;
13392 : expr_ty a;
13393 13015100 : if (
13394 13015100 : (_literal = _PyPegen_expect_token(p, 14)) // token='+'
13395 888 : &&
13396 888 : (a = factor_rule(p)) // factor
13397 : )
13398 : {
13399 864 : D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' factor"));
13400 864 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13401 864 : if (_token == NULL) {
13402 0 : p->level--;
13403 0 : return NULL;
13404 : }
13405 864 : int _end_lineno = _token->end_lineno;
13406 : UNUSED(_end_lineno); // Only used by EXTRA macro
13407 864 : int _end_col_offset = _token->end_col_offset;
13408 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13409 864 : _res = _PyAST_UnaryOp ( UAdd , a , EXTRA );
13410 864 : if (_res == NULL && PyErr_Occurred()) {
13411 0 : p->error_indicator = 1;
13412 0 : p->level--;
13413 0 : return NULL;
13414 : }
13415 864 : goto done;
13416 : }
13417 13014200 : p->mark = _mark;
13418 13014200 : 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 13014200 : if (p->error_indicator) {
13423 0 : p->level--;
13424 0 : return NULL;
13425 : }
13426 13014200 : D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' factor"));
13427 : Token * _literal;
13428 : expr_ty a;
13429 13014200 : if (
13430 13014200 : (_literal = _PyPegen_expect_token(p, 15)) // token='-'
13431 61648 : &&
13432 61648 : (a = factor_rule(p)) // factor
13433 : )
13434 : {
13435 43715 : D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' factor"));
13436 43715 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13437 43715 : if (_token == NULL) {
13438 0 : p->level--;
13439 0 : return NULL;
13440 : }
13441 43715 : int _end_lineno = _token->end_lineno;
13442 : UNUSED(_end_lineno); // Only used by EXTRA macro
13443 43715 : int _end_col_offset = _token->end_col_offset;
13444 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13445 43715 : _res = _PyAST_UnaryOp ( USub , a , EXTRA );
13446 43715 : if (_res == NULL && PyErr_Occurred()) {
13447 0 : p->error_indicator = 1;
13448 0 : p->level--;
13449 0 : return NULL;
13450 : }
13451 43715 : goto done;
13452 : }
13453 12970500 : p->mark = _mark;
13454 12970500 : 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 12970500 : if (p->error_indicator) {
13459 17933 : p->level--;
13460 17933 : return NULL;
13461 : }
13462 12952500 : D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~' factor"));
13463 : Token * _literal;
13464 : expr_ty a;
13465 12952500 : if (
13466 12952500 : (_literal = _PyPegen_expect_token(p, 31)) // token='~'
13467 1063 : &&
13468 1063 : (a = factor_rule(p)) // factor
13469 : )
13470 : {
13471 1063 : D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' factor"));
13472 1063 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13473 1063 : if (_token == NULL) {
13474 0 : p->level--;
13475 0 : return NULL;
13476 : }
13477 1063 : int _end_lineno = _token->end_lineno;
13478 : UNUSED(_end_lineno); // Only used by EXTRA macro
13479 1063 : int _end_col_offset = _token->end_col_offset;
13480 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13481 1063 : _res = _PyAST_UnaryOp ( Invert , a , EXTRA );
13482 1063 : if (_res == NULL && PyErr_Occurred()) {
13483 0 : p->error_indicator = 1;
13484 0 : p->level--;
13485 0 : return NULL;
13486 : }
13487 1063 : goto done;
13488 : }
13489 12951500 : p->mark = _mark;
13490 12951500 : 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 12951500 : if (p->error_indicator) {
13495 0 : p->level--;
13496 0 : return NULL;
13497 : }
13498 12951500 : D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "power"));
13499 : expr_ty power_var;
13500 12951500 : if (
13501 12951500 : (power_var = power_rule(p)) // power
13502 : )
13503 : {
13504 10646000 : D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "power"));
13505 10646000 : _res = power_var;
13506 10646000 : goto done;
13507 : }
13508 2305520 : p->mark = _mark;
13509 2305520 : D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
13510 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power"));
13511 : }
13512 2305520 : _res = NULL;
13513 12997100 : done:
13514 12997100 : _PyPegen_insert_memo(p, _mark, factor_type, _res);
13515 12997100 : p->level--;
13516 12997100 : return _res;
13517 : }
13518 :
13519 : // power: await_primary '**' factor | await_primary
13520 : static expr_ty
13521 12951500 : power_rule(Parser *p)
13522 : {
13523 12951500 : if (p->level++ == MAXSTACK) {
13524 0 : p->error_indicator = 1;
13525 0 : PyErr_NoMemory();
13526 : }
13527 12951500 : if (p->error_indicator) {
13528 0 : p->level--;
13529 0 : return NULL;
13530 : }
13531 12951500 : expr_ty _res = NULL;
13532 12951500 : int _mark = p->mark;
13533 12951500 : 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 12951500 : int _start_lineno = p->tokens[_mark]->lineno;
13539 : UNUSED(_start_lineno); // Only used by EXTRA macro
13540 12951500 : int _start_col_offset = p->tokens[_mark]->col_offset;
13541 : UNUSED(_start_col_offset); // Only used by EXTRA macro
13542 : { // await_primary '**' factor
13543 12951500 : if (p->error_indicator) {
13544 0 : p->level--;
13545 0 : return NULL;
13546 : }
13547 12951500 : 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 12951500 : if (
13552 12951500 : (a = await_primary_rule(p)) // await_primary
13553 10646000 : &&
13554 10646000 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
13555 5475 : &&
13556 5475 : (b = factor_rule(p)) // factor
13557 : )
13558 : {
13559 5470 : 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 12946000 : p->mark = _mark;
13578 12946000 : 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 12946000 : if (p->error_indicator) {
13583 836 : p->level--;
13584 836 : return NULL;
13585 : }
13586 12945200 : D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary"));
13587 : expr_ty await_primary_var;
13588 12945200 : if (
13589 12945200 : (await_primary_var = await_primary_rule(p)) // await_primary
13590 : )
13591 : {
13592 10640500 : D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary"));
13593 10640500 : _res = await_primary_var;
13594 10640500 : goto done;
13595 : }
13596 2304690 : p->mark = _mark;
13597 2304690 : 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 2304690 : _res = NULL;
13601 12950600 : done:
13602 12950600 : p->level--;
13603 12950600 : return _res;
13604 : }
13605 :
13606 : // await_primary: AWAIT primary | primary
13607 : static expr_ty
13608 25896700 : await_primary_rule(Parser *p)
13609 : {
13610 25896700 : if (p->level++ == MAXSTACK) {
13611 0 : p->error_indicator = 1;
13612 0 : PyErr_NoMemory();
13613 : }
13614 25896700 : if (p->error_indicator) {
13615 0 : p->level--;
13616 0 : return NULL;
13617 : }
13618 25896700 : expr_ty _res = NULL;
13619 25896700 : if (_PyPegen_is_memoized(p, await_primary_type, &_res)) {
13620 12945200 : p->level--;
13621 12945200 : return _res;
13622 : }
13623 12951500 : int _mark = p->mark;
13624 12951500 : 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 12951500 : int _start_lineno = p->tokens[_mark]->lineno;
13630 : UNUSED(_start_lineno); // Only used by EXTRA macro
13631 12951500 : int _start_col_offset = p->tokens[_mark]->col_offset;
13632 : UNUSED(_start_col_offset); // Only used by EXTRA macro
13633 : { // AWAIT primary
13634 12951500 : if (p->error_indicator) {
13635 0 : p->level--;
13636 0 : return NULL;
13637 : }
13638 12951500 : 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 12951500 : if (
13642 12951500 : (await_var = _PyPegen_expect_token(p, AWAIT)) // token='AWAIT'
13643 2406 : &&
13644 2406 : (a = primary_rule(p)) // primary
13645 : )
13646 : {
13647 2374 : D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AWAIT primary"));
13648 2374 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13649 2374 : if (_token == NULL) {
13650 0 : p->level--;
13651 0 : return NULL;
13652 : }
13653 2374 : int _end_lineno = _token->end_lineno;
13654 : UNUSED(_end_lineno); // Only used by EXTRA macro
13655 2374 : int _end_col_offset = _token->end_col_offset;
13656 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13657 2374 : _res = CHECK_VERSION ( expr_ty , 5 , "Await expressions are" , _PyAST_Await ( a , EXTRA ) );
13658 2374 : if (_res == NULL && PyErr_Occurred()) {
13659 1 : p->error_indicator = 1;
13660 1 : p->level--;
13661 1 : return NULL;
13662 : }
13663 2373 : goto done;
13664 : }
13665 12949100 : p->mark = _mark;
13666 12949100 : 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 12949100 : if (p->error_indicator) {
13671 0 : p->level--;
13672 0 : return NULL;
13673 : }
13674 12949100 : D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary"));
13675 : expr_ty primary_var;
13676 12949100 : if (
13677 12949100 : (primary_var = primary_rule(p)) // primary
13678 : )
13679 : {
13680 10643600 : D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary"));
13681 10643600 : _res = primary_var;
13682 10643600 : goto done;
13683 : }
13684 2305520 : p->mark = _mark;
13685 2305520 : 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 2305520 : _res = NULL;
13689 12951500 : done:
13690 12951500 : _PyPegen_insert_memo(p, _mark, await_primary_type, _res);
13691 12951500 : p->level--;
13692 12951500 : 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 116932000 : primary_rule(Parser *p)
13705 : {
13706 116932000 : if (p->level++ == MAXSTACK) {
13707 0 : p->error_indicator = 1;
13708 0 : PyErr_NoMemory();
13709 : }
13710 116932000 : expr_ty _res = NULL;
13711 116932000 : if (_PyPegen_is_memoized(p, primary_type, &_res)) {
13712 103980000 : p->level--;
13713 103980000 : return _res;
13714 : }
13715 12951500 : int _mark = p->mark;
13716 12951500 : int _resmark = p->mark;
13717 14990200 : while (1) {
13718 27941700 : int tmpvar_8 = _PyPegen_update_memo(p, _mark, primary_type, _res);
13719 27941700 : if (tmpvar_8) {
13720 0 : p->level--;
13721 0 : return _res;
13722 : }
13723 27941700 : p->mark = _mark;
13724 27941700 : void *_raw = primary_raw(p);
13725 27941700 : if (p->error_indicator) {
13726 833 : p->level--;
13727 833 : return NULL;
13728 : }
13729 27940900 : if (_raw == NULL || p->mark <= _resmark)
13730 : break;
13731 14990200 : _resmark = p->mark;
13732 14990200 : _res = _raw;
13733 : }
13734 12950700 : p->mark = _resmark;
13735 12950700 : p->level--;
13736 12950700 : return _res;
13737 : }
13738 : static expr_ty
13739 27941700 : primary_raw(Parser *p)
13740 : {
13741 27941700 : if (p->level++ == MAXSTACK) {
13742 0 : p->error_indicator = 1;
13743 0 : PyErr_NoMemory();
13744 : }
13745 27941700 : if (p->error_indicator) {
13746 0 : p->level--;
13747 0 : return NULL;
13748 : }
13749 27941700 : expr_ty _res = NULL;
13750 27941700 : int _mark = p->mark;
13751 27941700 : 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 27941700 : int _start_lineno = p->tokens[_mark]->lineno;
13757 : UNUSED(_start_lineno); // Only used by EXTRA macro
13758 27941700 : int _start_col_offset = p->tokens[_mark]->col_offset;
13759 : UNUSED(_start_col_offset); // Only used by EXTRA macro
13760 : { // primary '.' NAME
13761 27941700 : if (p->error_indicator) {
13762 0 : p->level--;
13763 0 : return NULL;
13764 : }
13765 27941700 : 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 27941700 : if (
13770 27941700 : (a = primary_rule(p)) // primary
13771 14990200 : &&
13772 14990200 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
13773 1961640 : &&
13774 1961640 : (b = _PyPegen_name_token(p)) // NAME
13775 : )
13776 : {
13777 1961620 : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));
13778 1961620 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13779 1961620 : if (_token == NULL) {
13780 0 : p->level--;
13781 0 : return NULL;
13782 : }
13783 1961620 : int _end_lineno = _token->end_lineno;
13784 : UNUSED(_end_lineno); // Only used by EXTRA macro
13785 1961620 : int _end_col_offset = _token->end_col_offset;
13786 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13787 1961620 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA );
13788 1961620 : if (_res == NULL && PyErr_Occurred()) {
13789 0 : p->error_indicator = 1;
13790 0 : p->level--;
13791 0 : return NULL;
13792 : }
13793 1961620 : goto done;
13794 : }
13795 25980100 : p->mark = _mark;
13796 25980100 : 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 25980100 : if (p->error_indicator) {
13801 23 : p->level--;
13802 23 : return NULL;
13803 : }
13804 25980000 : 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 25980000 : if (
13808 25980000 : (a = primary_rule(p)) // primary
13809 13028500 : &&
13810 13028500 : (b = genexp_rule(p)) // genexp
13811 : )
13812 : {
13813 6824 : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary genexp"));
13814 6824 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13815 6824 : if (_token == NULL) {
13816 0 : p->level--;
13817 0 : return NULL;
13818 : }
13819 6824 : int _end_lineno = _token->end_lineno;
13820 : UNUSED(_end_lineno); // Only used by EXTRA macro
13821 6824 : int _end_col_offset = _token->end_col_offset;
13822 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13823 6824 : _res = _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
13824 6824 : if (_res == NULL && PyErr_Occurred()) {
13825 0 : p->error_indicator = 1;
13826 0 : p->level--;
13827 0 : return NULL;
13828 : }
13829 6824 : goto done;
13830 : }
13831 25973200 : p->mark = _mark;
13832 25973200 : 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 25973200 : if (p->error_indicator) {
13837 4 : p->level--;
13838 4 : return NULL;
13839 : }
13840 25973200 : 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 25973200 : if (
13846 25973200 : (a = primary_rule(p)) // primary
13847 13021700 : &&
13848 13021700 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
13849 1888060 : &&
13850 1888060 : (b = arguments_rule(p), !p->error_indicator) // arguments?
13851 1888040 : &&
13852 1888040 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
13853 : )
13854 : {
13855 1887960 : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'"));
13856 1887960 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13857 1887960 : if (_token == NULL) {
13858 0 : p->level--;
13859 0 : return NULL;
13860 : }
13861 1887960 : int _end_lineno = _token->end_lineno;
13862 : UNUSED(_end_lineno); // Only used by EXTRA macro
13863 1887960 : int _end_col_offset = _token->end_col_offset;
13864 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13865 1887960 : _res = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
13866 1887960 : if (_res == NULL && PyErr_Occurred()) {
13867 0 : p->error_indicator = 1;
13868 0 : p->level--;
13869 0 : return NULL;
13870 : }
13871 1887960 : goto done;
13872 : }
13873 24085300 : p->mark = _mark;
13874 24085300 : 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 24085300 : if (p->error_indicator) {
13879 14 : p->level--;
13880 14 : return NULL;
13881 : }
13882 24085200 : 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 24085200 : if (
13888 24085200 : (a = primary_rule(p)) // primary
13889 11133700 : &&
13890 11133700 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
13891 487808 : &&
13892 487808 : (b = slices_rule(p)) // slices
13893 487788 : &&
13894 487788 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
13895 : )
13896 : {
13897 487770 : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'"));
13898 487770 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13899 487770 : if (_token == NULL) {
13900 0 : p->level--;
13901 0 : return NULL;
13902 : }
13903 487770 : int _end_lineno = _token->end_lineno;
13904 : UNUSED(_end_lineno); // Only used by EXTRA macro
13905 487770 : int _end_col_offset = _token->end_col_offset;
13906 : UNUSED(_end_col_offset); // Only used by EXTRA macro
13907 487770 : _res = _PyAST_Subscript ( a , b , Load , EXTRA );
13908 487770 : if (_res == NULL && PyErr_Occurred()) {
13909 0 : p->error_indicator = 1;
13910 0 : p->level--;
13911 0 : return NULL;
13912 : }
13913 487770 : goto done;
13914 : }
13915 23597500 : p->mark = _mark;
13916 23597500 : 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 23597500 : if (p->error_indicator) {
13921 1 : p->level--;
13922 1 : return NULL;
13923 : }
13924 23597500 : D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom"));
13925 : expr_ty atom_var;
13926 23597500 : if (
13927 23597500 : (atom_var = atom_rule(p)) // atom
13928 : )
13929 : {
13930 21292000 : D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom"));
13931 21292000 : _res = atom_var;
13932 21292000 : goto done;
13933 : }
13934 2305510 : p->mark = _mark;
13935 2305510 : D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
13936 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom"));
13937 : }
13938 2305510 : _res = NULL;
13939 27941600 : done:
13940 27941600 : p->level--;
13941 27941600 : return _res;
13942 : }
13943 :
13944 : // slices: slice !',' | ','.(slice | starred_expression)+ ','?
13945 : static expr_ty
13946 1001270 : slices_rule(Parser *p)
13947 : {
13948 1001270 : if (p->level++ == MAXSTACK) {
13949 0 : p->error_indicator = 1;
13950 0 : PyErr_NoMemory();
13951 : }
13952 1001270 : if (p->error_indicator) {
13953 0 : p->level--;
13954 0 : return NULL;
13955 : }
13956 1001270 : expr_ty _res = NULL;
13957 1001270 : int _mark = p->mark;
13958 1001270 : 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 1001270 : int _start_lineno = p->tokens[_mark]->lineno;
13964 : UNUSED(_start_lineno); // Only used by EXTRA macro
13965 1001270 : int _start_col_offset = p->tokens[_mark]->col_offset;
13966 : UNUSED(_start_col_offset); // Only used by EXTRA macro
13967 : { // slice !','
13968 1001270 : if (p->error_indicator) {
13969 0 : p->level--;
13970 0 : return NULL;
13971 : }
13972 1001270 : D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','"));
13973 : expr_ty a;
13974 1001270 : if (
13975 1001270 : (a = slice_rule(p)) // slice
13976 1000340 : &&
13977 1000340 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
13978 : )
13979 : {
13980 979490 : D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice !','"));
13981 979490 : _res = a;
13982 979490 : if (_res == NULL && PyErr_Occurred()) {
13983 0 : p->error_indicator = 1;
13984 0 : p->level--;
13985 0 : return NULL;
13986 : }
13987 979490 : goto done;
13988 : }
13989 21777 : p->mark = _mark;
13990 21777 : 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 21764 : 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 21667 : 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 97 : 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 1001250 : done:
14032 1001250 : p->level--;
14033 1001250 : return _res;
14034 : }
14035 :
14036 : // slice: expression? ':' expression? [':' expression?] | named_expression
14037 : static expr_ty
14038 1049280 : slice_rule(Parser *p)
14039 : {
14040 1049280 : if (p->level++ == MAXSTACK) {
14041 0 : p->error_indicator = 1;
14042 0 : PyErr_NoMemory();
14043 : }
14044 1049280 : if (p->error_indicator) {
14045 0 : p->level--;
14046 0 : return NULL;
14047 : }
14048 1049280 : expr_ty _res = NULL;
14049 1049280 : int _mark = p->mark;
14050 1049280 : 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 1049280 : int _start_lineno = p->tokens[_mark]->lineno;
14056 : UNUSED(_start_lineno); // Only used by EXTRA macro
14057 1049280 : int _start_col_offset = p->tokens[_mark]->col_offset;
14058 : UNUSED(_start_col_offset); // Only used by EXTRA macro
14059 : { // expression? ':' expression? [':' expression?]
14060 1049280 : if (p->error_indicator) {
14061 0 : p->level--;
14062 0 : return NULL;
14063 : }
14064 1049280 : 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 1049280 : if (
14070 1049280 : (a = expression_rule(p), !p->error_indicator) // expression?
14071 1049280 : &&
14072 1049280 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
14073 69162 : &&
14074 69162 : (b = expression_rule(p), !p->error_indicator) // expression?
14075 69157 : &&
14076 69157 : (c = _tmp_90_rule(p), !p->error_indicator) // [':' expression?]
14077 : )
14078 : {
14079 69153 : D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]"));
14080 69153 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14081 69153 : if (_token == NULL) {
14082 0 : p->level--;
14083 0 : return NULL;
14084 : }
14085 69153 : int _end_lineno = _token->end_lineno;
14086 : UNUSED(_end_lineno); // Only used by EXTRA macro
14087 69153 : int _end_col_offset = _token->end_col_offset;
14088 : UNUSED(_end_col_offset); // Only used by EXTRA macro
14089 69153 : _res = _PyAST_Slice ( a , b , c , EXTRA );
14090 69153 : if (_res == NULL && PyErr_Occurred()) {
14091 0 : p->error_indicator = 1;
14092 0 : p->level--;
14093 0 : return NULL;
14094 : }
14095 69153 : goto done;
14096 : }
14097 980126 : p->mark = _mark;
14098 980126 : 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 980126 : if (p->error_indicator) {
14103 13 : p->level--;
14104 13 : return NULL;
14105 : }
14106 980113 : D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
14107 : expr_ty a;
14108 980113 : if (
14109 980113 : (a = named_expression_rule(p)) // named_expression
14110 : )
14111 : {
14112 977132 : D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
14113 977132 : _res = a;
14114 977132 : if (_res == NULL && PyErr_Occurred()) {
14115 0 : p->error_indicator = 1;
14116 0 : p->level--;
14117 0 : return NULL;
14118 : }
14119 977132 : goto done;
14120 : }
14121 2981 : p->mark = _mark;
14122 2981 : 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 1049270 : done:
14127 1049270 : p->level--;
14128 1049270 : 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 29092800 : atom_rule(Parser *p)
14144 : {
14145 29092800 : if (p->level++ == MAXSTACK) {
14146 0 : p->error_indicator = 1;
14147 0 : PyErr_NoMemory();
14148 : }
14149 29092800 : if (p->error_indicator) {
14150 0 : p->level--;
14151 0 : return NULL;
14152 : }
14153 29092800 : expr_ty _res = NULL;
14154 29092800 : int _mark = p->mark;
14155 29092800 : 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 29092800 : int _start_lineno = p->tokens[_mark]->lineno;
14161 : UNUSED(_start_lineno); // Only used by EXTRA macro
14162 29092800 : int _start_col_offset = p->tokens[_mark]->col_offset;
14163 : UNUSED(_start_col_offset); // Only used by EXTRA macro
14164 : { // NAME
14165 29092800 : if (p->error_indicator) {
14166 0 : p->level--;
14167 0 : return NULL;
14168 : }
14169 29092800 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
14170 : expr_ty name_var;
14171 29092800 : if (
14172 29092800 : (name_var = _PyPegen_name_token(p)) // NAME
14173 : )
14174 : {
14175 14072600 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
14176 14072600 : _res = name_var;
14177 14072600 : goto done;
14178 : }
14179 15020300 : p->mark = _mark;
14180 15020300 : 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 15020300 : if (p->error_indicator) {
14185 0 : p->level--;
14186 0 : return NULL;
14187 : }
14188 15020300 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
14189 : Token * _keyword;
14190 15020300 : if (
14191 15020300 : (_keyword = _PyPegen_expect_token(p, 600)) // token='True'
14192 : )
14193 : {
14194 120986 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
14195 120986 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14196 120986 : if (_token == NULL) {
14197 0 : p->level--;
14198 0 : return NULL;
14199 : }
14200 120986 : int _end_lineno = _token->end_lineno;
14201 : UNUSED(_end_lineno); // Only used by EXTRA macro
14202 120986 : int _end_col_offset = _token->end_col_offset;
14203 : UNUSED(_end_col_offset); // Only used by EXTRA macro
14204 120986 : _res = _PyAST_Constant ( Py_True , NULL , EXTRA );
14205 120986 : if (_res == NULL && PyErr_Occurred()) {
14206 0 : p->error_indicator = 1;
14207 0 : p->level--;
14208 0 : return NULL;
14209 : }
14210 120986 : goto done;
14211 : }
14212 14899300 : p->mark = _mark;
14213 14899300 : 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 14899300 : if (p->error_indicator) {
14218 0 : p->level--;
14219 0 : return NULL;
14220 : }
14221 14899300 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
14222 : Token * _keyword;
14223 14899300 : if (
14224 14899300 : (_keyword = _PyPegen_expect_token(p, 602)) // token='False'
14225 : )
14226 : {
14227 115644 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
14228 115644 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14229 115644 : if (_token == NULL) {
14230 0 : p->level--;
14231 0 : return NULL;
14232 : }
14233 115644 : int _end_lineno = _token->end_lineno;
14234 : UNUSED(_end_lineno); // Only used by EXTRA macro
14235 115644 : int _end_col_offset = _token->end_col_offset;
14236 : UNUSED(_end_col_offset); // Only used by EXTRA macro
14237 115644 : _res = _PyAST_Constant ( Py_False , NULL , EXTRA );
14238 115644 : if (_res == NULL && PyErr_Occurred()) {
14239 0 : p->error_indicator = 1;
14240 0 : p->level--;
14241 0 : return NULL;
14242 : }
14243 115644 : goto done;
14244 : }
14245 14783600 : p->mark = _mark;
14246 14783600 : 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 14783600 : if (p->error_indicator) {
14251 0 : p->level--;
14252 0 : return NULL;
14253 : }
14254 14783600 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
14255 : Token * _keyword;
14256 14783600 : if (
14257 14783600 : (_keyword = _PyPegen_expect_token(p, 601)) // token='None'
14258 : )
14259 : {
14260 377668 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
14261 377668 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14262 377668 : if (_token == NULL) {
14263 0 : p->level--;
14264 0 : return NULL;
14265 : }
14266 377668 : int _end_lineno = _token->end_lineno;
14267 : UNUSED(_end_lineno); // Only used by EXTRA macro
14268 377668 : int _end_col_offset = _token->end_col_offset;
14269 : UNUSED(_end_col_offset); // Only used by EXTRA macro
14270 377668 : _res = _PyAST_Constant ( Py_None , NULL , EXTRA );
14271 377668 : if (_res == NULL && PyErr_Occurred()) {
14272 0 : p->error_indicator = 1;
14273 0 : p->level--;
14274 0 : return NULL;
14275 : }
14276 377668 : goto done;
14277 : }
14278 14406000 : p->mark = _mark;
14279 14406000 : 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 14406000 : if (p->error_indicator) {
14284 0 : p->level--;
14285 0 : return NULL;
14286 : }
14287 14406000 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&STRING strings"));
14288 : expr_ty strings_var;
14289 14406000 : if (
14290 14406000 : _PyPegen_lookahead(1, _PyPegen_string_token, p)
14291 3423980 : &&
14292 3423980 : (strings_var = strings_rule(p)) // strings
14293 : )
14294 : {
14295 3423210 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&STRING strings"));
14296 3423210 : _res = strings_var;
14297 3423210 : goto done;
14298 : }
14299 10982800 : p->mark = _mark;
14300 10982800 : 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 10982800 : if (p->error_indicator) {
14305 769 : p->level--;
14306 769 : return NULL;
14307 : }
14308 10982000 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
14309 : expr_ty number_var;
14310 10982000 : if (
14311 10982000 : (number_var = _PyPegen_number_token(p)) // NUMBER
14312 : )
14313 : {
14314 5872680 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
14315 5872680 : _res = number_var;
14316 5872680 : goto done;
14317 : }
14318 5109310 : p->mark = _mark;
14319 5109310 : 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 5109310 : if (p->error_indicator) {
14324 2 : p->level--;
14325 2 : return NULL;
14326 : }
14327 5109310 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)"));
14328 : void *_tmp_91_var;
14329 5109310 : if (
14330 5109310 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='('
14331 866593 : &&
14332 866593 : (_tmp_91_var = _tmp_91_rule(p)) // tuple | group | genexp
14333 : )
14334 : {
14335 866413 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)"));
14336 866413 : _res = _tmp_91_var;
14337 866413 : goto done;
14338 : }
14339 4242900 : p->mark = _mark;
14340 4242900 : 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 4242900 : if (p->error_indicator) {
14345 67 : p->level--;
14346 67 : return NULL;
14347 : }
14348 4242830 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)"));
14349 : void *_tmp_92_var;
14350 4242830 : if (
14351 4242830 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='['
14352 262274 : &&
14353 262274 : (_tmp_92_var = _tmp_92_rule(p)) // list | listcomp
14354 : )
14355 : {
14356 262151 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)"));
14357 262151 : _res = _tmp_92_var;
14358 262151 : goto done;
14359 : }
14360 3980680 : p->mark = _mark;
14361 3980680 : 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 3980680 : if (p->error_indicator) {
14366 53 : p->level--;
14367 53 : return NULL;
14368 : }
14369 3980620 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
14370 : void *_tmp_93_var;
14371 3980620 : if (
14372 3980620 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{'
14373 112966 : &&
14374 112966 : (_tmp_93_var = _tmp_93_rule(p)) // dict | set | dictcomp | setcomp
14375 : )
14376 : {
14377 112870 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
14378 112870 : _res = _tmp_93_var;
14379 112870 : goto done;
14380 : }
14381 3867760 : p->mark = _mark;
14382 3867760 : 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 3867760 : if (p->error_indicator) {
14387 39 : p->level--;
14388 39 : return NULL;
14389 : }
14390 3867720 : D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
14391 : Token * _literal;
14392 3867720 : if (
14393 3867720 : (_literal = _PyPegen_expect_token(p, 52)) // token='...'
14394 : )
14395 : {
14396 11959 : D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
14397 11959 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14398 11959 : if (_token == NULL) {
14399 0 : p->level--;
14400 0 : return NULL;
14401 : }
14402 11959 : int _end_lineno = _token->end_lineno;
14403 : UNUSED(_end_lineno); // Only used by EXTRA macro
14404 11959 : int _end_col_offset = _token->end_col_offset;
14405 : UNUSED(_end_col_offset); // Only used by EXTRA macro
14406 11959 : _res = _PyAST_Constant ( Py_Ellipsis , NULL , EXTRA );
14407 11959 : if (_res == NULL && PyErr_Occurred()) {
14408 0 : p->error_indicator = 1;
14409 0 : p->level--;
14410 0 : return NULL;
14411 : }
14412 11959 : goto done;
14413 : }
14414 3855760 : p->mark = _mark;
14415 3855760 : D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14416 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
14417 : }
14418 3855760 : _res = NULL;
14419 29091900 : done:
14420 29091900 : p->level--;
14421 29091900 : return _res;
14422 : }
14423 :
14424 : // group: '(' (yield_expr | named_expression) ')' | invalid_group
14425 : static expr_ty
14426 293962 : group_rule(Parser *p)
14427 : {
14428 293962 : if (p->level++ == MAXSTACK) {
14429 0 : p->error_indicator = 1;
14430 0 : PyErr_NoMemory();
14431 : }
14432 293962 : if (p->error_indicator) {
14433 0 : p->level--;
14434 0 : return NULL;
14435 : }
14436 293962 : expr_ty _res = NULL;
14437 293962 : int _mark = p->mark;
14438 : { // '(' (yield_expr | named_expression) ')'
14439 293962 : if (p->error_indicator) {
14440 0 : p->level--;
14441 0 : return NULL;
14442 : }
14443 293962 : 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 293962 : if (
14448 293962 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
14449 293962 : &&
14450 293962 : (a = _tmp_94_rule(p)) // yield_expr | named_expression
14451 293902 : &&
14452 293902 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
14453 : )
14454 : {
14455 288434 : D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
14456 288434 : _res = a;
14457 288434 : if (_res == NULL && PyErr_Occurred()) {
14458 0 : p->error_indicator = 1;
14459 0 : p->level--;
14460 0 : return NULL;
14461 : }
14462 288434 : goto done;
14463 : }
14464 5528 : p->mark = _mark;
14465 5528 : 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 5528 : if (p->call_invalid_rules) { // invalid_group
14469 50 : if (p->error_indicator) {
14470 0 : p->level--;
14471 0 : return NULL;
14472 : }
14473 50 : 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 0 : 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 50 : 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 5528 : _res = NULL;
14488 293962 : done:
14489 293962 : p->level--;
14490 293962 : return _res;
14491 : }
14492 :
14493 : // lambdef: 'lambda' lambda_params? ':' expression
14494 : static expr_ty
14495 2305080 : lambdef_rule(Parser *p)
14496 : {
14497 2305080 : if (p->level++ == MAXSTACK) {
14498 0 : p->error_indicator = 1;
14499 0 : PyErr_NoMemory();
14500 : }
14501 2305080 : if (p->error_indicator) {
14502 0 : p->level--;
14503 0 : return NULL;
14504 : }
14505 2305080 : expr_ty _res = NULL;
14506 2305080 : int _mark = p->mark;
14507 2305080 : 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 2305080 : int _start_lineno = p->tokens[_mark]->lineno;
14513 : UNUSED(_start_lineno); // Only used by EXTRA macro
14514 2305080 : 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 2305080 : if (p->error_indicator) {
14518 0 : p->level--;
14519 0 : return NULL;
14520 : }
14521 2305080 : 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 2305080 : if (
14527 2305080 : (_keyword = _PyPegen_expect_token(p, 586)) // token='lambda'
14528 37587 : &&
14529 37587 : (a = lambda_params_rule(p), !p->error_indicator) // lambda_params?
14530 37547 : &&
14531 37547 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
14532 37497 : &&
14533 37497 : (b = expression_rule(p)) // expression
14534 : )
14535 : {
14536 37490 : D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression"));
14537 37490 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14538 37490 : if (_token == NULL) {
14539 0 : p->level--;
14540 0 : return NULL;
14541 : }
14542 37490 : int _end_lineno = _token->end_lineno;
14543 : UNUSED(_end_lineno); // Only used by EXTRA macro
14544 37490 : int _end_col_offset = _token->end_col_offset;
14545 : UNUSED(_end_col_offset); // Only used by EXTRA macro
14546 37490 : _res = _PyAST_Lambda ( ( a ) ? a : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , EXTRA );
14547 37490 : if (_res == NULL && PyErr_Occurred()) {
14548 0 : p->error_indicator = 1;
14549 0 : p->level--;
14550 0 : return NULL;
14551 : }
14552 37490 : goto done;
14553 : }
14554 2267590 : p->mark = _mark;
14555 2267590 : 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 2267590 : _res = NULL;
14559 2305080 : done:
14560 2305080 : p->level--;
14561 2305080 : return _res;
14562 : }
14563 :
14564 : // lambda_params: invalid_lambda_parameters | lambda_parameters
14565 : static arguments_ty
14566 37587 : lambda_params_rule(Parser *p)
14567 : {
14568 37587 : if (p->level++ == MAXSTACK) {
14569 0 : p->error_indicator = 1;
14570 0 : PyErr_NoMemory();
14571 : }
14572 37587 : if (p->error_indicator) {
14573 0 : p->level--;
14574 0 : return NULL;
14575 : }
14576 37587 : arguments_ty _res = NULL;
14577 37587 : int _mark = p->mark;
14578 37587 : if (p->call_invalid_rules) { // invalid_lambda_parameters
14579 52 : if (p->error_indicator) {
14580 0 : p->level--;
14581 0 : return NULL;
14582 : }
14583 52 : 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 0 : 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 52 : 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 37587 : if (p->error_indicator) {
14599 27 : p->level--;
14600 27 : return NULL;
14601 : }
14602 37560 : D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_parameters"));
14603 : arguments_ty lambda_parameters_var;
14604 37560 : if (
14605 37560 : (lambda_parameters_var = lambda_parameters_rule(p)) // lambda_parameters
14606 : )
14607 : {
14608 34819 : D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_parameters"));
14609 34819 : _res = lambda_parameters_var;
14610 34819 : goto done;
14611 : }
14612 2741 : p->mark = _mark;
14613 2741 : 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 2741 : _res = NULL;
14617 37560 : done:
14618 37560 : p->level--;
14619 37560 : 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 37560 : lambda_parameters_rule(Parser *p)
14630 : {
14631 37560 : if (p->level++ == MAXSTACK) {
14632 0 : p->error_indicator = 1;
14633 0 : PyErr_NoMemory();
14634 : }
14635 37560 : if (p->error_indicator) {
14636 0 : p->level--;
14637 0 : return NULL;
14638 : }
14639 37560 : arguments_ty _res = NULL;
14640 37560 : int _mark = p->mark;
14641 : { // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
14642 37560 : if (p->error_indicator) {
14643 0 : p->level--;
14644 0 : return NULL;
14645 : }
14646 37560 : 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 37560 : if (
14652 37560 : (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 77 : 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 37483 : p->mark = _mark;
14671 37483 : 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 37483 : if (p->error_indicator) {
14676 2 : p->level--;
14677 2 : return NULL;
14678 : }
14679 37481 : 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 37481 : if (
14684 37481 : (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 57 : 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 37424 : p->mark = _mark;
14701 37424 : 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 37424 : if (p->error_indicator) {
14706 1 : p->level--;
14707 1 : return NULL;
14708 : }
14709 37423 : 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 37423 : if (
14714 37423 : (a = (asdl_arg_seq*)_loop1_98_rule(p)) // lambda_param_no_default+
14715 34292 : &&
14716 34292 : (b = _loop0_99_rule(p)) // lambda_param_with_default*
14717 34292 : &&
14718 34292 : (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc?
14719 : )
14720 : {
14721 34285 : 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 34285 : _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
14723 34285 : if (_res == NULL && PyErr_Occurred()) {
14724 0 : p->error_indicator = 1;
14725 0 : p->level--;
14726 0 : return NULL;
14727 : }
14728 34285 : goto done;
14729 : }
14730 3138 : p->mark = _mark;
14731 3138 : 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 3138 : if (p->error_indicator) {
14736 7 : p->level--;
14737 7 : return NULL;
14738 : }
14739 3131 : 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 3131 : if (
14743 3131 : (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 144 : 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 2987 : p->mark = _mark;
14758 2987 : 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 2987 : if (p->error_indicator) {
14763 0 : p->level--;
14764 0 : return NULL;
14765 : }
14766 2987 : D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_star_etc"));
14767 : StarEtc* a;
14768 2987 : if (
14769 2987 : (a = lambda_star_etc_rule(p)) // lambda_star_etc
14770 : )
14771 : {
14772 256 : D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_star_etc"));
14773 256 : _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
14774 256 : if (_res == NULL && PyErr_Occurred()) {
14775 0 : p->error_indicator = 1;
14776 0 : p->level--;
14777 0 : return NULL;
14778 : }
14779 256 : goto done;
14780 : }
14781 2731 : p->mark = _mark;
14782 2731 : 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 2731 : _res = NULL;
14786 37550 : done:
14787 37550 : p->level--;
14788 37550 : 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 37633 : lambda_slash_no_default_rule(Parser *p)
14796 : {
14797 37633 : if (p->level++ == MAXSTACK) {
14798 0 : p->error_indicator = 1;
14799 0 : PyErr_NoMemory();
14800 : }
14801 37633 : if (p->error_indicator) {
14802 0 : p->level--;
14803 0 : return NULL;
14804 : }
14805 37633 : asdl_arg_seq* _res = NULL;
14806 37633 : int _mark = p->mark;
14807 : { // lambda_param_no_default+ '/' ','
14808 37633 : if (p->error_indicator) {
14809 0 : p->level--;
14810 0 : return NULL;
14811 : }
14812 37633 : 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 37633 : if (
14817 37633 : (a = (asdl_arg_seq*)_loop1_101_rule(p)) // lambda_param_no_default+
14818 34410 : &&
14819 34410 : (_literal = _PyPegen_expect_token(p, 17)) // token='/'
14820 89 : &&
14821 89 : (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
14822 : )
14823 : {
14824 76 : 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 37557 : p->mark = _mark;
14834 37557 : 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 37557 : if (p->error_indicator) {
14839 0 : p->level--;
14840 0 : return NULL;
14841 : }
14842 37557 : 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 37557 : if (
14846 37557 : (a = (asdl_arg_seq*)_loop1_102_rule(p)) // lambda_param_no_default+
14847 34334 : &&
14848 34334 : (_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 13 : 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 37544 : p->mark = _mark;
14863 37544 : 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 37544 : _res = NULL;
14867 37633 : done:
14868 37633 : p->level--;
14869 37633 : 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 37596 : lambda_slash_with_default_rule(Parser *p)
14877 : {
14878 37596 : if (p->level++ == MAXSTACK) {
14879 0 : p->error_indicator = 1;
14880 0 : PyErr_NoMemory();
14881 : }
14882 37596 : if (p->error_indicator) {
14883 0 : p->level--;
14884 0 : return NULL;
14885 : }
14886 37596 : SlashWithDefault* _res = NULL;
14887 37596 : int _mark = p->mark;
14888 : { // lambda_param_no_default* lambda_param_with_default+ '/' ','
14889 37596 : if (p->error_indicator) {
14890 0 : p->level--;
14891 0 : return NULL;
14892 : }
14893 37596 : 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 37596 : if (
14899 37596 : (a = _loop0_103_rule(p)) // lambda_param_no_default*
14900 37596 : &&
14901 37596 : (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 55 : 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 37541 : p->mark = _mark;
14918 37541 : 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 37541 : if (p->error_indicator) {
14923 2 : p->level--;
14924 2 : return NULL;
14925 : }
14926 37539 : 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 37539 : if (
14931 37539 : (a = _loop0_105_rule(p)) // lambda_param_no_default*
14932 37539 : &&
14933 37539 : (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 9 : 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 37530 : p->mark = _mark;
14950 37530 : 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 37530 : _res = NULL;
14954 37594 : done:
14955 37594 : p->level--;
14956 37594 : 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 37560 : lambda_star_etc_rule(Parser *p)
14966 : {
14967 37560 : if (p->level++ == MAXSTACK) {
14968 0 : p->error_indicator = 1;
14969 0 : PyErr_NoMemory();
14970 : }
14971 37560 : if (p->error_indicator) {
14972 0 : p->level--;
14973 0 : return NULL;
14974 : }
14975 37560 : StarEtc* _res = NULL;
14976 37560 : int _mark = p->mark;
14977 37560 : 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 25 : 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 0 : 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 25 : 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 37560 : if (p->error_indicator) {
14998 6 : p->level--;
14999 6 : return NULL;
15000 : }
15001 37554 : 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 37554 : if (
15007 37554 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
15008 407 : &&
15009 407 : (a = lambda_param_no_default_rule(p)) // lambda_param_no_default
15010 302 : &&
15011 302 : (b = _loop0_107_rule(p)) // lambda_param_maybe_default*
15012 302 : &&
15013 302 : (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds?
15014 : )
15015 : {
15016 298 : 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 298 : _res = _PyPegen_star_etc ( p , a , b , c );
15018 298 : if (_res == NULL && PyErr_Occurred()) {
15019 0 : p->error_indicator = 1;
15020 0 : p->level--;
15021 0 : return NULL;
15022 : }
15023 298 : goto done;
15024 : }
15025 37256 : p->mark = _mark;
15026 37256 : 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 37256 : if (p->error_indicator) {
15031 4 : p->level--;
15032 4 : return NULL;
15033 : }
15034 37252 : 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 37252 : if (
15040 37252 : (_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 102 : 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 37150 : p->mark = _mark;
15059 37150 : 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 37150 : if (p->error_indicator) {
15064 0 : p->level--;
15065 0 : return NULL;
15066 : }
15067 37150 : D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_kwds"));
15068 : arg_ty a;
15069 37150 : if (
15070 37150 : (a = lambda_kwds_rule(p)) // lambda_kwds
15071 : )
15072 : {
15073 19 : 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 37131 : p->mark = _mark;
15083 37131 : 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 37131 : _res = NULL;
15087 37550 : done:
15088 37550 : p->level--;
15089 37550 : return _res;
15090 : }
15091 :
15092 : // lambda_kwds: invalid_lambda_kwds | '**' lambda_param_no_default
15093 : static arg_ty
15094 37554 : lambda_kwds_rule(Parser *p)
15095 : {
15096 37554 : if (p->level++ == MAXSTACK) {
15097 0 : p->error_indicator = 1;
15098 0 : PyErr_NoMemory();
15099 : }
15100 37554 : if (p->error_indicator) {
15101 0 : p->level--;
15102 0 : return NULL;
15103 : }
15104 37554 : arg_ty _res = NULL;
15105 37554 : int _mark = p->mark;
15106 37554 : if (p->call_invalid_rules) { // invalid_lambda_kwds
15107 19 : if (p->error_indicator) {
15108 0 : p->level--;
15109 0 : return NULL;
15110 : }
15111 19 : 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 0 : 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 19 : 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 37554 : if (p->error_indicator) {
15127 7 : p->level--;
15128 7 : return NULL;
15129 : }
15130 37547 : 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 37547 : if (
15134 37547 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
15135 133 : &&
15136 133 : (a = lambda_param_no_default_rule(p)) // lambda_param_no_default
15137 : )
15138 : {
15139 132 : D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default"));
15140 132 : _res = a;
15141 132 : if (_res == NULL && PyErr_Occurred()) {
15142 0 : p->error_indicator = 1;
15143 0 : p->level--;
15144 0 : return NULL;
15145 : }
15146 132 : goto done;
15147 : }
15148 37415 : p->mark = _mark;
15149 37415 : 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 37415 : _res = NULL;
15153 37547 : done:
15154 37547 : p->level--;
15155 37547 : return _res;
15156 : }
15157 :
15158 : // lambda_param_no_default: lambda_param ',' | lambda_param &':'
15159 : static arg_ty
15160 1034510 : lambda_param_no_default_rule(Parser *p)
15161 : {
15162 1034510 : if (p->level++ == MAXSTACK) {
15163 0 : p->error_indicator = 1;
15164 0 : PyErr_NoMemory();
15165 : }
15166 1034510 : if (p->error_indicator) {
15167 0 : p->level--;
15168 0 : return NULL;
15169 : }
15170 1034510 : arg_ty _res = NULL;
15171 1034510 : int _mark = p->mark;
15172 : { // lambda_param ','
15173 1034510 : if (p->error_indicator) {
15174 0 : p->level--;
15175 0 : return NULL;
15176 : }
15177 1034510 : 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 1034510 : if (
15181 1034510 : (a = lambda_param_rule(p)) // lambda_param
15182 847972 : &&
15183 847972 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
15184 : )
15185 : {
15186 675609 : D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param ','"));
15187 675609 : _res = a;
15188 675609 : if (_res == NULL && PyErr_Occurred()) {
15189 0 : p->error_indicator = 1;
15190 0 : p->level--;
15191 0 : return NULL;
15192 : }
15193 675609 : goto done;
15194 : }
15195 358897 : p->mark = _mark;
15196 358897 : 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 358897 : if (p->error_indicator) {
15201 0 : p->level--;
15202 0 : return NULL;
15203 : }
15204 358897 : D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param &':'"));
15205 : arg_ty a;
15206 358897 : if (
15207 358897 : (a = lambda_param_rule(p)) // lambda_param
15208 172363 : &&
15209 172363 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':'
15210 : )
15211 : {
15212 170859 : D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param &':'"));
15213 170859 : _res = a;
15214 170859 : if (_res == NULL && PyErr_Occurred()) {
15215 0 : p->error_indicator = 1;
15216 0 : p->level--;
15217 0 : return NULL;
15218 : }
15219 170859 : goto done;
15220 : }
15221 188038 : p->mark = _mark;
15222 188038 : 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 188038 : _res = NULL;
15226 1034510 : done:
15227 1034510 : p->level--;
15228 1034510 : return _res;
15229 : }
15230 :
15231 : // lambda_param_with_default: lambda_param default ',' | lambda_param default &':'
15232 : static NameDefaultPair*
15233 113713 : lambda_param_with_default_rule(Parser *p)
15234 : {
15235 113713 : if (p->level++ == MAXSTACK) {
15236 0 : p->error_indicator = 1;
15237 0 : PyErr_NoMemory();
15238 : }
15239 113713 : if (p->error_indicator) {
15240 0 : p->level--;
15241 0 : return NULL;
15242 : }
15243 113713 : NameDefaultPair* _res = NULL;
15244 113713 : int _mark = p->mark;
15245 : { // lambda_param default ','
15246 113713 : if (p->error_indicator) {
15247 0 : p->level--;
15248 0 : return NULL;
15249 : }
15250 113713 : 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 113713 : if (
15255 113713 : (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 353 : 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 113360 : p->mark = _mark;
15272 113360 : 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 113360 : if (p->error_indicator) {
15277 2 : p->level--;
15278 2 : return NULL;
15279 : }
15280 113358 : 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 113358 : if (
15284 113358 : (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 618 : 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 112740 : p->mark = _mark;
15301 112740 : 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 112740 : _res = NULL;
15305 113711 : done:
15306 113711 : p->level--;
15307 113711 : return _res;
15308 : }
15309 :
15310 : // lambda_param_maybe_default: lambda_param default? ',' | lambda_param default? &':'
15311 : static NameDefaultPair*
15312 775 : lambda_param_maybe_default_rule(Parser *p)
15313 : {
15314 775 : if (p->level++ == MAXSTACK) {
15315 0 : p->error_indicator = 1;
15316 0 : PyErr_NoMemory();
15317 : }
15318 775 : if (p->error_indicator) {
15319 0 : p->level--;
15320 0 : return NULL;
15321 : }
15322 775 : NameDefaultPair* _res = NULL;
15323 775 : int _mark = p->mark;
15324 : { // lambda_param default? ','
15325 775 : if (p->error_indicator) {
15326 0 : p->level--;
15327 0 : return NULL;
15328 : }
15329 775 : 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 775 : if (
15334 775 : (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 186 : 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 589 : p->mark = _mark;
15351 589 : 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 589 : if (p->error_indicator) {
15356 0 : p->level--;
15357 0 : return NULL;
15358 : }
15359 589 : 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 589 : if (
15363 589 : (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 92 : 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 497 : p->mark = _mark;
15380 497 : 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 497 : _res = NULL;
15384 775 : done:
15385 775 : p->level--;
15386 775 : return _res;
15387 : }
15388 :
15389 : // lambda_param: NAME
15390 : static arg_ty
15391 1621880 : lambda_param_rule(Parser *p)
15392 : {
15393 1621880 : if (p->level++ == MAXSTACK) {
15394 0 : p->error_indicator = 1;
15395 0 : PyErr_NoMemory();
15396 : }
15397 1621880 : if (p->error_indicator) {
15398 0 : p->level--;
15399 0 : return NULL;
15400 : }
15401 1621880 : arg_ty _res = NULL;
15402 1621880 : int _mark = p->mark;
15403 1621880 : 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 1621880 : int _start_lineno = p->tokens[_mark]->lineno;
15409 : UNUSED(_start_lineno); // Only used by EXTRA macro
15410 1621880 : int _start_col_offset = p->tokens[_mark]->col_offset;
15411 : UNUSED(_start_col_offset); // Only used by EXTRA macro
15412 : { // NAME
15413 1621880 : if (p->error_indicator) {
15414 0 : p->level--;
15415 0 : return NULL;
15416 : }
15417 1621880 : D(fprintf(stderr, "%*c> lambda_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
15418 : expr_ty a;
15419 1621880 : if (
15420 1621880 : (a = _PyPegen_name_token(p)) // NAME
15421 : )
15422 : {
15423 1022400 : D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
15424 1022400 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15425 1022400 : if (_token == NULL) {
15426 0 : p->level--;
15427 0 : return NULL;
15428 : }
15429 1022400 : int _end_lineno = _token->end_lineno;
15430 : UNUSED(_end_lineno); // Only used by EXTRA macro
15431 1022400 : int _end_col_offset = _token->end_col_offset;
15432 : UNUSED(_end_col_offset); // Only used by EXTRA macro
15433 1022400 : _res = _PyAST_arg ( a -> v . Name . id , NULL , NULL , EXTRA );
15434 1022400 : if (_res == NULL && PyErr_Occurred()) {
15435 0 : p->error_indicator = 1;
15436 0 : p->level--;
15437 0 : return NULL;
15438 : }
15439 1022400 : goto done;
15440 : }
15441 599479 : p->mark = _mark;
15442 599479 : 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 599479 : _res = NULL;
15446 1621880 : done:
15447 1621880 : p->level--;
15448 1621880 : return _res;
15449 : }
15450 :
15451 : // strings: STRING+
15452 : static expr_ty
15453 3427630 : strings_rule(Parser *p)
15454 : {
15455 3427630 : if (p->level++ == MAXSTACK) {
15456 0 : p->error_indicator = 1;
15457 0 : PyErr_NoMemory();
15458 : }
15459 3427630 : if (p->error_indicator) {
15460 0 : p->level--;
15461 0 : return NULL;
15462 : }
15463 3427630 : expr_ty _res = NULL;
15464 3427630 : if (_PyPegen_is_memoized(p, strings_type, &_res)) {
15465 1816620 : p->level--;
15466 1816620 : return _res;
15467 : }
15468 1611000 : int _mark = p->mark;
15469 : { // STRING+
15470 1611000 : if (p->error_indicator) {
15471 0 : p->level--;
15472 0 : return NULL;
15473 : }
15474 1611000 : D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING+"));
15475 : asdl_seq * a;
15476 1611000 : if (
15477 1611000 : (a = _loop1_109_rule(p)) // STRING+
15478 : )
15479 : {
15480 1607680 : D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING+"));
15481 1607680 : _res = _PyPegen_concatenate_strings ( p , a );
15482 1607680 : if (_res == NULL && PyErr_Occurred()) {
15483 767 : p->error_indicator = 1;
15484 767 : p->level--;
15485 767 : return NULL;
15486 : }
15487 1606910 : goto done;
15488 : }
15489 3328 : p->mark = _mark;
15490 3328 : D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ',
15491 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING+"));
15492 : }
15493 3328 : _res = NULL;
15494 1610240 : done:
15495 1610240 : _PyPegen_insert_memo(p, _mark, strings_type, _res);
15496 1610240 : p->level--;
15497 1610240 : return _res;
15498 : }
15499 :
15500 : // list: '[' star_named_expressions? ']'
15501 : static expr_ty
15502 264426 : list_rule(Parser *p)
15503 : {
15504 264426 : if (p->level++ == MAXSTACK) {
15505 0 : p->error_indicator = 1;
15506 0 : PyErr_NoMemory();
15507 : }
15508 264426 : if (p->error_indicator) {
15509 0 : p->level--;
15510 0 : return NULL;
15511 : }
15512 264426 : expr_ty _res = NULL;
15513 264426 : int _mark = p->mark;
15514 264426 : 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 264426 : int _start_lineno = p->tokens[_mark]->lineno;
15520 : UNUSED(_start_lineno); // Only used by EXTRA macro
15521 264426 : int _start_col_offset = p->tokens[_mark]->col_offset;
15522 : UNUSED(_start_col_offset); // Only used by EXTRA macro
15523 : { // '[' star_named_expressions? ']'
15524 264426 : if (p->error_indicator) {
15525 0 : p->level--;
15526 0 : return NULL;
15527 : }
15528 264426 : 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 264426 : if (
15533 264426 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
15534 262299 : &&
15535 262299 : (a = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions?
15536 262265 : &&
15537 262265 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
15538 : )
15539 : {
15540 232831 : D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'"));
15541 232831 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15542 232831 : if (_token == NULL) {
15543 0 : p->level--;
15544 0 : return NULL;
15545 : }
15546 232831 : int _end_lineno = _token->end_lineno;
15547 : UNUSED(_end_lineno); // Only used by EXTRA macro
15548 232831 : int _end_col_offset = _token->end_col_offset;
15549 : UNUSED(_end_col_offset); // Only used by EXTRA macro
15550 232831 : _res = _PyAST_List ( a , Load , EXTRA );
15551 232831 : if (_res == NULL && PyErr_Occurred()) {
15552 0 : p->error_indicator = 1;
15553 0 : p->level--;
15554 0 : return NULL;
15555 : }
15556 232831 : goto done;
15557 : }
15558 31595 : p->mark = _mark;
15559 31595 : 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 31595 : _res = NULL;
15563 264426 : done:
15564 264426 : p->level--;
15565 264426 : return _res;
15566 : }
15567 :
15568 : // tuple: '(' [star_named_expression ',' star_named_expressions?] ')'
15569 : static expr_ty
15570 868733 : tuple_rule(Parser *p)
15571 : {
15572 868733 : if (p->level++ == MAXSTACK) {
15573 0 : p->error_indicator = 1;
15574 0 : PyErr_NoMemory();
15575 : }
15576 868733 : if (p->error_indicator) {
15577 0 : p->level--;
15578 0 : return NULL;
15579 : }
15580 868733 : expr_ty _res = NULL;
15581 868733 : int _mark = p->mark;
15582 868733 : 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 868733 : int _start_lineno = p->tokens[_mark]->lineno;
15588 : UNUSED(_start_lineno); // Only used by EXTRA macro
15589 868733 : 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 868733 : if (p->error_indicator) {
15593 0 : p->level--;
15594 0 : return NULL;
15595 : }
15596 868733 : 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 868733 : if (
15601 868733 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
15602 866646 : &&
15603 866646 : (a = _tmp_110_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?]
15604 866595 : &&
15605 866595 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
15606 : )
15607 : {
15608 572607 : D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
15609 572607 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15610 572607 : if (_token == NULL) {
15611 0 : p->level--;
15612 0 : return NULL;
15613 : }
15614 572607 : int _end_lineno = _token->end_lineno;
15615 : UNUSED(_end_lineno); // Only used by EXTRA macro
15616 572607 : int _end_col_offset = _token->end_col_offset;
15617 : UNUSED(_end_col_offset); // Only used by EXTRA macro
15618 572607 : _res = _PyAST_Tuple ( a , Load , EXTRA );
15619 572607 : if (_res == NULL && PyErr_Occurred()) {
15620 0 : p->error_indicator = 1;
15621 0 : p->level--;
15622 0 : return NULL;
15623 : }
15624 572607 : goto done;
15625 : }
15626 296126 : p->mark = _mark;
15627 296126 : 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 296126 : _res = NULL;
15631 868733 : done:
15632 868733 : p->level--;
15633 868733 : return _res;
15634 : }
15635 :
15636 : // set: '{' star_named_expressions '}'
15637 : static expr_ty
15638 13742 : set_rule(Parser *p)
15639 : {
15640 13742 : if (p->level++ == MAXSTACK) {
15641 0 : p->error_indicator = 1;
15642 0 : PyErr_NoMemory();
15643 : }
15644 13742 : if (p->error_indicator) {
15645 0 : p->level--;
15646 0 : return NULL;
15647 : }
15648 13742 : expr_ty _res = NULL;
15649 13742 : int _mark = p->mark;
15650 13742 : 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 13742 : int _start_lineno = p->tokens[_mark]->lineno;
15656 : UNUSED(_start_lineno); // Only used by EXTRA macro
15657 13742 : int _start_col_offset = p->tokens[_mark]->col_offset;
15658 : UNUSED(_start_col_offset); // Only used by EXTRA macro
15659 : { // '{' star_named_expressions '}'
15660 13742 : if (p->error_indicator) {
15661 0 : p->level--;
15662 0 : return NULL;
15663 : }
15664 13742 : 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 13742 : if (
15669 13742 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
15670 13742 : &&
15671 13742 : (a = star_named_expressions_rule(p)) // star_named_expressions
15672 13709 : &&
15673 13709 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
15674 : )
15675 : {
15676 8371 : D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'"));
15677 8371 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15678 8371 : if (_token == NULL) {
15679 0 : p->level--;
15680 0 : return NULL;
15681 : }
15682 8371 : int _end_lineno = _token->end_lineno;
15683 : UNUSED(_end_lineno); // Only used by EXTRA macro
15684 8371 : int _end_col_offset = _token->end_col_offset;
15685 : UNUSED(_end_col_offset); // Only used by EXTRA macro
15686 8371 : _res = _PyAST_Set ( a , EXTRA );
15687 8371 : if (_res == NULL && PyErr_Occurred()) {
15688 0 : p->error_indicator = 1;
15689 0 : p->level--;
15690 0 : return NULL;
15691 : }
15692 8371 : goto done;
15693 : }
15694 5371 : p->mark = _mark;
15695 5371 : 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 5371 : _res = NULL;
15699 13742 : done:
15700 13742 : p->level--;
15701 13742 : return _res;
15702 : }
15703 :
15704 : // dict: '{' double_starred_kvpairs? '}' | '{' invalid_double_starred_kvpairs '}'
15705 : static expr_ty
15706 112966 : dict_rule(Parser *p)
15707 : {
15708 112966 : if (p->level++ == MAXSTACK) {
15709 0 : p->error_indicator = 1;
15710 0 : PyErr_NoMemory();
15711 : }
15712 112966 : if (p->error_indicator) {
15713 0 : p->level--;
15714 0 : return NULL;
15715 : }
15716 112966 : expr_ty _res = NULL;
15717 112966 : int _mark = p->mark;
15718 112966 : 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 112966 : int _start_lineno = p->tokens[_mark]->lineno;
15724 : UNUSED(_start_lineno); // Only used by EXTRA macro
15725 112966 : int _start_col_offset = p->tokens[_mark]->col_offset;
15726 : UNUSED(_start_col_offset); // Only used by EXTRA macro
15727 : { // '{' double_starred_kvpairs? '}'
15728 112966 : if (p->error_indicator) {
15729 0 : p->level--;
15730 0 : return NULL;
15731 : }
15732 112966 : 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 112966 : if (
15737 112966 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
15738 112966 : &&
15739 112966 : (a = double_starred_kvpairs_rule(p), !p->error_indicator) // double_starred_kvpairs?
15740 112940 : &&
15741 112940 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
15742 : )
15743 : {
15744 99192 : D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
15745 99192 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15746 99192 : if (_token == NULL) {
15747 0 : p->level--;
15748 0 : return NULL;
15749 : }
15750 99192 : int _end_lineno = _token->end_lineno;
15751 : UNUSED(_end_lineno); // Only used by EXTRA macro
15752 99192 : int _end_col_offset = _token->end_col_offset;
15753 : UNUSED(_end_col_offset); // Only used by EXTRA macro
15754 99192 : _res = _PyAST_Dict ( CHECK ( asdl_expr_seq* , _PyPegen_get_keys ( p , a ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_values ( p , a ) ) , EXTRA );
15755 99192 : if (_res == NULL && PyErr_Occurred()) {
15756 0 : p->error_indicator = 1;
15757 0 : p->level--;
15758 0 : return NULL;
15759 : }
15760 99192 : goto done;
15761 : }
15762 13774 : p->mark = _mark;
15763 13774 : 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 13774 : if (p->error_indicator) {
15768 26 : p->level--;
15769 26 : return NULL;
15770 : }
15771 13748 : 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 13748 : if (
15776 13748 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
15777 13748 : &&
15778 13748 : (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 0 : 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 13748 : p->mark = _mark;
15788 13748 : 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 13748 : _res = NULL;
15792 112940 : done:
15793 112940 : p->level--;
15794 112940 : return _res;
15795 : }
15796 :
15797 : // double_starred_kvpairs: ','.double_starred_kvpair+ ','?
15798 : static asdl_seq*
15799 112966 : double_starred_kvpairs_rule(Parser *p)
15800 : {
15801 112966 : if (p->level++ == MAXSTACK) {
15802 0 : p->error_indicator = 1;
15803 0 : PyErr_NoMemory();
15804 : }
15805 112966 : if (p->error_indicator) {
15806 0 : p->level--;
15807 0 : return NULL;
15808 : }
15809 112966 : asdl_seq* _res = NULL;
15810 112966 : int _mark = p->mark;
15811 : { // ','.double_starred_kvpair+ ','?
15812 112966 : if (p->error_indicator) {
15813 0 : p->level--;
15814 0 : return NULL;
15815 : }
15816 112966 : 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 112966 : if (
15821 112966 : (a = _gather_111_rule(p)) // ','.double_starred_kvpair+
15822 65010 : &&
15823 65010 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
15824 : )
15825 : {
15826 64997 : D(fprintf(stderr, "%*c+ double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?"));
15827 64997 : _res = a;
15828 64997 : if (_res == NULL && PyErr_Occurred()) {
15829 0 : p->error_indicator = 1;
15830 0 : p->level--;
15831 0 : return NULL;
15832 : }
15833 64997 : goto done;
15834 : }
15835 47969 : p->mark = _mark;
15836 47969 : 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 47969 : _res = NULL;
15840 112966 : done:
15841 112966 : p->level--;
15842 112966 : return _res;
15843 : }
15844 :
15845 : // double_starred_kvpair: '**' bitwise_or | kvpair
15846 : static KeyValuePair*
15847 1608460 : double_starred_kvpair_rule(Parser *p)
15848 : {
15849 1608460 : if (p->level++ == MAXSTACK) {
15850 0 : p->error_indicator = 1;
15851 0 : PyErr_NoMemory();
15852 : }
15853 1608460 : if (p->error_indicator) {
15854 0 : p->level--;
15855 0 : return NULL;
15856 : }
15857 1608460 : KeyValuePair* _res = NULL;
15858 1608460 : int _mark = p->mark;
15859 : { // '**' bitwise_or
15860 1608460 : if (p->error_indicator) {
15861 0 : p->level--;
15862 0 : return NULL;
15863 : }
15864 1608460 : 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 1608460 : if (
15868 1608460 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
15869 3090 : &&
15870 3090 : (a = bitwise_or_rule(p)) // bitwise_or
15871 : )
15872 : {
15873 3090 : D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or"));
15874 3090 : _res = _PyPegen_key_value_pair ( p , NULL , a );
15875 3090 : if (_res == NULL && PyErr_Occurred()) {
15876 0 : p->error_indicator = 1;
15877 0 : p->level--;
15878 0 : return NULL;
15879 : }
15880 3090 : goto done;
15881 : }
15882 1605370 : p->mark = _mark;
15883 1605370 : 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 1605370 : if (p->error_indicator) {
15888 12 : p->level--;
15889 12 : return NULL;
15890 : }
15891 1605360 : D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kvpair"));
15892 : KeyValuePair* kvpair_var;
15893 1605360 : if (
15894 1605360 : (kvpair_var = kvpair_rule(p)) // kvpair
15895 : )
15896 : {
15897 1525020 : D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kvpair"));
15898 1525020 : _res = kvpair_var;
15899 1525020 : goto done;
15900 : }
15901 80339 : p->mark = _mark;
15902 80339 : 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 80339 : _res = NULL;
15906 1608450 : done:
15907 1608450 : p->level--;
15908 1608450 : return _res;
15909 : }
15910 :
15911 : // kvpair: expression ':' expression
15912 : static KeyValuePair*
15913 1610720 : kvpair_rule(Parser *p)
15914 : {
15915 1610720 : if (p->level++ == MAXSTACK) {
15916 0 : p->error_indicator = 1;
15917 0 : PyErr_NoMemory();
15918 : }
15919 1610720 : if (p->error_indicator) {
15920 0 : p->level--;
15921 0 : return NULL;
15922 : }
15923 1610720 : KeyValuePair* _res = NULL;
15924 1610720 : int _mark = p->mark;
15925 : { // expression ':' expression
15926 1610720 : if (p->error_indicator) {
15927 0 : p->level--;
15928 0 : return NULL;
15929 : }
15930 1610720 : 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 1610720 : if (
15935 1610720 : (a = expression_rule(p)) // expression
15936 1550100 : &&
15937 1550100 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
15938 1528870 : &&
15939 1528870 : (b = expression_rule(p)) // expression
15940 : )
15941 : {
15942 1528810 : D(fprintf(stderr, "%*c+ kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
15943 1528810 : _res = _PyPegen_key_value_pair ( p , a , b );
15944 1528810 : if (_res == NULL && PyErr_Occurred()) {
15945 0 : p->error_indicator = 1;
15946 0 : p->level--;
15947 0 : return NULL;
15948 : }
15949 1528810 : goto done;
15950 : }
15951 81911 : p->mark = _mark;
15952 81911 : 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 81911 : _res = NULL;
15956 1610720 : done:
15957 1610720 : p->level--;
15958 1610720 : return _res;
15959 : }
15960 :
15961 : // for_if_clauses: for_if_clause+
15962 : static asdl_comprehension_seq*
15963 2133110 : for_if_clauses_rule(Parser *p)
15964 : {
15965 2133110 : if (p->level++ == MAXSTACK) {
15966 0 : p->error_indicator = 1;
15967 0 : PyErr_NoMemory();
15968 : }
15969 2133110 : if (p->error_indicator) {
15970 0 : p->level--;
15971 0 : return NULL;
15972 : }
15973 2133110 : asdl_comprehension_seq* _res = NULL;
15974 2133110 : int _mark = p->mark;
15975 : { // for_if_clause+
15976 2133110 : if (p->error_indicator) {
15977 0 : p->level--;
15978 0 : return NULL;
15979 : }
15980 2133110 : 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 2133110 : if (
15983 2133110 : (a = (asdl_comprehension_seq*)_loop1_113_rule(p)) // for_if_clause+
15984 : )
15985 : {
15986 49885 : D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "for_if_clause+"));
15987 49885 : _res = a;
15988 49885 : if (_res == NULL && PyErr_Occurred()) {
15989 0 : p->error_indicator = 1;
15990 0 : p->level--;
15991 0 : return NULL;
15992 : }
15993 49885 : goto done;
15994 : }
15995 2083230 : p->mark = _mark;
15996 2083230 : 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 2083230 : _res = NULL;
16000 2133110 : done:
16001 2133110 : p->level--;
16002 2133110 : 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 2185000 : for_if_clause_rule(Parser *p)
16011 : {
16012 2185000 : if (p->level++ == MAXSTACK) {
16013 0 : p->error_indicator = 1;
16014 0 : PyErr_NoMemory();
16015 : }
16016 2185000 : if (p->error_indicator) {
16017 0 : p->level--;
16018 0 : return NULL;
16019 : }
16020 2185000 : comprehension_ty _res = NULL;
16021 2185000 : int _mark = p->mark;
16022 : { // ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
16023 2185000 : if (p->error_indicator) {
16024 0 : p->level--;
16025 0 : return NULL;
16026 : }
16027 2185000 : 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 2185000 : 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 2185000 : if (
16036 2185000 : (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 508 : 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 2184490 : p->mark = _mark;
16061 2184490 : 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 2184490 : if (_cut_var) {
16064 0 : p->level--;
16065 0 : return NULL;
16066 : }
16067 : }
16068 : { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
16069 2184490 : if (p->error_indicator) {
16070 0 : p->level--;
16071 0 : return NULL;
16072 : }
16073 2184490 : D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
16074 2184490 : 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 2184490 : if (
16081 2184490 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
16082 51404 : &&
16083 51404 : (a = star_targets_rule(p)) // star_targets
16084 51400 : &&
16085 51400 : (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='in'
16086 : &&
16087 51391 : (_cut_var = 1)
16088 51391 : &&
16089 51391 : (b = disjunction_rule(p)) // disjunction
16090 51383 : &&
16091 51383 : (c = (asdl_expr_seq*)_loop0_115_rule(p)) // (('if' disjunction))*
16092 : )
16093 : {
16094 51383 : 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 51383 : _res = _PyAST_comprehension ( a , b , c , 0 , p -> arena );
16096 51383 : if (_res == NULL && PyErr_Occurred()) {
16097 0 : p->error_indicator = 1;
16098 0 : p->level--;
16099 0 : return NULL;
16100 : }
16101 51383 : goto done;
16102 : }
16103 2133110 : p->mark = _mark;
16104 2133110 : 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 2133110 : if (_cut_var) {
16107 8 : p->level--;
16108 8 : return NULL;
16109 : }
16110 : }
16111 2133100 : if (p->call_invalid_rules) { // invalid_for_target
16112 488 : if (p->error_indicator) {
16113 0 : p->level--;
16114 0 : return NULL;
16115 : }
16116 488 : 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 0 : 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 488 : 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 2133100 : _res = NULL;
16131 2184990 : done:
16132 2184990 : p->level--;
16133 2184990 : return _res;
16134 : }
16135 :
16136 : // listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension
16137 : static expr_ty
16138 29421 : listcomp_rule(Parser *p)
16139 : {
16140 29421 : if (p->level++ == MAXSTACK) {
16141 0 : p->error_indicator = 1;
16142 0 : PyErr_NoMemory();
16143 : }
16144 29421 : if (p->error_indicator) {
16145 0 : p->level--;
16146 0 : return NULL;
16147 : }
16148 29421 : expr_ty _res = NULL;
16149 29421 : int _mark = p->mark;
16150 29421 : 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 29421 : int _start_lineno = p->tokens[_mark]->lineno;
16156 : UNUSED(_start_lineno); // Only used by EXTRA macro
16157 29421 : 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 29421 : if (p->error_indicator) {
16161 0 : p->level--;
16162 0 : return NULL;
16163 : }
16164 29421 : 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 29421 : if (
16170 29421 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
16171 29421 : &&
16172 29421 : (a = named_expression_rule(p)) // named_expression
16173 29378 : &&
16174 29378 : (b = for_if_clauses_rule(p)) // for_if_clauses
16175 29336 : &&
16176 29336 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
16177 : )
16178 : {
16179 29332 : D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' named_expression for_if_clauses ']'"));
16180 29332 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16181 29332 : if (_token == NULL) {
16182 0 : p->level--;
16183 0 : return NULL;
16184 : }
16185 29332 : int _end_lineno = _token->end_lineno;
16186 : UNUSED(_end_lineno); // Only used by EXTRA macro
16187 29332 : int _end_col_offset = _token->end_col_offset;
16188 : UNUSED(_end_col_offset); // Only used by EXTRA macro
16189 29332 : _res = _PyAST_ListComp ( a , b , EXTRA );
16190 29332 : if (_res == NULL && PyErr_Occurred()) {
16191 0 : p->error_indicator = 1;
16192 0 : p->level--;
16193 0 : return NULL;
16194 : }
16195 29332 : goto done;
16196 : }
16197 89 : p->mark = _mark;
16198 89 : 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 14 : 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 0 : 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 14 : 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 29418 : done:
16222 29418 : p->level--;
16223 29418 : return _res;
16224 : }
16225 :
16226 : // setcomp: '{' named_expression for_if_clauses '}' | invalid_comprehension
16227 : static expr_ty
16228 1577 : setcomp_rule(Parser *p)
16229 : {
16230 1577 : if (p->level++ == MAXSTACK) {
16231 0 : p->error_indicator = 1;
16232 0 : PyErr_NoMemory();
16233 : }
16234 1577 : if (p->error_indicator) {
16235 0 : p->level--;
16236 0 : return NULL;
16237 : }
16238 1577 : expr_ty _res = NULL;
16239 1577 : int _mark = p->mark;
16240 1577 : 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 1577 : int _start_lineno = p->tokens[_mark]->lineno;
16246 : UNUSED(_start_lineno); // Only used by EXTRA macro
16247 1577 : 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 1577 : if (p->error_indicator) {
16251 0 : p->level--;
16252 0 : return NULL;
16253 : }
16254 1577 : 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 1577 : if (
16260 1577 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
16261 1577 : &&
16262 1577 : (a = named_expression_rule(p)) // named_expression
16263 1550 : &&
16264 1550 : (b = for_if_clauses_rule(p)) // for_if_clauses
16265 1519 : &&
16266 1519 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
16267 : )
16268 : {
16269 1519 : D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' named_expression for_if_clauses '}'"));
16270 1519 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16271 1519 : if (_token == NULL) {
16272 0 : p->level--;
16273 0 : return NULL;
16274 : }
16275 1519 : int _end_lineno = _token->end_lineno;
16276 : UNUSED(_end_lineno); // Only used by EXTRA macro
16277 1519 : int _end_col_offset = _token->end_col_offset;
16278 : UNUSED(_end_col_offset); // Only used by EXTRA macro
16279 1519 : _res = _PyAST_SetComp ( a , b , EXTRA );
16280 1519 : if (_res == NULL && PyErr_Occurred()) {
16281 0 : p->error_indicator = 1;
16282 0 : p->level--;
16283 0 : return NULL;
16284 : }
16285 1519 : goto done;
16286 : }
16287 58 : p->mark = _mark;
16288 58 : 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 30 : 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 0 : 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 30 : 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 1577 : done:
16312 1577 : p->level--;
16313 1577 : return _res;
16314 : }
16315 :
16316 : // genexp:
16317 : // | '(' (assignment_expression | expression !':=') for_if_clauses ')'
16318 : // | invalid_comprehension
16319 : static expr_ty
16320 14536600 : genexp_rule(Parser *p)
16321 : {
16322 14536600 : if (p->level++ == MAXSTACK) {
16323 0 : p->error_indicator = 1;
16324 0 : PyErr_NoMemory();
16325 : }
16326 14536600 : if (p->error_indicator) {
16327 0 : p->level--;
16328 0 : return NULL;
16329 : }
16330 14536600 : expr_ty _res = NULL;
16331 14536600 : int _mark = p->mark;
16332 14536600 : 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 14536600 : int _start_lineno = p->tokens[_mark]->lineno;
16338 : UNUSED(_start_lineno); // Only used by EXTRA macro
16339 14536600 : 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 14536600 : if (p->error_indicator) {
16343 0 : p->level--;
16344 0 : return NULL;
16345 : }
16346 14536600 : 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 14536600 : if (
16352 14536600 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
16353 3099980 : &&
16354 3099980 : (a = _tmp_116_rule(p)) // assignment_expression | expression !':='
16355 2098110 : &&
16356 2098110 : (b = for_if_clauses_rule(p)) // for_if_clauses
16357 15208 : &&
16358 15208 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
16359 : )
16360 : {
16361 15174 : D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'"));
16362 15174 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16363 15174 : if (_token == NULL) {
16364 0 : p->level--;
16365 0 : return NULL;
16366 : }
16367 15174 : int _end_lineno = _token->end_lineno;
16368 : UNUSED(_end_lineno); // Only used by EXTRA macro
16369 15174 : int _end_col_offset = _token->end_col_offset;
16370 : UNUSED(_end_col_offset); // Only used by EXTRA macro
16371 15174 : _res = _PyAST_GeneratorExp ( a , b , EXTRA );
16372 15174 : if (_res == NULL && PyErr_Occurred()) {
16373 0 : p->error_indicator = 1;
16374 0 : p->level--;
16375 0 : return NULL;
16376 : }
16377 15174 : goto done;
16378 : }
16379 14521400 : p->mark = _mark;
16380 14521400 : 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 14521400 : if (p->call_invalid_rules) { // invalid_comprehension
16384 2862 : if (p->error_indicator) {
16385 0 : p->level--;
16386 0 : return NULL;
16387 : }
16388 2862 : 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 0 : 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 2862 : 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 14521400 : _res = NULL;
16403 14536600 : done:
16404 14536600 : p->level--;
16405 14536600 : return _res;
16406 : }
16407 :
16408 : // dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension
16409 : static expr_ty
16410 5366 : dictcomp_rule(Parser *p)
16411 : {
16412 5366 : if (p->level++ == MAXSTACK) {
16413 0 : p->error_indicator = 1;
16414 0 : PyErr_NoMemory();
16415 : }
16416 5366 : if (p->error_indicator) {
16417 0 : p->level--;
16418 0 : return NULL;
16419 : }
16420 5366 : expr_ty _res = NULL;
16421 5366 : int _mark = p->mark;
16422 5366 : 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 5366 : int _start_lineno = p->tokens[_mark]->lineno;
16428 : UNUSED(_start_lineno); // Only used by EXTRA macro
16429 5366 : 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 5366 : if (p->error_indicator) {
16433 0 : p->level--;
16434 0 : return NULL;
16435 : }
16436 5366 : 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 5366 : if (
16442 5366 : (_literal = _PyPegen_expect_token(p, 25)) // token='{'
16443 5366 : &&
16444 5366 : (a = kvpair_rule(p)) // kvpair
16445 3794 : &&
16446 3794 : (b = for_if_clauses_rule(p)) // for_if_clauses
16447 3788 : &&
16448 3788 : (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
16449 : )
16450 : {
16451 3788 : D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
16452 3788 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16453 3788 : if (_token == NULL) {
16454 0 : p->level--;
16455 0 : return NULL;
16456 : }
16457 3788 : int _end_lineno = _token->end_lineno;
16458 : UNUSED(_end_lineno); // Only used by EXTRA macro
16459 3788 : int _end_col_offset = _token->end_col_offset;
16460 : UNUSED(_end_col_offset); // Only used by EXTRA macro
16461 3788 : _res = _PyAST_DictComp ( a -> key , a -> value , b , EXTRA );
16462 3788 : if (_res == NULL && PyErr_Occurred()) {
16463 0 : p->error_indicator = 1;
16464 0 : p->level--;
16465 0 : return NULL;
16466 : }
16467 3788 : goto done;
16468 : }
16469 1578 : p->mark = _mark;
16470 1578 : 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 1578 : if (p->call_invalid_rules) { // invalid_dict_comprehension
16474 37 : if (p->error_indicator) {
16475 0 : p->level--;
16476 0 : return NULL;
16477 : }
16478 37 : 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 0 : 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 37 : 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 1578 : _res = NULL;
16493 5366 : done:
16494 5366 : p->level--;
16495 5366 : return _res;
16496 : }
16497 :
16498 : // arguments: args ','? &')' | invalid_arguments
16499 : static expr_ty
16500 3130560 : arguments_rule(Parser *p)
16501 : {
16502 3130560 : if (p->level++ == MAXSTACK) {
16503 0 : p->error_indicator = 1;
16504 0 : PyErr_NoMemory();
16505 : }
16506 3130560 : if (p->error_indicator) {
16507 0 : p->level--;
16508 0 : return NULL;
16509 : }
16510 3130560 : expr_ty _res = NULL;
16511 3130560 : if (_PyPegen_is_memoized(p, arguments_type, &_res)) {
16512 1195990 : p->level--;
16513 1195990 : return _res;
16514 : }
16515 1934560 : int _mark = p->mark;
16516 : { // args ','? &')'
16517 1934560 : if (p->error_indicator) {
16518 0 : p->level--;
16519 0 : return NULL;
16520 : }
16521 1934560 : 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 1934560 : if (
16526 1934560 : (a = args_rule(p)) // args
16527 1388560 : &&
16528 1388560 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
16529 1388560 : &&
16530 1388560 : _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
16531 : )
16532 : {
16533 1385550 : D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','? &')'"));
16534 1385550 : _res = a;
16535 1385550 : if (_res == NULL && PyErr_Occurred()) {
16536 0 : p->error_indicator = 1;
16537 0 : p->level--;
16538 0 : return NULL;
16539 : }
16540 1385550 : goto done;
16541 : }
16542 549009 : p->mark = _mark;
16543 549009 : D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ',
16544 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','? &')'"));
16545 : }
16546 549009 : if (p->call_invalid_rules) { // invalid_arguments
16547 109 : if (p->error_indicator) {
16548 15 : p->level--;
16549 15 : return NULL;
16550 : }
16551 94 : 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 0 : 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 94 : 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 548994 : _res = NULL;
16566 1934550 : done:
16567 1934550 : _PyPegen_insert_memo(p, _mark, arguments_type, _res);
16568 1934550 : p->level--;
16569 1934550 : return _res;
16570 : }
16571 :
16572 : // args:
16573 : // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]
16574 : // | kwargs
16575 : static expr_ty
16576 1934900 : args_rule(Parser *p)
16577 : {
16578 1934900 : if (p->level++ == MAXSTACK) {
16579 0 : p->error_indicator = 1;
16580 0 : PyErr_NoMemory();
16581 : }
16582 1934900 : if (p->error_indicator) {
16583 0 : p->level--;
16584 0 : return NULL;
16585 : }
16586 1934900 : expr_ty _res = NULL;
16587 1934900 : int _mark = p->mark;
16588 1934900 : 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 1934900 : int _start_lineno = p->tokens[_mark]->lineno;
16594 : UNUSED(_start_lineno); // Only used by EXTRA macro
16595 1934900 : 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 1934900 : if (p->error_indicator) {
16599 0 : p->level--;
16600 0 : return NULL;
16601 : }
16602 1934900 : 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 1934900 : if (
16606 1934900 : (a = (asdl_expr_seq*)_gather_117_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+
16607 1349900 : &&
16608 1349900 : (b = _tmp_119_rule(p), !p->error_indicator) // [',' kwargs]
16609 : )
16610 : {
16611 1349880 : D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]"));
16612 1349880 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16613 1349880 : if (_token == NULL) {
16614 0 : p->level--;
16615 0 : return NULL;
16616 : }
16617 1349880 : int _end_lineno = _token->end_lineno;
16618 : UNUSED(_end_lineno); // Only used by EXTRA macro
16619 1349880 : int _end_col_offset = _token->end_col_offset;
16620 : UNUSED(_end_col_offset); // Only used by EXTRA macro
16621 1349880 : _res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA );
16622 1349880 : if (_res == NULL && PyErr_Occurred()) {
16623 0 : p->error_indicator = 1;
16624 0 : p->level--;
16625 0 : return NULL;
16626 : }
16627 1349880 : goto done;
16628 : }
16629 585019 : p->mark = _mark;
16630 585019 : 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 585019 : if (p->error_indicator) {
16635 16 : p->level--;
16636 16 : return NULL;
16637 : }
16638 585003 : D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs"));
16639 : asdl_seq* a;
16640 585003 : if (
16641 585003 : (a = kwargs_rule(p)) // kwargs
16642 : )
16643 : {
16644 38818 : D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs"));
16645 38818 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16646 38818 : if (_token == NULL) {
16647 0 : p->level--;
16648 0 : return NULL;
16649 : }
16650 38818 : int _end_lineno = _token->end_lineno;
16651 : UNUSED(_end_lineno); // Only used by EXTRA macro
16652 38818 : int _end_col_offset = _token->end_col_offset;
16653 : UNUSED(_end_col_offset); // Only used by EXTRA macro
16654 38818 : _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 38818 : if (_res == NULL && PyErr_Occurred()) {
16656 0 : p->error_indicator = 1;
16657 0 : p->level--;
16658 0 : return NULL;
16659 : }
16660 38818 : goto done;
16661 : }
16662 546185 : p->mark = _mark;
16663 546185 : D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ',
16664 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs"));
16665 : }
16666 546185 : _res = NULL;
16667 1934890 : done:
16668 1934890 : p->level--;
16669 1934890 : 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 657731 : kwargs_rule(Parser *p)
16678 : {
16679 657731 : if (p->level++ == MAXSTACK) {
16680 0 : p->error_indicator = 1;
16681 0 : PyErr_NoMemory();
16682 : }
16683 657731 : if (p->error_indicator) {
16684 0 : p->level--;
16685 0 : return NULL;
16686 : }
16687 657731 : asdl_seq* _res = NULL;
16688 657731 : int _mark = p->mark;
16689 : { // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
16690 657731 : if (p->error_indicator) {
16691 0 : p->level--;
16692 0 : return NULL;
16693 : }
16694 657731 : 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 657731 : if (
16699 657731 : (a = _gather_120_rule(p)) // ','.kwarg_or_starred+
16700 98915 : &&
16701 98915 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
16702 8559 : &&
16703 8559 : (b = _gather_122_rule(p)) // ','.kwarg_or_double_starred+
16704 : )
16705 : {
16706 1039 : D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+"));
16707 1039 : _res = _PyPegen_join_sequences ( p , a , b );
16708 1039 : if (_res == NULL && PyErr_Occurred()) {
16709 0 : p->error_indicator = 1;
16710 0 : p->level--;
16711 0 : return NULL;
16712 : }
16713 1039 : goto done;
16714 : }
16715 656692 : p->mark = _mark;
16716 656692 : 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 656692 : if (p->error_indicator) {
16721 14 : p->level--;
16722 14 : return NULL;
16723 : }
16724 656678 : D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+"));
16725 : asdl_seq * _gather_124_var;
16726 656678 : if (
16727 656678 : (_gather_124_var = _gather_124_rule(p)) // ','.kwarg_or_starred+
16728 : )
16729 : {
16730 97876 : D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+"));
16731 97876 : _res = _gather_124_var;
16732 97876 : goto done;
16733 : }
16734 558802 : p->mark = _mark;
16735 558802 : 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 558802 : if (p->error_indicator) {
16740 0 : p->level--;
16741 0 : return NULL;
16742 : }
16743 558802 : 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 558802 : if (
16746 558802 : (_gather_126_var = _gather_126_rule(p)) // ','.kwarg_or_double_starred+
16747 : )
16748 : {
16749 7541 : D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+"));
16750 7541 : _res = _gather_126_var;
16751 7541 : goto done;
16752 : }
16753 551261 : p->mark = _mark;
16754 551261 : 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 551261 : _res = NULL;
16758 657717 : done:
16759 657717 : p->level--;
16760 657717 : return _res;
16761 : }
16762 :
16763 : // starred_expression: '*' expression
16764 : static expr_ty
16765 3896780 : starred_expression_rule(Parser *p)
16766 : {
16767 3896780 : if (p->level++ == MAXSTACK) {
16768 0 : p->error_indicator = 1;
16769 0 : PyErr_NoMemory();
16770 : }
16771 3896780 : if (p->error_indicator) {
16772 0 : p->level--;
16773 0 : return NULL;
16774 : }
16775 3896780 : expr_ty _res = NULL;
16776 3896780 : int _mark = p->mark;
16777 3896780 : 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 3896770 : int _start_lineno = p->tokens[_mark]->lineno;
16783 : UNUSED(_start_lineno); // Only used by EXTRA macro
16784 3896770 : int _start_col_offset = p->tokens[_mark]->col_offset;
16785 : UNUSED(_start_col_offset); // Only used by EXTRA macro
16786 : { // '*' expression
16787 3896770 : if (p->error_indicator) {
16788 0 : p->level--;
16789 0 : return NULL;
16790 : }
16791 3896770 : D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression"));
16792 : Token * _literal;
16793 : expr_ty a;
16794 3896770 : if (
16795 3896770 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
16796 12784 : &&
16797 12784 : (a = expression_rule(p)) // expression
16798 : )
16799 : {
16800 12728 : D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression"));
16801 12728 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16802 12728 : if (_token == NULL) {
16803 0 : p->level--;
16804 0 : return NULL;
16805 : }
16806 12728 : int _end_lineno = _token->end_lineno;
16807 : UNUSED(_end_lineno); // Only used by EXTRA macro
16808 12728 : int _end_col_offset = _token->end_col_offset;
16809 : UNUSED(_end_col_offset); // Only used by EXTRA macro
16810 12728 : _res = _PyAST_Starred ( a , Load , EXTRA );
16811 12728 : if (_res == NULL && PyErr_Occurred()) {
16812 0 : p->error_indicator = 1;
16813 0 : p->level--;
16814 0 : return NULL;
16815 : }
16816 12728 : goto done;
16817 : }
16818 3884040 : p->mark = _mark;
16819 3884040 : 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 3884040 : _res = NULL;
16823 3896770 : done:
16824 3896770 : p->level--;
16825 3896770 : return _res;
16826 : }
16827 :
16828 : // kwarg_or_starred: invalid_kwarg | NAME '=' expression | starred_expression
16829 : static KeywordOrStarred*
16830 1482340 : kwarg_or_starred_rule(Parser *p)
16831 : {
16832 1482340 : if (p->level++ == MAXSTACK) {
16833 0 : p->error_indicator = 1;
16834 0 : PyErr_NoMemory();
16835 : }
16836 1482340 : if (p->error_indicator) {
16837 0 : p->level--;
16838 0 : return NULL;
16839 : }
16840 1482340 : KeywordOrStarred* _res = NULL;
16841 1482340 : int _mark = p->mark;
16842 1482340 : 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 1482340 : int _start_lineno = p->tokens[_mark]->lineno;
16848 : UNUSED(_start_lineno); // Only used by EXTRA macro
16849 1482340 : int _start_col_offset = p->tokens[_mark]->col_offset;
16850 : UNUSED(_start_col_offset); // Only used by EXTRA macro
16851 1482340 : if (p->call_invalid_rules) { // invalid_kwarg
16852 804 : if (p->error_indicator) {
16853 0 : p->level--;
16854 0 : return NULL;
16855 : }
16856 804 : 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 0 : 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 804 : 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 1482340 : if (p->error_indicator) {
16872 14 : p->level--;
16873 14 : return NULL;
16874 : }
16875 1482330 : 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 1482330 : if (
16880 1482330 : (a = _PyPegen_name_token(p)) // NAME
16881 348553 : &&
16882 348553 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
16883 348461 : &&
16884 348461 : (b = expression_rule(p)) // expression
16885 : )
16886 : {
16887 348449 : D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
16888 348449 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16889 348449 : if (_token == NULL) {
16890 0 : p->level--;
16891 0 : return NULL;
16892 : }
16893 348449 : int _end_lineno = _token->end_lineno;
16894 : UNUSED(_end_lineno); // Only used by EXTRA macro
16895 348449 : int _end_col_offset = _token->end_col_offset;
16896 : UNUSED(_end_col_offset); // Only used by EXTRA macro
16897 348449 : _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
16898 348449 : if (_res == NULL && PyErr_Occurred()) {
16899 0 : p->error_indicator = 1;
16900 0 : p->level--;
16901 0 : return NULL;
16902 : }
16903 348449 : goto done;
16904 : }
16905 1133880 : p->mark = _mark;
16906 1133880 : 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 1133880 : if (p->error_indicator) {
16911 0 : p->level--;
16912 0 : return NULL;
16913 : }
16914 1133880 : D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
16915 : expr_ty a;
16916 1133880 : if (
16917 1133880 : (a = starred_expression_rule(p)) // starred_expression
16918 : )
16919 : {
16920 199 : 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 1133680 : p->mark = _mark;
16930 1133680 : 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 1133680 : _res = NULL;
16934 1482330 : done:
16935 1482330 : p->level--;
16936 1482330 : return _res;
16937 : }
16938 :
16939 : // kwarg_or_double_starred: invalid_kwarg | NAME '=' expression | '**' expression
16940 : static KeywordOrStarred*
16941 567452 : kwarg_or_double_starred_rule(Parser *p)
16942 : {
16943 567452 : if (p->level++ == MAXSTACK) {
16944 0 : p->error_indicator = 1;
16945 0 : PyErr_NoMemory();
16946 : }
16947 567452 : if (p->error_indicator) {
16948 0 : p->level--;
16949 0 : return NULL;
16950 : }
16951 567452 : KeywordOrStarred* _res = NULL;
16952 567452 : int _mark = p->mark;
16953 567452 : 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 567452 : int _start_lineno = p->tokens[_mark]->lineno;
16959 : UNUSED(_start_lineno); // Only used by EXTRA macro
16960 567452 : int _start_col_offset = p->tokens[_mark]->col_offset;
16961 : UNUSED(_start_col_offset); // Only used by EXTRA macro
16962 567452 : if (p->call_invalid_rules) { // invalid_kwarg
16963 326 : if (p->error_indicator) {
16964 0 : p->level--;
16965 0 : return NULL;
16966 : }
16967 326 : 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 0 : 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 326 : 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 567452 : if (p->error_indicator) {
16983 0 : p->level--;
16984 0 : return NULL;
16985 : }
16986 567452 : 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 567452 : if (
16991 567452 : (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 41 : 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 567411 : p->mark = _mark;
17017 567411 : 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 567411 : if (p->error_indicator) {
17022 0 : p->level--;
17023 0 : return NULL;
17024 : }
17025 567411 : 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 567411 : if (
17029 567411 : (_literal = _PyPegen_expect_token(p, 35)) // token='**'
17030 8604 : &&
17031 8604 : (a = expression_rule(p)) // expression
17032 : )
17033 : {
17034 8603 : D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression"));
17035 8603 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17036 8603 : if (_token == NULL) {
17037 0 : p->level--;
17038 0 : return NULL;
17039 : }
17040 8603 : int _end_lineno = _token->end_lineno;
17041 : UNUSED(_end_lineno); // Only used by EXTRA macro
17042 8603 : int _end_col_offset = _token->end_col_offset;
17043 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17044 8603 : _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( NULL , a , EXTRA ) ) , 1 );
17045 8603 : if (_res == NULL && PyErr_Occurred()) {
17046 0 : p->error_indicator = 1;
17047 0 : p->level--;
17048 0 : return NULL;
17049 : }
17050 8603 : goto done;
17051 : }
17052 558808 : p->mark = _mark;
17053 558808 : 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 558808 : _res = NULL;
17057 567452 : done:
17058 567452 : p->level--;
17059 567452 : return _res;
17060 : }
17061 :
17062 : // star_targets: star_target !',' | star_target ((',' star_target))* ','?
17063 : static expr_ty
17064 4151060 : star_targets_rule(Parser *p)
17065 : {
17066 4151060 : if (p->level++ == MAXSTACK) {
17067 0 : p->error_indicator = 1;
17068 0 : PyErr_NoMemory();
17069 : }
17070 4151060 : if (p->error_indicator) {
17071 0 : p->level--;
17072 0 : return NULL;
17073 : }
17074 4151060 : expr_ty _res = NULL;
17075 4151060 : int _mark = p->mark;
17076 4151060 : 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 4151040 : int _start_lineno = p->tokens[_mark]->lineno;
17082 : UNUSED(_start_lineno); // Only used by EXTRA macro
17083 4151040 : int _start_col_offset = p->tokens[_mark]->col_offset;
17084 : UNUSED(_start_col_offset); // Only used by EXTRA macro
17085 : { // star_target !','
17086 4151040 : if (p->error_indicator) {
17087 0 : p->level--;
17088 0 : return NULL;
17089 : }
17090 4151040 : D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target !','"));
17091 : expr_ty a;
17092 4151040 : if (
17093 4151040 : (a = star_target_rule(p)) // star_target
17094 2281920 : &&
17095 2281920 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
17096 : )
17097 : {
17098 2224820 : D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target !','"));
17099 2224820 : _res = a;
17100 2224820 : if (_res == NULL && PyErr_Occurred()) {
17101 0 : p->error_indicator = 1;
17102 0 : p->level--;
17103 0 : return NULL;
17104 : }
17105 2224820 : goto done;
17106 : }
17107 1926220 : p->mark = _mark;
17108 1926220 : 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 1926220 : if (p->error_indicator) {
17113 18 : p->level--;
17114 18 : return NULL;
17115 : }
17116 1926200 : 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 1926200 : if (
17122 1926200 : (a = star_target_rule(p)) // star_target
17123 57095 : &&
17124 57095 : (b = _loop0_128_rule(p)) // ((',' star_target))*
17125 57095 : &&
17126 57095 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
17127 : )
17128 : {
17129 57093 : D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?"));
17130 57093 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17131 57093 : if (_token == NULL) {
17132 0 : p->level--;
17133 0 : return NULL;
17134 : }
17135 57093 : int _end_lineno = _token->end_lineno;
17136 : UNUSED(_end_lineno); // Only used by EXTRA macro
17137 57093 : int _end_col_offset = _token->end_col_offset;
17138 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17139 57093 : _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA );
17140 57093 : if (_res == NULL && PyErr_Occurred()) {
17141 0 : p->error_indicator = 1;
17142 0 : p->level--;
17143 0 : return NULL;
17144 : }
17145 57093 : goto done;
17146 : }
17147 1869100 : p->mark = _mark;
17148 1869100 : 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 1869100 : _res = NULL;
17152 4151020 : done:
17153 4151020 : p->level--;
17154 4151020 : return _res;
17155 : }
17156 :
17157 : // star_targets_list_seq: ','.star_target+ ','?
17158 : static asdl_expr_seq*
17159 42800 : star_targets_list_seq_rule(Parser *p)
17160 : {
17161 42800 : if (p->level++ == MAXSTACK) {
17162 0 : p->error_indicator = 1;
17163 0 : PyErr_NoMemory();
17164 : }
17165 42800 : if (p->error_indicator) {
17166 0 : p->level--;
17167 0 : return NULL;
17168 : }
17169 42800 : asdl_expr_seq* _res = NULL;
17170 42800 : int _mark = p->mark;
17171 : { // ','.star_target+ ','?
17172 42800 : if (p->error_indicator) {
17173 0 : p->level--;
17174 0 : return NULL;
17175 : }
17176 42800 : 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 42800 : if (
17181 42800 : (a = (asdl_expr_seq*)_gather_129_rule(p)) // ','.star_target+
17182 12171 : &&
17183 12171 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
17184 : )
17185 : {
17186 12171 : D(fprintf(stderr, "%*c+ star_targets_list_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?"));
17187 12171 : _res = a;
17188 12171 : if (_res == NULL && PyErr_Occurred()) {
17189 0 : p->error_indicator = 1;
17190 0 : p->level--;
17191 0 : return NULL;
17192 : }
17193 12171 : goto done;
17194 : }
17195 30629 : p->mark = _mark;
17196 30629 : 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 30629 : _res = NULL;
17200 42800 : done:
17201 42800 : p->level--;
17202 42800 : return _res;
17203 : }
17204 :
17205 : // star_targets_tuple_seq: star_target ((',' star_target))+ ','? | star_target ','
17206 : static asdl_expr_seq*
17207 31707 : star_targets_tuple_seq_rule(Parser *p)
17208 : {
17209 31707 : if (p->level++ == MAXSTACK) {
17210 0 : p->error_indicator = 1;
17211 0 : PyErr_NoMemory();
17212 : }
17213 31707 : if (p->error_indicator) {
17214 0 : p->level--;
17215 0 : return NULL;
17216 : }
17217 31707 : asdl_expr_seq* _res = NULL;
17218 31707 : int _mark = p->mark;
17219 : { // star_target ((',' star_target))+ ','?
17220 31707 : if (p->error_indicator) {
17221 0 : p->level--;
17222 0 : return NULL;
17223 : }
17224 31707 : 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 31707 : if (
17230 31707 : (a = star_target_rule(p)) // star_target
17231 16570 : &&
17232 16570 : (b = _loop1_131_rule(p)) // ((',' star_target))+
17233 7626 : &&
17234 7626 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
17235 : )
17236 : {
17237 7626 : D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?"));
17238 7626 : _res = ( asdl_expr_seq* ) _PyPegen_seq_insert_in_front ( p , a , b );
17239 7626 : if (_res == NULL && PyErr_Occurred()) {
17240 0 : p->error_indicator = 1;
17241 0 : p->level--;
17242 0 : return NULL;
17243 : }
17244 7626 : goto done;
17245 : }
17246 24081 : p->mark = _mark;
17247 24081 : 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 24081 : if (p->error_indicator) {
17252 0 : p->level--;
17253 0 : return NULL;
17254 : }
17255 24081 : 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 24081 : if (
17259 24081 : (a = star_target_rule(p)) // star_target
17260 8944 : &&
17261 8944 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
17262 : )
17263 : {
17264 1878 : D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ','"));
17265 1878 : _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a );
17266 1878 : if (_res == NULL && PyErr_Occurred()) {
17267 0 : p->error_indicator = 1;
17268 0 : p->level--;
17269 0 : return NULL;
17270 : }
17271 1878 : goto done;
17272 : }
17273 22203 : p->mark = _mark;
17274 22203 : 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 22203 : _res = NULL;
17278 31707 : done:
17279 31707 : p->level--;
17280 31707 : return _res;
17281 : }
17282 :
17283 : // star_target: '*' (!'*' star_target) | target_with_star_atom
17284 : static expr_ty
17285 6296950 : star_target_rule(Parser *p)
17286 : {
17287 6296950 : if (p->level++ == MAXSTACK) {
17288 0 : p->error_indicator = 1;
17289 0 : PyErr_NoMemory();
17290 : }
17291 6296950 : if (p->error_indicator) {
17292 0 : p->level--;
17293 0 : return NULL;
17294 : }
17295 6296950 : expr_ty _res = NULL;
17296 6296950 : if (_PyPegen_is_memoized(p, star_target_type, &_res)) {
17297 1985490 : p->level--;
17298 1985490 : return _res;
17299 : }
17300 4311460 : int _mark = p->mark;
17301 4311460 : 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 4311460 : int _start_lineno = p->tokens[_mark]->lineno;
17307 : UNUSED(_start_lineno); // Only used by EXTRA macro
17308 4311460 : int _start_col_offset = p->tokens[_mark]->col_offset;
17309 : UNUSED(_start_col_offset); // Only used by EXTRA macro
17310 : { // '*' (!'*' star_target)
17311 4311460 : if (p->error_indicator) {
17312 0 : p->level--;
17313 0 : return NULL;
17314 : }
17315 4311460 : D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
17316 : Token * _literal;
17317 : void *a;
17318 4311460 : if (
17319 4311460 : (_literal = _PyPegen_expect_token(p, 16)) // token='*'
17320 735 : &&
17321 735 : (a = _tmp_132_rule(p)) // !'*' star_target
17322 : )
17323 : {
17324 699 : D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
17325 699 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17326 699 : if (_token == NULL) {
17327 0 : p->level--;
17328 0 : return NULL;
17329 : }
17330 699 : int _end_lineno = _token->end_lineno;
17331 : UNUSED(_end_lineno); // Only used by EXTRA macro
17332 699 : int _end_col_offset = _token->end_col_offset;
17333 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17334 699 : _res = _PyAST_Starred ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA );
17335 699 : if (_res == NULL && PyErr_Occurred()) {
17336 0 : p->error_indicator = 1;
17337 0 : p->level--;
17338 0 : return NULL;
17339 : }
17340 699 : goto done;
17341 : }
17342 4310760 : p->mark = _mark;
17343 4310760 : 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 4310760 : if (p->error_indicator) {
17348 0 : p->level--;
17349 0 : return NULL;
17350 : }
17351 4310760 : 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 4310760 : if (
17354 4310760 : (target_with_star_atom_var = target_with_star_atom_rule(p)) // target_with_star_atom
17355 : )
17356 : {
17357 2393250 : D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "target_with_star_atom"));
17358 2393250 : _res = target_with_star_atom_var;
17359 2393250 : goto done;
17360 : }
17361 1917510 : p->mark = _mark;
17362 1917510 : 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 1917510 : _res = NULL;
17366 4311460 : done:
17367 4311460 : _PyPegen_insert_memo(p, _mark, star_target_type, _res);
17368 4311460 : p->level--;
17369 4311460 : 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 4342570 : target_with_star_atom_rule(Parser *p)
17378 : {
17379 4342570 : if (p->level++ == MAXSTACK) {
17380 0 : p->error_indicator = 1;
17381 0 : PyErr_NoMemory();
17382 : }
17383 4342570 : if (p->error_indicator) {
17384 0 : p->level--;
17385 0 : return NULL;
17386 : }
17387 4342570 : expr_ty _res = NULL;
17388 4342570 : if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) {
17389 31564 : p->level--;
17390 31564 : return _res;
17391 : }
17392 4311000 : int _mark = p->mark;
17393 4311000 : 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 4311000 : int _start_lineno = p->tokens[_mark]->lineno;
17399 : UNUSED(_start_lineno); // Only used by EXTRA macro
17400 4311000 : 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 4311000 : if (p->error_indicator) {
17404 0 : p->level--;
17405 0 : return NULL;
17406 : }
17407 4311000 : 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 4311000 : if (
17412 4311000 : (a = t_primary_rule(p)) // t_primary
17413 1163050 : &&
17414 1163050 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
17415 217608 : &&
17416 217608 : (b = _PyPegen_name_token(p)) // NAME
17417 217600 : &&
17418 217600 : _PyPegen_lookahead(0, t_lookahead_rule, p)
17419 : )
17420 : {
17421 217600 : D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
17422 217600 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17423 217600 : if (_token == NULL) {
17424 0 : p->level--;
17425 0 : return NULL;
17426 : }
17427 217600 : int _end_lineno = _token->end_lineno;
17428 : UNUSED(_end_lineno); // Only used by EXTRA macro
17429 217600 : int _end_col_offset = _token->end_col_offset;
17430 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17431 217600 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA );
17432 217600 : if (_res == NULL && PyErr_Occurred()) {
17433 0 : p->error_indicator = 1;
17434 0 : p->level--;
17435 0 : return NULL;
17436 : }
17437 217600 : goto done;
17438 : }
17439 4093400 : p->mark = _mark;
17440 4093400 : 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 4093400 : if (p->error_indicator) {
17445 20 : p->level--;
17446 20 : return NULL;
17447 : }
17448 4093380 : 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 4093380 : if (
17454 4093380 : (a = t_primary_rule(p)) // t_primary
17455 945450 : &&
17456 945450 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
17457 75995 : &&
17458 75995 : (b = slices_rule(p)) // slices
17459 75978 : &&
17460 75978 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
17461 75963 : &&
17462 75963 : _PyPegen_lookahead(0, t_lookahead_rule, p)
17463 : )
17464 : {
17465 75963 : D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
17466 75963 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17467 75963 : if (_token == NULL) {
17468 0 : p->level--;
17469 0 : return NULL;
17470 : }
17471 75963 : int _end_lineno = _token->end_lineno;
17472 : UNUSED(_end_lineno); // Only used by EXTRA macro
17473 75963 : int _end_col_offset = _token->end_col_offset;
17474 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17475 75963 : _res = _PyAST_Subscript ( a , b , Store , EXTRA );
17476 75963 : if (_res == NULL && PyErr_Occurred()) {
17477 0 : p->error_indicator = 1;
17478 0 : p->level--;
17479 0 : return NULL;
17480 : }
17481 75963 : goto done;
17482 : }
17483 4017420 : p->mark = _mark;
17484 4017420 : 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 4017420 : if (p->error_indicator) {
17489 0 : p->level--;
17490 0 : return NULL;
17491 : }
17492 4017420 : 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 4017420 : if (
17495 4017420 : (star_atom_var = star_atom_rule(p)) // star_atom
17496 : )
17497 : {
17498 2099790 : D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_atom"));
17499 2099790 : _res = star_atom_var;
17500 2099790 : goto done;
17501 : }
17502 1917630 : p->mark = _mark;
17503 1917630 : 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 1917630 : _res = NULL;
17507 4310980 : done:
17508 4310980 : _PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res);
17509 4310980 : p->level--;
17510 4310980 : 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 4017420 : star_atom_rule(Parser *p)
17520 : {
17521 4017420 : if (p->level++ == MAXSTACK) {
17522 0 : p->error_indicator = 1;
17523 0 : PyErr_NoMemory();
17524 : }
17525 4017420 : if (p->error_indicator) {
17526 0 : p->level--;
17527 0 : return NULL;
17528 : }
17529 4017420 : expr_ty _res = NULL;
17530 4017420 : int _mark = p->mark;
17531 4017420 : 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 4017420 : int _start_lineno = p->tokens[_mark]->lineno;
17537 : UNUSED(_start_lineno); // Only used by EXTRA macro
17538 4017420 : int _start_col_offset = p->tokens[_mark]->col_offset;
17539 : UNUSED(_start_col_offset); // Only used by EXTRA macro
17540 : { // NAME
17541 4017420 : if (p->error_indicator) {
17542 0 : p->level--;
17543 0 : return NULL;
17544 : }
17545 4017420 : D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
17546 : expr_ty a;
17547 4017420 : if (
17548 4017420 : (a = _PyPegen_name_token(p)) // NAME
17549 : )
17550 : {
17551 2068960 : D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
17552 2068960 : _res = _PyPegen_set_expr_context ( p , a , Store );
17553 2068960 : if (_res == NULL && PyErr_Occurred()) {
17554 0 : p->error_indicator = 1;
17555 0 : p->level--;
17556 0 : return NULL;
17557 : }
17558 2068960 : goto done;
17559 : }
17560 1948460 : p->mark = _mark;
17561 1948460 : 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 1948460 : if (p->error_indicator) {
17566 0 : p->level--;
17567 0 : return NULL;
17568 : }
17569 1948460 : 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 1948460 : if (
17574 1948460 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
17575 31807 : &&
17576 31807 : (a = target_with_star_atom_rule(p)) // target_with_star_atom
17577 16527 : &&
17578 16527 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
17579 : )
17580 : {
17581 100 : D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'"));
17582 100 : _res = _PyPegen_set_expr_context ( p , a , Store );
17583 100 : if (_res == NULL && PyErr_Occurred()) {
17584 0 : p->error_indicator = 1;
17585 0 : p->level--;
17586 0 : return NULL;
17587 : }
17588 100 : goto done;
17589 : }
17590 1948360 : p->mark = _mark;
17591 1948360 : 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 1948360 : if (p->error_indicator) {
17596 0 : p->level--;
17597 0 : return NULL;
17598 : }
17599 1948360 : 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 1948360 : if (
17604 1948360 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
17605 31707 : &&
17606 31707 : (a = star_targets_tuple_seq_rule(p), !p->error_indicator) // star_targets_tuple_seq?
17607 31707 : &&
17608 31707 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
17609 : )
17610 : {
17611 10440 : D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
17612 10440 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17613 10440 : if (_token == NULL) {
17614 0 : p->level--;
17615 0 : return NULL;
17616 : }
17617 10440 : int _end_lineno = _token->end_lineno;
17618 : UNUSED(_end_lineno); // Only used by EXTRA macro
17619 10440 : int _end_col_offset = _token->end_col_offset;
17620 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17621 10440 : _res = _PyAST_Tuple ( a , Store , EXTRA );
17622 10440 : if (_res == NULL && PyErr_Occurred()) {
17623 0 : p->error_indicator = 1;
17624 0 : p->level--;
17625 0 : return NULL;
17626 : }
17627 10440 : goto done;
17628 : }
17629 1937920 : p->mark = _mark;
17630 1937920 : 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 1937920 : if (p->error_indicator) {
17635 0 : p->level--;
17636 0 : return NULL;
17637 : }
17638 1937920 : 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 1937920 : if (
17643 1937920 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
17644 42800 : &&
17645 42800 : (a = star_targets_list_seq_rule(p), !p->error_indicator) // star_targets_list_seq?
17646 42800 : &&
17647 42800 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
17648 : )
17649 : {
17650 20287 : D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'"));
17651 20287 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17652 20287 : if (_token == NULL) {
17653 0 : p->level--;
17654 0 : return NULL;
17655 : }
17656 20287 : int _end_lineno = _token->end_lineno;
17657 : UNUSED(_end_lineno); // Only used by EXTRA macro
17658 20287 : int _end_col_offset = _token->end_col_offset;
17659 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17660 20287 : _res = _PyAST_List ( a , Store , EXTRA );
17661 20287 : if (_res == NULL && PyErr_Occurred()) {
17662 0 : p->error_indicator = 1;
17663 0 : p->level--;
17664 0 : return NULL;
17665 : }
17666 20287 : goto done;
17667 : }
17668 1917630 : p->mark = _mark;
17669 1917630 : 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 1917630 : _res = NULL;
17673 4017420 : done:
17674 4017420 : p->level--;
17675 4017420 : return _res;
17676 : }
17677 :
17678 : // single_target: single_subscript_attribute_target | NAME | '(' single_target ')'
17679 : static expr_ty
17680 2413360 : single_target_rule(Parser *p)
17681 : {
17682 2413360 : if (p->level++ == MAXSTACK) {
17683 0 : p->error_indicator = 1;
17684 0 : PyErr_NoMemory();
17685 : }
17686 2413360 : if (p->error_indicator) {
17687 0 : p->level--;
17688 0 : return NULL;
17689 : }
17690 2413360 : expr_ty _res = NULL;
17691 2413360 : int _mark = p->mark;
17692 : { // single_subscript_attribute_target
17693 2413360 : if (p->error_indicator) {
17694 0 : p->level--;
17695 0 : return NULL;
17696 : }
17697 2413360 : 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 2413360 : if (
17700 2413360 : (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target
17701 : )
17702 : {
17703 8857 : D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
17704 8857 : _res = single_subscript_attribute_target_var;
17705 8857 : goto done;
17706 : }
17707 2404510 : p->mark = _mark;
17708 2404510 : 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 2404510 : if (p->error_indicator) {
17713 8 : p->level--;
17714 8 : return NULL;
17715 : }
17716 2404500 : D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
17717 : expr_ty a;
17718 2404500 : if (
17719 2404500 : (a = _PyPegen_name_token(p)) // NAME
17720 : )
17721 : {
17722 757011 : D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
17723 757011 : _res = _PyPegen_set_expr_context ( p , a , Store );
17724 757011 : if (_res == NULL && PyErr_Occurred()) {
17725 0 : p->error_indicator = 1;
17726 0 : p->level--;
17727 0 : return NULL;
17728 : }
17729 757011 : goto done;
17730 : }
17731 1647490 : p->mark = _mark;
17732 1647490 : 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 1647490 : if (p->error_indicator) {
17737 0 : p->level--;
17738 0 : return NULL;
17739 : }
17740 1647490 : 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 1647490 : if (
17745 1647490 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
17746 480 : &&
17747 480 : (a = single_target_rule(p)) // single_target
17748 351 : &&
17749 351 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
17750 : )
17751 : {
17752 18 : D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
17753 18 : _res = a;
17754 18 : if (_res == NULL && PyErr_Occurred()) {
17755 0 : p->error_indicator = 1;
17756 0 : p->level--;
17757 0 : return NULL;
17758 : }
17759 18 : goto done;
17760 : }
17761 1647470 : p->mark = _mark;
17762 1647470 : 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 1647470 : _res = NULL;
17766 2413360 : done:
17767 2413360 : p->level--;
17768 2413360 : 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 5634280 : single_subscript_attribute_target_rule(Parser *p)
17776 : {
17777 5634280 : if (p->level++ == MAXSTACK) {
17778 0 : p->error_indicator = 1;
17779 0 : PyErr_NoMemory();
17780 : }
17781 5634280 : if (p->error_indicator) {
17782 0 : p->level--;
17783 0 : return NULL;
17784 : }
17785 5634280 : expr_ty _res = NULL;
17786 5634280 : int _mark = p->mark;
17787 5634280 : 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 5634270 : int _start_lineno = p->tokens[_mark]->lineno;
17793 : UNUSED(_start_lineno); // Only used by EXTRA macro
17794 5634270 : 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 5634270 : if (p->error_indicator) {
17798 0 : p->level--;
17799 0 : return NULL;
17800 : }
17801 5634270 : 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 5634270 : if (
17806 5634270 : (a = t_primary_rule(p)) // t_primary
17807 1251520 : &&
17808 1251520 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
17809 149422 : &&
17810 149422 : (b = _PyPegen_name_token(p)) // NAME
17811 149406 : &&
17812 149406 : _PyPegen_lookahead(0, t_lookahead_rule, p)
17813 : )
17814 : {
17815 149406 : D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
17816 149406 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17817 149406 : if (_token == NULL) {
17818 0 : p->level--;
17819 0 : return NULL;
17820 : }
17821 149406 : int _end_lineno = _token->end_lineno;
17822 : UNUSED(_end_lineno); // Only used by EXTRA macro
17823 149406 : int _end_col_offset = _token->end_col_offset;
17824 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17825 149406 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA );
17826 149406 : if (_res == NULL && PyErr_Occurred()) {
17827 0 : p->error_indicator = 1;
17828 0 : p->level--;
17829 0 : return NULL;
17830 : }
17831 149406 : goto done;
17832 : }
17833 5484870 : p->mark = _mark;
17834 5484870 : 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 5484870 : if (p->error_indicator) {
17839 219 : p->level--;
17840 219 : return NULL;
17841 : }
17842 5484650 : 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 5484650 : if (
17848 5484650 : (a = t_primary_rule(p)) // t_primary
17849 1102110 : &&
17850 1102110 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
17851 38416 : &&
17852 38416 : (b = slices_rule(p)) // slices
17853 38382 : &&
17854 38382 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
17855 38352 : &&
17856 38352 : _PyPegen_lookahead(0, t_lookahead_rule, p)
17857 : )
17858 : {
17859 38352 : D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
17860 38352 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17861 38352 : if (_token == NULL) {
17862 0 : p->level--;
17863 0 : return NULL;
17864 : }
17865 38352 : int _end_lineno = _token->end_lineno;
17866 : UNUSED(_end_lineno); // Only used by EXTRA macro
17867 38352 : int _end_col_offset = _token->end_col_offset;
17868 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17869 38352 : _res = _PyAST_Subscript ( a , b , Store , EXTRA );
17870 38352 : if (_res == NULL && PyErr_Occurred()) {
17871 0 : p->error_indicator = 1;
17872 0 : p->level--;
17873 0 : return NULL;
17874 : }
17875 38352 : goto done;
17876 : }
17877 5446300 : p->mark = _mark;
17878 5446300 : 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 5446300 : _res = NULL;
17882 5634060 : done:
17883 5634060 : p->level--;
17884 5634060 : 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 44542100 : t_primary_rule(Parser *p)
17897 : {
17898 44542100 : if (p->level++ == MAXSTACK) {
17899 0 : p->error_indicator = 1;
17900 0 : PyErr_NoMemory();
17901 : }
17902 44542100 : expr_ty _res = NULL;
17903 44542100 : if (_PyPegen_is_memoized(p, t_primary_type, &_res)) {
17904 40218000 : p->level--;
17905 40218000 : return _res;
17906 : }
17907 4324100 : int _mark = p->mark;
17908 4324100 : int _resmark = p->mark;
17909 2884740 : while (1) {
17910 7208840 : int tmpvar_9 = _PyPegen_update_memo(p, _mark, t_primary_type, _res);
17911 7208840 : if (tmpvar_9) {
17912 0 : p->level--;
17913 0 : return _res;
17914 : }
17915 7208840 : p->mark = _mark;
17916 7208840 : void *_raw = t_primary_raw(p);
17917 7208840 : if (p->error_indicator) {
17918 240 : p->level--;
17919 240 : return NULL;
17920 : }
17921 7208600 : if (_raw == NULL || p->mark <= _resmark)
17922 : break;
17923 2884740 : _resmark = p->mark;
17924 2884740 : _res = _raw;
17925 : }
17926 4323860 : p->mark = _resmark;
17927 4323860 : p->level--;
17928 4323860 : return _res;
17929 : }
17930 : static expr_ty
17931 7208840 : t_primary_raw(Parser *p)
17932 : {
17933 7208840 : if (p->level++ == MAXSTACK) {
17934 0 : p->error_indicator = 1;
17935 0 : PyErr_NoMemory();
17936 : }
17937 7208840 : if (p->error_indicator) {
17938 0 : p->level--;
17939 0 : return NULL;
17940 : }
17941 7208840 : expr_ty _res = NULL;
17942 7208840 : int _mark = p->mark;
17943 7208840 : 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 7208840 : int _start_lineno = p->tokens[_mark]->lineno;
17949 : UNUSED(_start_lineno); // Only used by EXTRA macro
17950 7208840 : 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 7208840 : if (p->error_indicator) {
17954 0 : p->level--;
17955 0 : return NULL;
17956 : }
17957 7208840 : 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 7208840 : if (
17962 7208840 : (a = t_primary_rule(p)) // t_primary
17963 2884740 : &&
17964 2884740 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
17965 1290940 : &&
17966 1290940 : (b = _PyPegen_name_token(p)) // NAME
17967 1290930 : &&
17968 1290930 : _PyPegen_lookahead(1, t_lookahead_rule, p)
17969 : )
17970 : {
17971 1069970 : D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
17972 1069970 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17973 1069970 : if (_token == NULL) {
17974 0 : p->level--;
17975 0 : return NULL;
17976 : }
17977 1069970 : int _end_lineno = _token->end_lineno;
17978 : UNUSED(_end_lineno); // Only used by EXTRA macro
17979 1069970 : int _end_col_offset = _token->end_col_offset;
17980 : UNUSED(_end_col_offset); // Only used by EXTRA macro
17981 1069970 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA );
17982 1069970 : if (_res == NULL && PyErr_Occurred()) {
17983 0 : p->error_indicator = 1;
17984 0 : p->level--;
17985 0 : return NULL;
17986 : }
17987 1069970 : goto done;
17988 : }
17989 6138870 : p->mark = _mark;
17990 6138870 : 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 6138870 : if (p->error_indicator) {
17995 2 : p->level--;
17996 2 : return NULL;
17997 : }
17998 6138860 : 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 6138860 : if (
18004 6138860 : (a = t_primary_rule(p)) // t_primary
18005 1814760 : &&
18006 1814760 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
18007 394235 : &&
18008 394235 : (b = slices_rule(p)) // slices
18009 394198 : &&
18010 394198 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
18011 394177 : &&
18012 394177 : _PyPegen_lookahead(1, t_lookahead_rule, p)
18013 : )
18014 : {
18015 313390 : D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
18016 313390 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18017 313390 : if (_token == NULL) {
18018 0 : p->level--;
18019 0 : return NULL;
18020 : }
18021 313390 : int _end_lineno = _token->end_lineno;
18022 : UNUSED(_end_lineno); // Only used by EXTRA macro
18023 313390 : int _end_col_offset = _token->end_col_offset;
18024 : UNUSED(_end_col_offset); // Only used by EXTRA macro
18025 313390 : _res = _PyAST_Subscript ( a , b , Load , EXTRA );
18026 313390 : if (_res == NULL && PyErr_Occurred()) {
18027 0 : p->error_indicator = 1;
18028 0 : p->level--;
18029 0 : return NULL;
18030 : }
18031 313390 : goto done;
18032 : }
18033 5825480 : p->mark = _mark;
18034 5825480 : 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 5825480 : if (p->error_indicator) {
18039 16 : p->level--;
18040 16 : return NULL;
18041 : }
18042 5825460 : 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 5825460 : if (
18046 5825460 : (a = t_primary_rule(p)) // t_primary
18047 1501350 : &&
18048 1501350 : (b = genexp_rule(p)) // genexp
18049 2947 : &&
18050 2947 : _PyPegen_lookahead(1, t_lookahead_rule, p)
18051 : )
18052 : {
18053 28 : 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 5825430 : p->mark = _mark;
18072 5825430 : 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 5825430 : if (p->error_indicator) {
18077 33 : p->level--;
18078 33 : return NULL;
18079 : }
18080 5825400 : 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 5825400 : if (
18086 5825400 : (a = t_primary_rule(p)) // t_primary
18087 1501290 : &&
18088 1501290 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
18089 1199500 : &&
18090 1199500 : (b = arguments_rule(p), !p->error_indicator) // arguments?
18091 1199450 : &&
18092 1199450 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
18093 1196460 : &&
18094 1196460 : _PyPegen_lookahead(1, t_lookahead_rule, p)
18095 : )
18096 : {
18097 329991 : D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
18098 329991 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18099 329991 : if (_token == NULL) {
18100 0 : p->level--;
18101 0 : return NULL;
18102 : }
18103 329991 : int _end_lineno = _token->end_lineno;
18104 : UNUSED(_end_lineno); // Only used by EXTRA macro
18105 329991 : int _end_col_offset = _token->end_col_offset;
18106 : UNUSED(_end_col_offset); // Only used by EXTRA macro
18107 329991 : _res = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
18108 329991 : if (_res == NULL && PyErr_Occurred()) {
18109 0 : p->error_indicator = 1;
18110 0 : p->level--;
18111 0 : return NULL;
18112 : }
18113 329991 : goto done;
18114 : }
18115 5495410 : p->mark = _mark;
18116 5495410 : 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 5495410 : if (p->error_indicator) {
18121 45 : p->level--;
18122 45 : return NULL;
18123 : }
18124 5495360 : D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead"));
18125 : expr_ty a;
18126 5495360 : if (
18127 5495360 : (a = atom_rule(p)) // atom
18128 3944190 : &&
18129 3944190 : _PyPegen_lookahead(1, t_lookahead_rule, p)
18130 : )
18131 : {
18132 2342610 : D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead"));
18133 2342610 : _res = a;
18134 2342610 : if (_res == NULL && PyErr_Occurred()) {
18135 0 : p->error_indicator = 1;
18136 0 : p->level--;
18137 0 : return NULL;
18138 : }
18139 2342610 : goto done;
18140 : }
18141 3152750 : p->mark = _mark;
18142 3152750 : 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 3152750 : _res = NULL;
18146 7208740 : done:
18147 7208740 : p->level--;
18148 7208740 : return _res;
18149 : }
18150 :
18151 : // t_lookahead: '(' | '[' | '.'
18152 : static void *
18153 7316250 : t_lookahead_rule(Parser *p)
18154 : {
18155 7316250 : if (p->level++ == MAXSTACK) {
18156 0 : p->error_indicator = 1;
18157 0 : PyErr_NoMemory();
18158 : }
18159 7316250 : if (p->error_indicator) {
18160 0 : p->level--;
18161 0 : return NULL;
18162 : }
18163 7316250 : void * _res = NULL;
18164 7316250 : int _mark = p->mark;
18165 : { // '('
18166 7316250 : if (p->error_indicator) {
18167 0 : p->level--;
18168 0 : return NULL;
18169 : }
18170 7316250 : D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
18171 : Token * _literal;
18172 7316250 : if (
18173 7316250 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
18174 : )
18175 : {
18176 1441830 : D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
18177 1441830 : _res = _literal;
18178 1441830 : goto done;
18179 : }
18180 5874420 : p->mark = _mark;
18181 5874420 : 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 5874420 : if (p->error_indicator) {
18186 7 : p->level--;
18187 7 : return NULL;
18188 : }
18189 5874410 : D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
18190 : Token * _literal;
18191 5874410 : if (
18192 5874410 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
18193 : )
18194 : {
18195 455087 : D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
18196 455087 : _res = _literal;
18197 455087 : goto done;
18198 : }
18199 5419320 : p->mark = _mark;
18200 5419320 : 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 5419320 : if (p->error_indicator) {
18205 0 : p->level--;
18206 0 : return NULL;
18207 : }
18208 5419320 : D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
18209 : Token * _literal;
18210 5419320 : if (
18211 5419320 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
18212 : )
18213 : {
18214 2159080 : D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
18215 2159080 : _res = _literal;
18216 2159080 : goto done;
18217 : }
18218 3260250 : p->mark = _mark;
18219 3260250 : D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',
18220 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
18221 : }
18222 3260250 : _res = NULL;
18223 7316240 : done:
18224 7316240 : p->level--;
18225 7316240 : return _res;
18226 : }
18227 :
18228 : // del_targets: ','.del_target+ ','?
18229 : static asdl_expr_seq*
18230 9065 : del_targets_rule(Parser *p)
18231 : {
18232 9065 : if (p->level++ == MAXSTACK) {
18233 0 : p->error_indicator = 1;
18234 0 : PyErr_NoMemory();
18235 : }
18236 9065 : if (p->error_indicator) {
18237 0 : p->level--;
18238 0 : return NULL;
18239 : }
18240 9065 : asdl_expr_seq* _res = NULL;
18241 9065 : int _mark = p->mark;
18242 : { // ','.del_target+ ','?
18243 9065 : if (p->error_indicator) {
18244 0 : p->level--;
18245 0 : return NULL;
18246 : }
18247 9065 : 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 9065 : if (
18252 9065 : (a = (asdl_expr_seq*)_gather_133_rule(p)) // ','.del_target+
18253 8999 : &&
18254 8999 : (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
18255 : )
18256 : {
18257 8999 : D(fprintf(stderr, "%*c+ del_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?"));
18258 8999 : _res = a;
18259 8999 : if (_res == NULL && PyErr_Occurred()) {
18260 0 : p->error_indicator = 1;
18261 0 : p->level--;
18262 0 : return NULL;
18263 : }
18264 8999 : goto done;
18265 : }
18266 66 : p->mark = _mark;
18267 66 : 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 9065 : done:
18272 9065 : p->level--;
18273 9065 : 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 10900 : del_target_rule(Parser *p)
18282 : {
18283 10900 : if (p->level++ == MAXSTACK) {
18284 0 : p->error_indicator = 1;
18285 0 : PyErr_NoMemory();
18286 : }
18287 10900 : if (p->error_indicator) {
18288 0 : p->level--;
18289 0 : return NULL;
18290 : }
18291 10900 : expr_ty _res = NULL;
18292 10900 : if (_PyPegen_is_memoized(p, del_target_type, &_res)) {
18293 68 : p->level--;
18294 68 : return _res;
18295 : }
18296 10832 : int _mark = p->mark;
18297 10832 : 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 10832 : int _start_lineno = p->tokens[_mark]->lineno;
18303 : UNUSED(_start_lineno); // Only used by EXTRA macro
18304 10832 : 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 10832 : if (p->error_indicator) {
18308 0 : p->level--;
18309 0 : return NULL;
18310 : }
18311 10832 : 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 10832 : if (
18316 10832 : (a = t_primary_rule(p)) // t_primary
18317 6247 : &&
18318 6247 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
18319 1416 : &&
18320 1416 : (b = _PyPegen_name_token(p)) // NAME
18321 1416 : &&
18322 1416 : _PyPegen_lookahead(0, t_lookahead_rule, p)
18323 : )
18324 : {
18325 1416 : D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
18326 1416 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18327 1416 : if (_token == NULL) {
18328 0 : p->level--;
18329 0 : return NULL;
18330 : }
18331 1416 : int _end_lineno = _token->end_lineno;
18332 : UNUSED(_end_lineno); // Only used by EXTRA macro
18333 1416 : int _end_col_offset = _token->end_col_offset;
18334 : UNUSED(_end_col_offset); // Only used by EXTRA macro
18335 1416 : _res = _PyAST_Attribute ( a , b -> v . Name . id , Del , EXTRA );
18336 1416 : if (_res == NULL && PyErr_Occurred()) {
18337 0 : p->error_indicator = 1;
18338 0 : p->level--;
18339 0 : return NULL;
18340 : }
18341 1416 : goto done;
18342 : }
18343 9416 : p->mark = _mark;
18344 9416 : 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 9416 : if (p->error_indicator) {
18349 1 : p->level--;
18350 1 : return NULL;
18351 : }
18352 9415 : 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 9415 : if (
18358 9415 : (a = t_primary_rule(p)) // t_primary
18359 4831 : &&
18360 4831 : (_literal = _PyPegen_expect_token(p, 9)) // token='['
18361 4815 : &&
18362 4815 : (b = slices_rule(p)) // slices
18363 4811 : &&
18364 4811 : (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
18365 4805 : &&
18366 4805 : _PyPegen_lookahead(0, t_lookahead_rule, p)
18367 : )
18368 : {
18369 4805 : D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
18370 4805 : Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18371 4805 : if (_token == NULL) {
18372 0 : p->level--;
18373 0 : return NULL;
18374 : }
18375 4805 : int _end_lineno = _token->end_lineno;
18376 : UNUSED(_end_lineno); // Only used by EXTRA macro
18377 4805 : int _end_col_offset = _token->end_col_offset;
18378 : UNUSED(_end_col_offset); // Only used by EXTRA macro
18379 4805 : _res = _PyAST_Subscript ( a , b , Del , EXTRA );
18380 4805 : if (_res == NULL && PyErr_Occurred()) {
18381 0 : p->error_indicator = 1;
18382 0 : p->level--;
18383 0 : return NULL;
18384 : }
18385 4805 : goto done;
18386 : }
18387 4610 : p->mark = _mark;
18388 4610 : 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 4610 : if (p->error_indicator) {
18393 0 : p->level--;
18394 0 : return NULL;
18395 : }
18396 4610 : 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 4610 : if (
18399 4610 : (del_t_atom_var = del_t_atom_rule(p)) // del_t_atom
18400 : )
18401 : {
18402 4532 : D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_t_atom"));
18403 4532 : _res = del_t_atom_var;
18404 4532 : goto done;
18405 : }
18406 78 : p->mark = _mark;
18407 78 : 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 10831 : done:
18412 10831 : _PyPegen_insert_memo(p, _mark, del_target_type, _res);
18413 10831 : p->level--;
18414 10831 : return _res;
18415 : }
18416 :
18417 : // del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']'
18418 : static expr_ty
18419 4610 : del_t_atom_rule(Parser *p)
18420 : {
18421 4610 : if (p->level++ == MAXSTACK) {
18422 0 : p->error_indicator = 1;
18423 0 : PyErr_NoMemory();
18424 : }
18425 4610 : if (p->error_indicator) {
18426 0 : p->level--;
18427 0 : return NULL;
18428 : }
18429 4610 : expr_ty _res = NULL;
18430 4610 : int _mark = p->mark;
18431 4610 : 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 4610 : int _start_lineno = p->tokens[_mark]->lineno;
18437 : UNUSED(_start_lineno); // Only used by EXTRA macro
18438 4610 : int _start_col_offset = p->tokens[_mark]->col_offset;
18439 : UNUSED(_start_col_offset); // Only used by EXTRA macro
18440 : { // NAME
18441 4610 : if (p->error_indicator) {
18442 0 : p->level--;
18443 0 : return NULL;
18444 : }
18445 4610 : D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
18446 : expr_ty a;
18447 4610 : if (
18448 4610 : (a = _PyPegen_name_token(p)) // NAME
18449 : )
18450 : {
18451 4471 : D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
18452 4471 : _res = _PyPegen_set_expr_context ( p , a , Del );
18453 4471 : if (_res == NULL && PyErr_Occurred()) {
18454 0 : p->error_indicator = 1;
18455 0 : p->level--;
18456 0 : return NULL;
18457 : }
18458 4471 : goto done;
18459 : }
18460 139 : p->mark = _mark;
18461 139 : 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 139 : 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 10 : 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 129 : 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 129 : 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 42 : 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 87 : 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 87 : 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 9 : 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 78 : 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 4610 : done:
18574 4610 : p->level--;
18575 4610 : 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 0 : 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 18 : 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 1 : 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 17 : 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 17 : 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 2 : 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 15 : 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 15 : 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 2 : 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 13 : 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 13 : 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 1 : 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 12 : 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 12 : 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 1 : 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 11 : 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 11 : 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 3 : 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 8 : 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 8 : 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 5 : 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 3 : 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 342507 : func_type_comment_rule(Parser *p)
18833 : {
18834 342507 : if (p->level++ == MAXSTACK) {
18835 0 : p->error_indicator = 1;
18836 0 : PyErr_NoMemory();
18837 : }
18838 342507 : if (p->error_indicator) {
18839 0 : p->level--;
18840 0 : return NULL;
18841 : }
18842 342507 : Token* _res = NULL;
18843 342507 : int _mark = p->mark;
18844 : { // NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
18845 342507 : if (p->error_indicator) {
18846 0 : p->level--;
18847 0 : return NULL;
18848 : }
18849 342507 : 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 342507 : if (
18853 342507 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
18854 336442 : &&
18855 336442 : (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
18856 27 : &&
18857 27 : _PyPegen_lookahead(1, _tmp_143_rule, p)
18858 : )
18859 : {
18860 27 : 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 342480 : p->mark = _mark;
18870 342480 : 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 342480 : 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 63 : 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 0 : 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 63 : 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 342480 : if (p->error_indicator) {
18894 9 : p->level--;
18895 9 : return NULL;
18896 : }
18897 342471 : D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT"));
18898 : Token * type_comment_var;
18899 342471 : if (
18900 342471 : (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
18901 : )
18902 : {
18903 34 : 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 342437 : p->mark = _mark;
18908 342437 : 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 342437 : _res = NULL;
18912 342498 : done:
18913 342498 : p->level--;
18914 342498 : 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 0 : 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 94 : 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 1 : 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 93 : 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 93 : 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 10 : 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 83 : 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 82 : 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 0 : 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 82 : 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 82 : 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 11 : 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 71 : 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 71 : 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 0 : 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 71 : 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 71 : 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 11 : 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 60 : 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 0 : 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 1130 : 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 4 : 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 1126 : 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 1126 : 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 1 : 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 1125 : 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 1125 : 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 9 : 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 1116 : 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 0 : 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 1161 : 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 0 : 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 1161 : 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 1159 : 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 53 : 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 1106 : 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 1106 : 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 0 : 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 1106 : 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 0 : 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 2674 : 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 126 : 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 2548 : 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 0 : 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 2706 : 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 53 : 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 2653 : 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 2635 : 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 4 : 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 2631 : 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 0 : 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 1333 : 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 3 : 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 1330 : 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 1247 : 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 8 : 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 1239 : 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 1239 : 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 31 : 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 1208 : 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 0 : 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 901 : 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 7 : 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 894 : 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 894 : 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 1 : 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 893 : 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 797 : 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 1 : 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 796 : 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 796 : 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 22 : 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 774 : 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 774 : 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 3 : 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 771 : 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 771 : 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 14 : 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 757 : 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 0 : 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 913 : 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 7 : 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 906 : 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 906 : 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 10 : 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 896 : 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 896 : 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 2 : 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 894 : 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 0 : 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 37 : 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 35 : 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 2 : 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 0 : 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 136 : 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 4 : 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 132 : 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 0 : 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 2906 : 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 5 : 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 2901 : 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 2900 : 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 4 : 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 2896 : 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 2896 : 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 0 : 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 2896 : 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 0 : 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 37 : 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 1 : 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 36 : 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 0 : 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 302 : 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 10 : 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 292 : 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 284 : 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 4 : 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 280 : 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 280 : 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 5 : 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 275 : 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 275 : 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 10 : 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 265 : 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 265 : 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 12 : 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 253 : 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 253 : 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 1 : 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 252 : 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 0 : 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 1775 : 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 5 : 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 1770 : 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 0 : 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 252 : 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 3 : 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 249 : 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 249 : 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 1 : 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 248 : 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 248 : 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 2 : 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 246 : 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 246 : 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 4 : 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 242 : 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 0 : 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 242 : 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 2 : 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 240 : 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 240 : 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 2 : 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 238 : 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 238 : 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 5 : 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 233 : 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 0 : 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 297 : 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 6 : 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 291 : 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 288 : 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 8 : 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 280 : 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 0 : 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 52 : 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 3 : 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 49 : 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 47 : 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 4 : 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 43 : 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 43 : 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 3 : 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 40 : 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 40 : 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 7 : 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 33 : 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 33 : 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 7 : 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 26 : 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 26 : 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 1 : 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 25 : 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 0 : 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 52 : 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 3 : 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 49 : 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 47 : 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 4 : 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 43 : 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 0 : 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 25 : 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 1 : 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 24 : 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 24 : 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 1 : 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 23 : 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 23 : 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 4 : 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 19 : 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 0 : 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 19 : 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 1 : 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 18 : 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 18 : 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 2 : 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 16 : 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 16 : 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 4 : 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 12 : 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 0 : 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 63 : 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 9 : 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 54 : 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 0 : 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 28 : 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 11 : 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 17 : 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 0 : 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 535 : 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 16 : 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 519 : 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 0 : 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 50 : 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 9 : 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 41 : 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 41 : 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 1 : 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 40 : 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 0 : 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 10 : 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 5 : 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 5 : 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 0 : 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 45 : 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 6 : 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 39 : 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 39 : 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 3 : 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 36 : 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 0 : 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 63 : 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 4 : 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 59 : 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 58 : 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 2 : 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 56 : 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 0 : 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 51 : 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 1 : 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 50 : 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 50 : 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 1 : 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 49 : 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 49 : 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 11 : 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 38 : 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 0 : 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 103 : 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 8 : 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 95 : 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 95 : 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 0 : 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 95 : 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 95 : 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 1 : 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 94 : 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 94 : 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 4 : 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 90 : 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 0 : 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 15 : 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 2 : 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 13 : 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 0 : 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 78 : 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 1 : 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 77 : 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 77 : 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 1 : 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 76 : 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 0 : 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 58 : 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 1 : 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 57 : 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 0 : 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 829 : 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 1 : 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 828 : 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 828 : 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 1 : 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 827 : 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 0 : 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 21 : 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 2 : 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 19 : 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 12 : 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 2 : 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 10 : 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 0 : 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 107 : 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 2 : 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 105 : 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 105 : 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 1 : 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 104 : 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 0 : 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 19 : 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 4 : 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 15 : 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 0 : 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 4 : 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 4 : 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 0 : 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 0 : 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 39 : 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 1 : 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 38 : 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 36 : 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 3 : 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 33 : 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 0 : 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 8 : 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 1 : 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 7 : 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 7 : 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 1 : 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 6 : 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 0 : 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 6 : 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 3 : 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 3 : 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 0 : 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 23 : 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 1 : 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 22 : 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 20 : 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 1 : 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 19 : 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 0 : 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 54 : 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 1 : 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 53 : 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 53 : 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 2 : 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 51 : 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 0 : 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 217 : 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 3 : 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 214 : 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 0 : 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 15 : 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 1 : 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 14 : 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 14 : 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 1 : 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 13 : 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 13748 : invalid_double_starred_kvpairs_rule(Parser *p)
23266 : {
23267 13748 : if (p->level++ == MAXSTACK) {
23268 0 : p->error_indicator = 1;
23269 0 : PyErr_NoMemory();
23270 : }
23271 13748 : if (p->error_indicator) {
23272 0 : p->level--;
23273 0 : return NULL;
23274 : }
23275 13748 : void * _res = NULL;
23276 13748 : int _mark = p->mark;
23277 : { // ','.double_starred_kvpair+ ',' invalid_kvpair
23278 13748 : if (p->error_indicator) {
23279 0 : p->level--;
23280 0 : return NULL;
23281 : }
23282 13748 : 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 13748 : if (
23287 13748 : (_gather_215_var = _gather_215_rule(p)) // ','.double_starred_kvpair+
23288 3800 : &&
23289 3800 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
23290 3 : &&
23291 3 : (invalid_kvpair_var = invalid_kvpair_rule(p)) // invalid_kvpair
23292 : )
23293 : {
23294 0 : 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 13748 : p->mark = _mark;
23299 13748 : 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 13748 : if (p->error_indicator) {
23304 3 : p->level--;
23305 3 : return NULL;
23306 : }
23307 13745 : 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 13745 : if (
23313 13745 : (expression_var = expression_rule(p)) // expression
23314 13660 : &&
23315 13660 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23316 3809 : &&
23317 3809 : (a = _PyPegen_expect_token(p, 16)) // token='*'
23318 2 : &&
23319 2 : (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
23320 : )
23321 : {
23322 2 : 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 13743 : p->mark = _mark;
23332 13743 : 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 13743 : if (p->error_indicator) {
23337 0 : p->level--;
23338 0 : return NULL;
23339 : }
23340 13743 : 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 13743 : if (
23344 13743 : (expression_var = expression_rule(p)) // expression
23345 13658 : &&
23346 13658 : (a = _PyPegen_expect_token(p, 11)) // token=':'
23347 3807 : &&
23348 3807 : _PyPegen_lookahead(1, _tmp_217_rule, p)
23349 : )
23350 : {
23351 1 : 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 13742 : p->mark = _mark;
23361 13742 : 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 13742 : _res = NULL;
23365 13742 : done:
23366 13742 : p->level--;
23367 13742 : 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 0 : 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 3 : 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 1 : 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 2 : 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 2 : 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 1 : 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 1 : 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 1 : 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 1 : 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 0 : 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 73421 : _loop0_1_rule(Parser *p)
23484 : {
23485 73421 : if (p->level++ == MAXSTACK) {
23486 0 : p->error_indicator = 1;
23487 0 : PyErr_NoMemory();
23488 : }
23489 73421 : if (p->error_indicator) {
23490 0 : p->level--;
23491 0 : return NULL;
23492 : }
23493 73421 : void *_res = NULL;
23494 73421 : int _mark = p->mark;
23495 73421 : int _start_mark = p->mark;
23496 73421 : void **_children = PyMem_Malloc(sizeof(void *));
23497 73421 : if (!_children) {
23498 0 : p->error_indicator = 1;
23499 0 : PyErr_NoMemory();
23500 0 : p->level--;
23501 0 : return NULL;
23502 : }
23503 73421 : Py_ssize_t _children_capacity = 1;
23504 73421 : Py_ssize_t _n = 0;
23505 : { // NEWLINE
23506 73421 : if (p->error_indicator) {
23507 0 : p->level--;
23508 0 : return NULL;
23509 : }
23510 73421 : D(fprintf(stderr, "%*c> _loop0_1[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
23511 : Token * newline_var;
23512 146858 : while (
23513 73437 : (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 0 : 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 73421 : p->mark = _mark;
23532 73421 : 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 73421 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
23536 73421 : if (!_seq) {
23537 0 : PyMem_Free(_children);
23538 0 : p->error_indicator = 1;
23539 0 : PyErr_NoMemory();
23540 0 : p->level--;
23541 0 : return NULL;
23542 : }
23543 73437 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
23544 73421 : PyMem_Free(_children);
23545 73421 : _PyPegen_insert_memo(p, _start_mark, _loop0_1_type, _seq);
23546 73421 : p->level--;
23547 73421 : 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 0 : 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 0 : 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 12 : D(fprintf(stderr, "%*c> _loop0_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
23580 : Token * newline_var;
23581 24 : 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 0 : 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 12 : 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 0 : 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 1045380 : _loop1_3_rule(Parser *p)
23622 : {
23623 1045380 : if (p->level++ == MAXSTACK) {
23624 0 : p->error_indicator = 1;
23625 0 : PyErr_NoMemory();
23626 : }
23627 1045380 : if (p->error_indicator) {
23628 0 : p->level--;
23629 0 : return NULL;
23630 : }
23631 1045380 : void *_res = NULL;
23632 1045380 : int _mark = p->mark;
23633 1045380 : int _start_mark = p->mark;
23634 1045380 : void **_children = PyMem_Malloc(sizeof(void *));
23635 1045380 : if (!_children) {
23636 0 : p->error_indicator = 1;
23637 0 : PyErr_NoMemory();
23638 0 : p->level--;
23639 0 : return NULL;
23640 : }
23641 1045380 : Py_ssize_t _children_capacity = 1;
23642 1045380 : Py_ssize_t _n = 0;
23643 : { // statement
23644 1045380 : if (p->error_indicator) {
23645 0 : p->level--;
23646 0 : return NULL;
23647 : }
23648 1045380 : D(fprintf(stderr, "%*c> _loop1_3[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement"));
23649 : asdl_stmt_seq* statement_var;
23650 5102760 : while (
23651 4057380 : (statement_var = statement_rule(p)) // statement
23652 : )
23653 : {
23654 3012000 : _res = statement_var;
23655 3012000 : if (_n == _children_capacity) {
23656 920157 : _children_capacity *= 2;
23657 920157 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
23658 920157 : if (!_new_children) {
23659 0 : p->error_indicator = 1;
23660 0 : PyErr_NoMemory();
23661 0 : p->level--;
23662 0 : return NULL;
23663 : }
23664 920157 : _children = _new_children;
23665 : }
23666 3012000 : _children[_n++] = _res;
23667 3012000 : _mark = p->mark;
23668 : }
23669 1045380 : p->mark = _mark;
23670 1045380 : 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 1045380 : if (_n == 0 || p->error_indicator) {
23674 1979 : PyMem_Free(_children);
23675 1979 : p->level--;
23676 1979 : return NULL;
23677 : }
23678 1043400 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
23679 1043400 : if (!_seq) {
23680 0 : PyMem_Free(_children);
23681 0 : p->error_indicator = 1;
23682 0 : PyErr_NoMemory();
23683 0 : p->level--;
23684 0 : return NULL;
23685 : }
23686 4055360 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
23687 1043400 : PyMem_Free(_children);
23688 1043400 : _PyPegen_insert_memo(p, _start_mark, _loop1_3_type, _seq);
23689 1043400 : p->level--;
23690 1043400 : return _seq;
23691 : }
23692 :
23693 : // _loop0_5: ';' simple_stmt
23694 : static asdl_seq *
23695 2679 : _loop0_5_rule(Parser *p)
23696 : {
23697 2679 : if (p->level++ == MAXSTACK) {
23698 0 : p->error_indicator = 1;
23699 0 : PyErr_NoMemory();
23700 : }
23701 2679 : if (p->error_indicator) {
23702 0 : p->level--;
23703 0 : return NULL;
23704 : }
23705 2679 : void *_res = NULL;
23706 2679 : int _mark = p->mark;
23707 2679 : int _start_mark = p->mark;
23708 2679 : void **_children = PyMem_Malloc(sizeof(void *));
23709 2679 : if (!_children) {
23710 0 : p->error_indicator = 1;
23711 0 : PyErr_NoMemory();
23712 0 : p->level--;
23713 0 : return NULL;
23714 : }
23715 2679 : Py_ssize_t _children_capacity = 1;
23716 2679 : Py_ssize_t _n = 0;
23717 : { // ';' simple_stmt
23718 2679 : if (p->error_indicator) {
23719 0 : p->level--;
23720 0 : return NULL;
23721 : }
23722 2679 : 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 12918 : while (
23726 10239 : (_literal = _PyPegen_expect_token(p, 13)) // token=';'
23727 7693 : &&
23728 7693 : (elem = simple_stmt_rule(p)) // simple_stmt
23729 : )
23730 : {
23731 7560 : _res = elem;
23732 7560 : 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 7560 : if (_n == _children_capacity) {
23739 996 : _children_capacity *= 2;
23740 996 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
23741 996 : if (!_new_children) {
23742 0 : p->error_indicator = 1;
23743 0 : PyErr_NoMemory();
23744 0 : p->level--;
23745 0 : return NULL;
23746 : }
23747 996 : _children = _new_children;
23748 : }
23749 7560 : _children[_n++] = _res;
23750 7560 : _mark = p->mark;
23751 : }
23752 2679 : p->mark = _mark;
23753 2679 : 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 2679 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
23757 2679 : if (!_seq) {
23758 0 : PyMem_Free(_children);
23759 0 : p->error_indicator = 1;
23760 0 : PyErr_NoMemory();
23761 0 : p->level--;
23762 0 : return NULL;
23763 : }
23764 10239 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
23765 2679 : PyMem_Free(_children);
23766 2679 : _PyPegen_insert_memo(p, _start_mark, _loop0_5_type, _seq);
23767 2679 : p->level--;
23768 2679 : return _seq;
23769 : }
23770 :
23771 : // _gather_4: simple_stmt _loop0_5
23772 : static asdl_seq *
23773 1047930 : _gather_4_rule(Parser *p)
23774 : {
23775 1047930 : if (p->level++ == MAXSTACK) {
23776 0 : p->error_indicator = 1;
23777 0 : PyErr_NoMemory();
23778 : }
23779 1047930 : if (p->error_indicator) {
23780 0 : p->level--;
23781 0 : return NULL;
23782 : }
23783 1047930 : asdl_seq * _res = NULL;
23784 1047930 : int _mark = p->mark;
23785 : { // simple_stmt _loop0_5
23786 1047930 : if (p->error_indicator) {
23787 0 : p->level--;
23788 0 : return NULL;
23789 : }
23790 1047930 : 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 1047930 : if (
23794 1047930 : (elem = simple_stmt_rule(p)) // simple_stmt
23795 2679 : &&
23796 2679 : (seq = _loop0_5_rule(p)) // _loop0_5
23797 : )
23798 : {
23799 2679 : D(fprintf(stderr, "%*c+ _gather_4[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt _loop0_5"));
23800 2679 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
23801 2679 : goto done;
23802 : }
23803 1045250 : p->mark = _mark;
23804 1045250 : 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 1045250 : _res = NULL;
23808 1047930 : done:
23809 1047930 : p->level--;
23810 1047930 : return _res;
23811 : }
23812 :
23813 : // _tmp_6: 'import' | 'from'
23814 : static void *
23815 1280900 : _tmp_6_rule(Parser *p)
23816 : {
23817 1280900 : if (p->level++ == MAXSTACK) {
23818 0 : p->error_indicator = 1;
23819 0 : PyErr_NoMemory();
23820 : }
23821 1280900 : if (p->error_indicator) {
23822 0 : p->level--;
23823 0 : return NULL;
23824 : }
23825 1280900 : void * _res = NULL;
23826 1280900 : int _mark = p->mark;
23827 : { // 'import'
23828 1280900 : if (p->error_indicator) {
23829 0 : p->level--;
23830 0 : return NULL;
23831 : }
23832 1280900 : D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'"));
23833 : Token * _keyword;
23834 1280900 : if (
23835 1280900 : (_keyword = _PyPegen_expect_token(p, 531)) // token='import'
23836 : )
23837 : {
23838 45189 : D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'"));
23839 45189 : _res = _keyword;
23840 45189 : goto done;
23841 : }
23842 1235710 : p->mark = _mark;
23843 1235710 : 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 1235710 : if (p->error_indicator) {
23848 0 : p->level--;
23849 0 : return NULL;
23850 : }
23851 1235710 : D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'"));
23852 : Token * _keyword;
23853 1235710 : if (
23854 1235710 : (_keyword = _PyPegen_expect_token(p, 572)) // token='from'
23855 : )
23856 : {
23857 46171 : D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'"));
23858 46171 : _res = _keyword;
23859 46171 : goto done;
23860 : }
23861 1189540 : p->mark = _mark;
23862 1189540 : 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 1189540 : _res = NULL;
23866 1280900 : done:
23867 1280900 : p->level--;
23868 1280900 : return _res;
23869 : }
23870 :
23871 : // _tmp_7: 'def' | '@' | ASYNC
23872 : static void *
23873 4062440 : _tmp_7_rule(Parser *p)
23874 : {
23875 4062440 : if (p->level++ == MAXSTACK) {
23876 0 : p->error_indicator = 1;
23877 0 : PyErr_NoMemory();
23878 : }
23879 4062440 : if (p->error_indicator) {
23880 0 : p->level--;
23881 0 : return NULL;
23882 : }
23883 4062440 : void * _res = NULL;
23884 4062440 : int _mark = p->mark;
23885 : { // 'def'
23886 4062440 : if (p->error_indicator) {
23887 0 : p->level--;
23888 0 : return NULL;
23889 : }
23890 4062440 : D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'"));
23891 : Token * _keyword;
23892 4062440 : if (
23893 4062440 : (_keyword = _PyPegen_expect_token(p, 644)) // token='def'
23894 : )
23895 : {
23896 308314 : D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'"));
23897 308314 : _res = _keyword;
23898 308314 : goto done;
23899 : }
23900 3754130 : p->mark = _mark;
23901 3754130 : 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 3754130 : if (p->error_indicator) {
23906 78 : p->level--;
23907 78 : return NULL;
23908 : }
23909 3754050 : D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
23910 : Token * _literal;
23911 3754050 : if (
23912 3754050 : (_literal = _PyPegen_expect_token(p, 49)) // token='@'
23913 : )
23914 : {
23915 34525 : D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
23916 34525 : _res = _literal;
23917 34525 : goto done;
23918 : }
23919 3719520 : p->mark = _mark;
23920 3719520 : 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 3719520 : if (p->error_indicator) {
23925 0 : p->level--;
23926 0 : return NULL;
23927 : }
23928 3719520 : D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
23929 : Token * async_var;
23930 3719520 : if (
23931 3719520 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
23932 : )
23933 : {
23934 3742 : D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));
23935 3742 : _res = async_var;
23936 3742 : goto done;
23937 : }
23938 3715780 : p->mark = _mark;
23939 3715780 : 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 3715780 : _res = NULL;
23943 4062360 : done:
23944 4062360 : p->level--;
23945 4062360 : return _res;
23946 : }
23947 :
23948 : // _tmp_8: 'class' | '@'
23949 : static void *
23950 3230730 : _tmp_8_rule(Parser *p)
23951 : {
23952 3230730 : if (p->level++ == MAXSTACK) {
23953 0 : p->error_indicator = 1;
23954 0 : PyErr_NoMemory();
23955 : }
23956 3230730 : if (p->error_indicator) {
23957 0 : p->level--;
23958 0 : return NULL;
23959 : }
23960 3230730 : void * _res = NULL;
23961 3230730 : int _mark = p->mark;
23962 : { // 'class'
23963 3230730 : if (p->error_indicator) {
23964 0 : p->level--;
23965 0 : return NULL;
23966 : }
23967 3230730 : D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'"));
23968 : Token * _keyword;
23969 3230730 : if (
23970 3230730 : (_keyword = _PyPegen_expect_token(p, 646)) // token='class'
23971 : )
23972 : {
23973 53626 : D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'"));
23974 53626 : _res = _keyword;
23975 53626 : goto done;
23976 : }
23977 3177110 : p->mark = _mark;
23978 3177110 : 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 3177110 : if (p->error_indicator) {
23983 0 : p->level--;
23984 0 : return NULL;
23985 : }
23986 3177110 : D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
23987 : Token * _literal;
23988 3177110 : if (
23989 3177110 : (_literal = _PyPegen_expect_token(p, 49)) // token='@'
23990 : )
23991 : {
23992 3185 : D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
23993 3185 : _res = _literal;
23994 3185 : goto done;
23995 : }
23996 3173920 : p->mark = _mark;
23997 3173920 : D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ',
23998 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
23999 : }
24000 3173920 : _res = NULL;
24001 3230730 : done:
24002 3230730 : p->level--;
24003 3230730 : return _res;
24004 : }
24005 :
24006 : // _tmp_9: 'with' | ASYNC
24007 : static void *
24008 3173960 : _tmp_9_rule(Parser *p)
24009 : {
24010 3173960 : if (p->level++ == MAXSTACK) {
24011 0 : p->error_indicator = 1;
24012 0 : PyErr_NoMemory();
24013 : }
24014 3173960 : if (p->error_indicator) {
24015 0 : p->level--;
24016 0 : return NULL;
24017 : }
24018 3173960 : void * _res = NULL;
24019 3173960 : int _mark = p->mark;
24020 : { // 'with'
24021 3173960 : if (p->error_indicator) {
24022 0 : p->level--;
24023 0 : return NULL;
24024 : }
24025 3173960 : D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'"));
24026 : Token * _keyword;
24027 3173960 : if (
24028 3173960 : (_keyword = _PyPegen_expect_token(p, 612)) // token='with'
24029 : )
24030 : {
24031 38639 : D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'"));
24032 38639 : _res = _keyword;
24033 38639 : goto done;
24034 : }
24035 3135320 : p->mark = _mark;
24036 3135320 : 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 3135320 : if (p->error_indicator) {
24041 0 : p->level--;
24042 0 : return NULL;
24043 : }
24044 3135320 : D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
24045 : Token * async_var;
24046 3135320 : if (
24047 3135320 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
24048 : )
24049 : {
24050 650 : 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 3134670 : p->mark = _mark;
24055 3134670 : 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 3134670 : _res = NULL;
24059 3173960 : done:
24060 3173960 : p->level--;
24061 3173960 : return _res;
24062 : }
24063 :
24064 : // _tmp_10: 'for' | ASYNC
24065 : static void *
24066 3134970 : _tmp_10_rule(Parser *p)
24067 : {
24068 3134970 : if (p->level++ == MAXSTACK) {
24069 0 : p->error_indicator = 1;
24070 0 : PyErr_NoMemory();
24071 : }
24072 3134970 : if (p->error_indicator) {
24073 0 : p->level--;
24074 0 : return NULL;
24075 : }
24076 3134970 : void * _res = NULL;
24077 3134970 : int _mark = p->mark;
24078 : { // 'for'
24079 3134970 : if (p->error_indicator) {
24080 0 : p->level--;
24081 0 : return NULL;
24082 : }
24083 3134970 : D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'"));
24084 : Token * _keyword;
24085 3134970 : if (
24086 3134970 : (_keyword = _PyPegen_expect_token(p, 642)) // token='for'
24087 : )
24088 : {
24089 61502 : D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'"));
24090 61502 : _res = _keyword;
24091 61502 : goto done;
24092 : }
24093 3073470 : p->mark = _mark;
24094 3073470 : 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 3073470 : if (p->error_indicator) {
24099 0 : p->level--;
24100 0 : return NULL;
24101 : }
24102 3073470 : D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
24103 : Token * async_var;
24104 3073470 : if (
24105 3073470 : (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC'
24106 : )
24107 : {
24108 276 : 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 3073200 : p->mark = _mark;
24113 3073200 : 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 3073200 : _res = NULL;
24117 3134970 : done:
24118 3134970 : p->level--;
24119 3134970 : 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 0 : 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 9486 : 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 6022 : &&
24147 6022 : (d = annotated_rhs_rule(p)) // annotated_rhs
24148 : )
24149 : {
24150 6022 : D(fprintf(stderr, "%*c+ _tmp_11[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
24151 6022 : _res = d;
24152 6022 : if (_res == NULL && PyErr_Occurred()) {
24153 0 : p->error_indicator = 1;
24154 0 : p->level--;
24155 0 : return NULL;
24156 : }
24157 6022 : goto done;
24158 : }
24159 3464 : p->mark = _mark;
24160 3464 : 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 3464 : _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 3220940 : _tmp_12_rule(Parser *p)
24172 : {
24173 3220940 : if (p->level++ == MAXSTACK) {
24174 0 : p->error_indicator = 1;
24175 0 : PyErr_NoMemory();
24176 : }
24177 3220940 : if (p->error_indicator) {
24178 0 : p->level--;
24179 0 : return NULL;
24180 : }
24181 3220940 : void * _res = NULL;
24182 3220940 : int _mark = p->mark;
24183 : { // '(' single_target ')'
24184 3220940 : if (p->error_indicator) {
24185 0 : p->level--;
24186 0 : return NULL;
24187 : }
24188 3220940 : 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 3220940 : if (
24193 3220940 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
24194 2080 : &&
24195 2080 : (b = single_target_rule(p)) // single_target
24196 1895 : &&
24197 1895 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
24198 : )
24199 : {
24200 21 : D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
24201 21 : _res = b;
24202 21 : if (_res == NULL && PyErr_Occurred()) {
24203 0 : p->error_indicator = 1;
24204 0 : p->level--;
24205 0 : return NULL;
24206 : }
24207 21 : goto done;
24208 : }
24209 3220920 : p->mark = _mark;
24210 3220920 : 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 3220920 : if (p->error_indicator) {
24215 8 : p->level--;
24216 8 : return NULL;
24217 : }
24218 3220910 : 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 3220910 : if (
24221 3220910 : (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target
24222 : )
24223 : {
24224 178901 : D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
24225 178901 : _res = single_subscript_attribute_target_var;
24226 178901 : goto done;
24227 : }
24228 3042010 : p->mark = _mark;
24229 3042010 : 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 3042010 : _res = NULL;
24233 3220940 : done:
24234 3220940 : p->level--;
24235 3220940 : 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 0 : 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 1969 : 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 1586 : 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 383 : 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 3218750 : _loop1_14_rule(Parser *p)
24288 : {
24289 3218750 : if (p->level++ == MAXSTACK) {
24290 0 : p->error_indicator = 1;
24291 0 : PyErr_NoMemory();
24292 : }
24293 3218750 : if (p->error_indicator) {
24294 0 : p->level--;
24295 0 : return NULL;
24296 : }
24297 3218750 : void *_res = NULL;
24298 3218750 : int _mark = p->mark;
24299 3218750 : int _start_mark = p->mark;
24300 3218750 : void **_children = PyMem_Malloc(sizeof(void *));
24301 3218750 : if (!_children) {
24302 0 : p->error_indicator = 1;
24303 0 : PyErr_NoMemory();
24304 0 : p->level--;
24305 0 : return NULL;
24306 : }
24307 3218750 : Py_ssize_t _children_capacity = 1;
24308 3218750 : Py_ssize_t _n = 0;
24309 : { // (star_targets '=')
24310 3218750 : if (p->error_indicator) {
24311 0 : p->level--;
24312 0 : return NULL;
24313 : }
24314 3218750 : D(fprintf(stderr, "%*c> _loop1_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
24315 : void *_tmp_219_var;
24316 7254580 : while (
24317 4035830 : (_tmp_219_var = _tmp_219_rule(p)) // star_targets '='
24318 : )
24319 : {
24320 817078 : _res = _tmp_219_var;
24321 817078 : if (_n == _children_capacity) {
24322 6462 : _children_capacity *= 2;
24323 6462 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
24324 6462 : if (!_new_children) {
24325 0 : p->error_indicator = 1;
24326 0 : PyErr_NoMemory();
24327 0 : p->level--;
24328 0 : return NULL;
24329 : }
24330 6462 : _children = _new_children;
24331 : }
24332 817078 : _children[_n++] = _res;
24333 817078 : _mark = p->mark;
24334 : }
24335 3218750 : p->mark = _mark;
24336 3218750 : 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 3218750 : if (_n == 0 || p->error_indicator) {
24340 2410820 : PyMem_Free(_children);
24341 2410820 : p->level--;
24342 2410820 : return NULL;
24343 : }
24344 807926 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24345 807926 : if (!_seq) {
24346 0 : PyMem_Free(_children);
24347 0 : p->error_indicator = 1;
24348 0 : PyErr_NoMemory();
24349 0 : p->level--;
24350 0 : return NULL;
24351 : }
24352 1624970 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
24353 807926 : PyMem_Free(_children);
24354 807926 : _PyPegen_insert_memo(p, _start_mark, _loop1_14_type, _seq);
24355 807926 : p->level--;
24356 807926 : return _seq;
24357 : }
24358 :
24359 : // _tmp_15: yield_expr | star_expressions
24360 : static void *
24361 807926 : _tmp_15_rule(Parser *p)
24362 : {
24363 807926 : if (p->level++ == MAXSTACK) {
24364 0 : p->error_indicator = 1;
24365 0 : PyErr_NoMemory();
24366 : }
24367 807926 : if (p->error_indicator) {
24368 0 : p->level--;
24369 0 : return NULL;
24370 : }
24371 807926 : void * _res = NULL;
24372 807926 : int _mark = p->mark;
24373 : { // yield_expr
24374 807926 : if (p->error_indicator) {
24375 0 : p->level--;
24376 0 : return NULL;
24377 : }
24378 807926 : D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
24379 : expr_ty yield_expr_var;
24380 807926 : if (
24381 807926 : (yield_expr_var = yield_expr_rule(p)) // yield_expr
24382 : )
24383 : {
24384 166 : 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 807760 : p->mark = _mark;
24389 807760 : 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 807760 : if (p->error_indicator) {
24394 0 : p->level--;
24395 0 : return NULL;
24396 : }
24397 807760 : D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
24398 : expr_ty star_expressions_var;
24399 807760 : if (
24400 807760 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
24401 : )
24402 : {
24403 807744 : D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
24404 807744 : _res = star_expressions_var;
24405 807744 : goto done;
24406 : }
24407 16 : p->mark = _mark;
24408 16 : 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 807926 : done:
24413 807926 : p->level--;
24414 807926 : return _res;
24415 : }
24416 :
24417 : // _tmp_16: yield_expr | star_expressions
24418 : static void *
24419 25695 : _tmp_16_rule(Parser *p)
24420 : {
24421 25695 : if (p->level++ == MAXSTACK) {
24422 0 : p->error_indicator = 1;
24423 0 : PyErr_NoMemory();
24424 : }
24425 25695 : if (p->error_indicator) {
24426 0 : p->level--;
24427 0 : return NULL;
24428 : }
24429 25695 : void * _res = NULL;
24430 25695 : int _mark = p->mark;
24431 : { // yield_expr
24432 25695 : if (p->error_indicator) {
24433 0 : p->level--;
24434 0 : return NULL;
24435 : }
24436 25695 : D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
24437 : expr_ty yield_expr_var;
24438 25695 : if (
24439 25695 : (yield_expr_var = yield_expr_rule(p)) // yield_expr
24440 : )
24441 : {
24442 2 : 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 25693 : p->mark = _mark;
24447 25693 : 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 25693 : if (p->error_indicator) {
24452 0 : p->level--;
24453 0 : return NULL;
24454 : }
24455 25693 : D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
24456 : expr_ty star_expressions_var;
24457 25693 : if (
24458 25693 : (star_expressions_var = star_expressions_rule(p)) // star_expressions
24459 : )
24460 : {
24461 25693 : D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
24462 25693 : _res = star_expressions_var;
24463 25693 : goto done;
24464 : }
24465 0 : p->mark = _mark;
24466 0 : 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 25695 : done:
24471 25695 : p->level--;
24472 25695 : return _res;
24473 : }
24474 :
24475 : // _tmp_17: 'from' expression
24476 : static void *
24477 56670 : _tmp_17_rule(Parser *p)
24478 : {
24479 56670 : if (p->level++ == MAXSTACK) {
24480 0 : p->error_indicator = 1;
24481 0 : PyErr_NoMemory();
24482 : }
24483 56670 : if (p->error_indicator) {
24484 0 : p->level--;
24485 0 : return NULL;
24486 : }
24487 56670 : void * _res = NULL;
24488 56670 : int _mark = p->mark;
24489 : { // 'from' expression
24490 56670 : if (p->error_indicator) {
24491 0 : p->level--;
24492 0 : return NULL;
24493 : }
24494 56670 : 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 56670 : if (
24498 56670 : (_keyword = _PyPegen_expect_token(p, 572)) // token='from'
24499 2941 : &&
24500 2941 : (z = expression_rule(p)) // expression
24501 : )
24502 : {
24503 2941 : D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' expression"));
24504 2941 : _res = z;
24505 2941 : if (_res == NULL && PyErr_Occurred()) {
24506 0 : p->error_indicator = 1;
24507 0 : p->level--;
24508 0 : return NULL;
24509 : }
24510 2941 : goto done;
24511 : }
24512 53729 : p->mark = _mark;
24513 53729 : 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 53729 : _res = NULL;
24517 56670 : done:
24518 56670 : p->level--;
24519 56670 : return _res;
24520 : }
24521 :
24522 : // _loop0_19: ',' NAME
24523 : static asdl_seq *
24524 1839 : _loop0_19_rule(Parser *p)
24525 : {
24526 1839 : if (p->level++ == MAXSTACK) {
24527 0 : p->error_indicator = 1;
24528 0 : PyErr_NoMemory();
24529 : }
24530 1839 : if (p->error_indicator) {
24531 0 : p->level--;
24532 0 : return NULL;
24533 : }
24534 1839 : void *_res = NULL;
24535 1839 : int _mark = p->mark;
24536 1839 : int _start_mark = p->mark;
24537 1839 : void **_children = PyMem_Malloc(sizeof(void *));
24538 1839 : if (!_children) {
24539 0 : p->error_indicator = 1;
24540 0 : PyErr_NoMemory();
24541 0 : p->level--;
24542 0 : return NULL;
24543 : }
24544 1839 : Py_ssize_t _children_capacity = 1;
24545 1839 : Py_ssize_t _n = 0;
24546 : { // ',' NAME
24547 1839 : if (p->error_indicator) {
24548 0 : p->level--;
24549 0 : return NULL;
24550 : }
24551 1839 : D(fprintf(stderr, "%*c> _loop0_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));
24552 : Token * _literal;
24553 : expr_ty elem;
24554 4240 : while (
24555 2401 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
24556 562 : &&
24557 562 : (elem = _PyPegen_name_token(p)) // NAME
24558 : )
24559 : {
24560 562 : _res = elem;
24561 562 : 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 562 : if (_n == _children_capacity) {
24568 125 : _children_capacity *= 2;
24569 125 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
24570 125 : if (!_new_children) {
24571 0 : p->error_indicator = 1;
24572 0 : PyErr_NoMemory();
24573 0 : p->level--;
24574 0 : return NULL;
24575 : }
24576 125 : _children = _new_children;
24577 : }
24578 562 : _children[_n++] = _res;
24579 562 : _mark = p->mark;
24580 : }
24581 1839 : p->mark = _mark;
24582 1839 : 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 1839 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24586 1839 : if (!_seq) {
24587 0 : PyMem_Free(_children);
24588 0 : p->error_indicator = 1;
24589 0 : PyErr_NoMemory();
24590 0 : p->level--;
24591 0 : return NULL;
24592 : }
24593 2401 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
24594 1839 : PyMem_Free(_children);
24595 1839 : _PyPegen_insert_memo(p, _start_mark, _loop0_19_type, _seq);
24596 1839 : p->level--;
24597 1839 : return _seq;
24598 : }
24599 :
24600 : // _gather_18: NAME _loop0_19
24601 : static asdl_seq *
24602 1841 : _gather_18_rule(Parser *p)
24603 : {
24604 1841 : if (p->level++ == MAXSTACK) {
24605 0 : p->error_indicator = 1;
24606 0 : PyErr_NoMemory();
24607 : }
24608 1841 : if (p->error_indicator) {
24609 0 : p->level--;
24610 0 : return NULL;
24611 : }
24612 1841 : asdl_seq * _res = NULL;
24613 1841 : int _mark = p->mark;
24614 : { // NAME _loop0_19
24615 1841 : if (p->error_indicator) {
24616 0 : p->level--;
24617 0 : return NULL;
24618 : }
24619 1841 : 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 1841 : if (
24623 1841 : (elem = _PyPegen_name_token(p)) // NAME
24624 1839 : &&
24625 1839 : (seq = _loop0_19_rule(p)) // _loop0_19
24626 : )
24627 : {
24628 1839 : D(fprintf(stderr, "%*c+ _gather_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_19"));
24629 1839 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
24630 1839 : goto done;
24631 : }
24632 2 : p->mark = _mark;
24633 2 : 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 1841 : done:
24638 1841 : p->level--;
24639 1841 : return _res;
24640 : }
24641 :
24642 : // _loop0_21: ',' NAME
24643 : static asdl_seq *
24644 927 : _loop0_21_rule(Parser *p)
24645 : {
24646 927 : if (p->level++ == MAXSTACK) {
24647 0 : p->error_indicator = 1;
24648 0 : PyErr_NoMemory();
24649 : }
24650 927 : if (p->error_indicator) {
24651 0 : p->level--;
24652 0 : return NULL;
24653 : }
24654 927 : void *_res = NULL;
24655 927 : int _mark = p->mark;
24656 927 : int _start_mark = p->mark;
24657 927 : void **_children = PyMem_Malloc(sizeof(void *));
24658 927 : if (!_children) {
24659 0 : p->error_indicator = 1;
24660 0 : PyErr_NoMemory();
24661 0 : p->level--;
24662 0 : return NULL;
24663 : }
24664 927 : Py_ssize_t _children_capacity = 1;
24665 927 : Py_ssize_t _n = 0;
24666 : { // ',' NAME
24667 927 : if (p->error_indicator) {
24668 0 : p->level--;
24669 0 : return NULL;
24670 : }
24671 927 : D(fprintf(stderr, "%*c> _loop0_21[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));
24672 : Token * _literal;
24673 : expr_ty elem;
24674 2035 : while (
24675 1108 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
24676 181 : &&
24677 181 : (elem = _PyPegen_name_token(p)) // NAME
24678 : )
24679 : {
24680 181 : _res = elem;
24681 181 : 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 181 : if (_n == _children_capacity) {
24688 74 : _children_capacity *= 2;
24689 74 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
24690 74 : if (!_new_children) {
24691 0 : p->error_indicator = 1;
24692 0 : PyErr_NoMemory();
24693 0 : p->level--;
24694 0 : return NULL;
24695 : }
24696 74 : _children = _new_children;
24697 : }
24698 181 : _children[_n++] = _res;
24699 181 : _mark = p->mark;
24700 : }
24701 927 : p->mark = _mark;
24702 927 : 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 927 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24706 927 : if (!_seq) {
24707 0 : PyMem_Free(_children);
24708 0 : p->error_indicator = 1;
24709 0 : PyErr_NoMemory();
24710 0 : p->level--;
24711 0 : return NULL;
24712 : }
24713 1108 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
24714 927 : PyMem_Free(_children);
24715 927 : _PyPegen_insert_memo(p, _start_mark, _loop0_21_type, _seq);
24716 927 : p->level--;
24717 927 : return _seq;
24718 : }
24719 :
24720 : // _gather_20: NAME _loop0_21
24721 : static asdl_seq *
24722 929 : _gather_20_rule(Parser *p)
24723 : {
24724 929 : if (p->level++ == MAXSTACK) {
24725 0 : p->error_indicator = 1;
24726 0 : PyErr_NoMemory();
24727 : }
24728 929 : if (p->error_indicator) {
24729 0 : p->level--;
24730 0 : return NULL;
24731 : }
24732 929 : asdl_seq * _res = NULL;
24733 929 : int _mark = p->mark;
24734 : { // NAME _loop0_21
24735 929 : if (p->error_indicator) {
24736 0 : p->level--;
24737 0 : return NULL;
24738 : }
24739 929 : 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 929 : if (
24743 929 : (elem = _PyPegen_name_token(p)) // NAME
24744 927 : &&
24745 927 : (seq = _loop0_21_rule(p)) // _loop0_21
24746 : )
24747 : {
24748 927 : D(fprintf(stderr, "%*c+ _gather_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_21"));
24749 927 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
24750 927 : goto done;
24751 : }
24752 2 : p->mark = _mark;
24753 2 : 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 929 : done:
24758 929 : p->level--;
24759 929 : return _res;
24760 : }
24761 :
24762 : // _tmp_22: ';' | NEWLINE
24763 : static void *
24764 8933 : _tmp_22_rule(Parser *p)
24765 : {
24766 8933 : if (p->level++ == MAXSTACK) {
24767 0 : p->error_indicator = 1;
24768 0 : PyErr_NoMemory();
24769 : }
24770 8933 : if (p->error_indicator) {
24771 0 : p->level--;
24772 0 : return NULL;
24773 : }
24774 8933 : void * _res = NULL;
24775 8933 : int _mark = p->mark;
24776 : { // ';'
24777 8933 : if (p->error_indicator) {
24778 0 : p->level--;
24779 0 : return NULL;
24780 : }
24781 8933 : D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'"));
24782 : Token * _literal;
24783 8933 : if (
24784 8933 : (_literal = _PyPegen_expect_token(p, 13)) // token=';'
24785 : )
24786 : {
24787 37 : 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 8896 : p->mark = _mark;
24792 8896 : 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 8896 : if (p->error_indicator) {
24797 0 : p->level--;
24798 0 : return NULL;
24799 : }
24800 8896 : D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
24801 : Token * newline_var;
24802 8896 : if (
24803 8896 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24804 : )
24805 : {
24806 8862 : D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
24807 8862 : _res = newline_var;
24808 8862 : goto done;
24809 : }
24810 34 : p->mark = _mark;
24811 34 : 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 8933 : done:
24816 8933 : p->level--;
24817 8933 : return _res;
24818 : }
24819 :
24820 : // _tmp_23: ',' expression
24821 : static void *
24822 9780 : _tmp_23_rule(Parser *p)
24823 : {
24824 9780 : if (p->level++ == MAXSTACK) {
24825 0 : p->error_indicator = 1;
24826 0 : PyErr_NoMemory();
24827 : }
24828 9780 : if (p->error_indicator) {
24829 0 : p->level--;
24830 0 : return NULL;
24831 : }
24832 9780 : void * _res = NULL;
24833 9780 : int _mark = p->mark;
24834 : { // ',' expression
24835 9780 : if (p->error_indicator) {
24836 0 : p->level--;
24837 0 : return NULL;
24838 : }
24839 9780 : D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
24840 : Token * _literal;
24841 : expr_ty z;
24842 9780 : if (
24843 9780 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
24844 2174 : &&
24845 2174 : (z = expression_rule(p)) // expression
24846 : )
24847 : {
24848 2174 : D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression"));
24849 2174 : _res = z;
24850 2174 : if (_res == NULL && PyErr_Occurred()) {
24851 0 : p->error_indicator = 1;
24852 0 : p->level--;
24853 0 : return NULL;
24854 : }
24855 2174 : goto done;
24856 : }
24857 7606 : p->mark = _mark;
24858 7606 : 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 7606 : _res = NULL;
24862 9780 : done:
24863 9780 : p->level--;
24864 9780 : return _res;
24865 : }
24866 :
24867 : // _loop0_24: ('.' | '...')
24868 : static asdl_seq *
24869 46171 : _loop0_24_rule(Parser *p)
24870 : {
24871 46171 : if (p->level++ == MAXSTACK) {
24872 0 : p->error_indicator = 1;
24873 0 : PyErr_NoMemory();
24874 : }
24875 46171 : if (p->error_indicator) {
24876 0 : p->level--;
24877 0 : return NULL;
24878 : }
24879 46171 : void *_res = NULL;
24880 46171 : int _mark = p->mark;
24881 46171 : int _start_mark = p->mark;
24882 46171 : void **_children = PyMem_Malloc(sizeof(void *));
24883 46171 : if (!_children) {
24884 0 : p->error_indicator = 1;
24885 0 : PyErr_NoMemory();
24886 0 : p->level--;
24887 0 : return NULL;
24888 : }
24889 46171 : Py_ssize_t _children_capacity = 1;
24890 46171 : Py_ssize_t _n = 0;
24891 : { // ('.' | '...')
24892 46171 : if (p->error_indicator) {
24893 0 : p->level--;
24894 0 : return NULL;
24895 : }
24896 46171 : D(fprintf(stderr, "%*c> _loop0_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
24897 : void *_tmp_220_var;
24898 104144 : while (
24899 57973 : (_tmp_220_var = _tmp_220_rule(p)) // '.' | '...'
24900 : )
24901 : {
24902 11802 : _res = _tmp_220_var;
24903 11802 : 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 0 : PyErr_NoMemory();
24909 0 : p->level--;
24910 0 : return NULL;
24911 : }
24912 652 : _children = _new_children;
24913 : }
24914 11802 : _children[_n++] = _res;
24915 11802 : _mark = p->mark;
24916 : }
24917 46171 : p->mark = _mark;
24918 46171 : D(fprintf(stderr, "%*c%s _loop0_24[%d-%d]: %s failed!\n", p->level, ' ',
24919 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')"));
24920 : }
24921 46171 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24922 46171 : if (!_seq) {
24923 0 : PyMem_Free(_children);
24924 0 : p->error_indicator = 1;
24925 0 : PyErr_NoMemory();
24926 0 : p->level--;
24927 0 : return NULL;
24928 : }
24929 57973 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
24930 46171 : PyMem_Free(_children);
24931 46171 : _PyPegen_insert_memo(p, _start_mark, _loop0_24_type, _seq);
24932 46171 : p->level--;
24933 46171 : return _seq;
24934 : }
24935 :
24936 : // _loop1_25: ('.' | '...')
24937 : static asdl_seq *
24938 1274 : _loop1_25_rule(Parser *p)
24939 : {
24940 1274 : if (p->level++ == MAXSTACK) {
24941 0 : p->error_indicator = 1;
24942 0 : PyErr_NoMemory();
24943 : }
24944 1274 : if (p->error_indicator) {
24945 0 : p->level--;
24946 0 : return NULL;
24947 : }
24948 1274 : void *_res = NULL;
24949 1274 : int _mark = p->mark;
24950 1274 : int _start_mark = p->mark;
24951 1274 : void **_children = PyMem_Malloc(sizeof(void *));
24952 1274 : if (!_children) {
24953 0 : p->error_indicator = 1;
24954 0 : PyErr_NoMemory();
24955 0 : p->level--;
24956 0 : return NULL;
24957 : }
24958 1274 : Py_ssize_t _children_capacity = 1;
24959 1274 : Py_ssize_t _n = 0;
24960 : { // ('.' | '...')
24961 1274 : if (p->error_indicator) {
24962 0 : p->level--;
24963 0 : return NULL;
24964 : }
24965 1274 : D(fprintf(stderr, "%*c> _loop1_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
24966 : void *_tmp_221_var;
24967 3918 : while (
24968 2644 : (_tmp_221_var = _tmp_221_rule(p)) // '.' | '...'
24969 : )
24970 : {
24971 1370 : _res = _tmp_221_var;
24972 1370 : 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 0 : PyErr_NoMemory();
24978 0 : p->level--;
24979 0 : return NULL;
24980 : }
24981 115 : _children = _new_children;
24982 : }
24983 1370 : _children[_n++] = _res;
24984 1370 : _mark = p->mark;
24985 : }
24986 1274 : p->mark = _mark;
24987 1274 : D(fprintf(stderr, "%*c%s _loop1_25[%d-%d]: %s failed!\n", p->level, ' ',
24988 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')"));
24989 : }
24990 1274 : if (_n == 0 || p->error_indicator) {
24991 19 : PyMem_Free(_children);
24992 19 : p->level--;
24993 19 : return NULL;
24994 : }
24995 1255 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
24996 1255 : if (!_seq) {
24997 0 : PyMem_Free(_children);
24998 0 : p->error_indicator = 1;
24999 0 : PyErr_NoMemory();
25000 0 : p->level--;
25001 0 : return NULL;
25002 : }
25003 2625 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25004 1255 : PyMem_Free(_children);
25005 1255 : _PyPegen_insert_memo(p, _start_mark, _loop1_25_type, _seq);
25006 1255 : p->level--;
25007 1255 : return _seq;
25008 : }
25009 :
25010 : // _loop0_27: ',' import_from_as_name
25011 : static asdl_seq *
25012 45029 : _loop0_27_rule(Parser *p)
25013 : {
25014 45029 : if (p->level++ == MAXSTACK) {
25015 0 : p->error_indicator = 1;
25016 0 : PyErr_NoMemory();
25017 : }
25018 45029 : if (p->error_indicator) {
25019 0 : p->level--;
25020 0 : return NULL;
25021 : }
25022 45029 : void *_res = NULL;
25023 45029 : int _mark = p->mark;
25024 45029 : int _start_mark = p->mark;
25025 45029 : void **_children = PyMem_Malloc(sizeof(void *));
25026 45029 : if (!_children) {
25027 0 : p->error_indicator = 1;
25028 0 : PyErr_NoMemory();
25029 0 : p->level--;
25030 0 : return NULL;
25031 : }
25032 45029 : Py_ssize_t _children_capacity = 1;
25033 45029 : Py_ssize_t _n = 0;
25034 : { // ',' import_from_as_name
25035 45029 : if (p->error_indicator) {
25036 0 : p->level--;
25037 0 : return NULL;
25038 : }
25039 45029 : 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 122533 : while (
25043 77504 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
25044 33855 : &&
25045 33855 : (elem = import_from_as_name_rule(p)) // import_from_as_name
25046 : )
25047 : {
25048 32475 : _res = elem;
25049 32475 : 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 32475 : if (_n == _children_capacity) {
25056 12733 : _children_capacity *= 2;
25057 12733 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25058 12733 : if (!_new_children) {
25059 0 : p->error_indicator = 1;
25060 0 : PyErr_NoMemory();
25061 0 : p->level--;
25062 0 : return NULL;
25063 : }
25064 12733 : _children = _new_children;
25065 : }
25066 32475 : _children[_n++] = _res;
25067 32475 : _mark = p->mark;
25068 : }
25069 45029 : p->mark = _mark;
25070 45029 : 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 45029 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25074 45029 : if (!_seq) {
25075 0 : PyMem_Free(_children);
25076 0 : p->error_indicator = 1;
25077 0 : PyErr_NoMemory();
25078 0 : p->level--;
25079 0 : return NULL;
25080 : }
25081 77504 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25082 45029 : PyMem_Free(_children);
25083 45029 : _PyPegen_insert_memo(p, _start_mark, _loop0_27_type, _seq);
25084 45029 : p->level--;
25085 45029 : return _seq;
25086 : }
25087 :
25088 : // _gather_26: import_from_as_name _loop0_27
25089 : static asdl_seq *
25090 46181 : _gather_26_rule(Parser *p)
25091 : {
25092 46181 : if (p->level++ == MAXSTACK) {
25093 0 : p->error_indicator = 1;
25094 0 : PyErr_NoMemory();
25095 : }
25096 46181 : if (p->error_indicator) {
25097 0 : p->level--;
25098 0 : return NULL;
25099 : }
25100 46181 : asdl_seq * _res = NULL;
25101 46181 : int _mark = p->mark;
25102 : { // import_from_as_name _loop0_27
25103 46181 : if (p->error_indicator) {
25104 0 : p->level--;
25105 0 : return NULL;
25106 : }
25107 46181 : 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 46181 : if (
25111 46181 : (elem = import_from_as_name_rule(p)) // import_from_as_name
25112 45029 : &&
25113 45029 : (seq = _loop0_27_rule(p)) // _loop0_27
25114 : )
25115 : {
25116 45029 : D(fprintf(stderr, "%*c+ _gather_26[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_27"));
25117 45029 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
25118 45029 : goto done;
25119 : }
25120 1152 : p->mark = _mark;
25121 1152 : 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 1152 : _res = NULL;
25125 46181 : done:
25126 46181 : p->level--;
25127 46181 : return _res;
25128 : }
25129 :
25130 : // _tmp_28: 'as' NAME
25131 : static void *
25132 77512 : _tmp_28_rule(Parser *p)
25133 : {
25134 77512 : if (p->level++ == MAXSTACK) {
25135 0 : p->error_indicator = 1;
25136 0 : PyErr_NoMemory();
25137 : }
25138 77512 : if (p->error_indicator) {
25139 0 : p->level--;
25140 0 : return NULL;
25141 : }
25142 77512 : void * _res = NULL;
25143 77512 : int _mark = p->mark;
25144 : { // 'as' NAME
25145 77512 : if (p->error_indicator) {
25146 0 : p->level--;
25147 0 : return NULL;
25148 : }
25149 77512 : 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 77512 : if (
25153 77512 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
25154 3098 : &&
25155 3098 : (z = _PyPegen_name_token(p)) // NAME
25156 : )
25157 : {
25158 3094 : D(fprintf(stderr, "%*c+ _tmp_28[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
25159 3094 : _res = z;
25160 3094 : if (_res == NULL && PyErr_Occurred()) {
25161 0 : p->error_indicator = 1;
25162 0 : p->level--;
25163 0 : return NULL;
25164 : }
25165 3094 : goto done;
25166 : }
25167 74418 : p->mark = _mark;
25168 74418 : 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 74418 : _res = NULL;
25172 77512 : done:
25173 77512 : p->level--;
25174 77512 : return _res;
25175 : }
25176 :
25177 : // _loop0_30: ',' dotted_as_name
25178 : static asdl_seq *
25179 45171 : _loop0_30_rule(Parser *p)
25180 : {
25181 45171 : if (p->level++ == MAXSTACK) {
25182 0 : p->error_indicator = 1;
25183 0 : PyErr_NoMemory();
25184 : }
25185 45171 : if (p->error_indicator) {
25186 0 : p->level--;
25187 0 : return NULL;
25188 : }
25189 45171 : void *_res = NULL;
25190 45171 : int _mark = p->mark;
25191 45171 : int _start_mark = p->mark;
25192 45171 : void **_children = PyMem_Malloc(sizeof(void *));
25193 45171 : if (!_children) {
25194 0 : p->error_indicator = 1;
25195 0 : PyErr_NoMemory();
25196 0 : p->level--;
25197 0 : return NULL;
25198 : }
25199 45171 : Py_ssize_t _children_capacity = 1;
25200 45171 : Py_ssize_t _n = 0;
25201 : { // ',' dotted_as_name
25202 45171 : if (p->error_indicator) {
25203 0 : p->level--;
25204 0 : return NULL;
25205 : }
25206 45171 : 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 91589 : while (
25210 46418 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
25211 1247 : &&
25212 1247 : (elem = dotted_as_name_rule(p)) // dotted_as_name
25213 : )
25214 : {
25215 1247 : _res = elem;
25216 1247 : 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 1247 : if (_n == _children_capacity) {
25223 279 : _children_capacity *= 2;
25224 279 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25225 279 : if (!_new_children) {
25226 0 : p->error_indicator = 1;
25227 0 : PyErr_NoMemory();
25228 0 : p->level--;
25229 0 : return NULL;
25230 : }
25231 279 : _children = _new_children;
25232 : }
25233 1247 : _children[_n++] = _res;
25234 1247 : _mark = p->mark;
25235 : }
25236 45171 : p->mark = _mark;
25237 45171 : 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 45171 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25241 45171 : if (!_seq) {
25242 0 : PyMem_Free(_children);
25243 0 : p->error_indicator = 1;
25244 0 : PyErr_NoMemory();
25245 0 : p->level--;
25246 0 : return NULL;
25247 : }
25248 46418 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25249 45171 : PyMem_Free(_children);
25250 45171 : _PyPegen_insert_memo(p, _start_mark, _loop0_30_type, _seq);
25251 45171 : p->level--;
25252 45171 : return _seq;
25253 : }
25254 :
25255 : // _gather_29: dotted_as_name _loop0_30
25256 : static asdl_seq *
25257 45189 : _gather_29_rule(Parser *p)
25258 : {
25259 45189 : if (p->level++ == MAXSTACK) {
25260 0 : p->error_indicator = 1;
25261 0 : PyErr_NoMemory();
25262 : }
25263 45189 : if (p->error_indicator) {
25264 0 : p->level--;
25265 0 : return NULL;
25266 : }
25267 45189 : asdl_seq * _res = NULL;
25268 45189 : int _mark = p->mark;
25269 : { // dotted_as_name _loop0_30
25270 45189 : if (p->error_indicator) {
25271 0 : p->level--;
25272 0 : return NULL;
25273 : }
25274 45189 : 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 45189 : if (
25278 45189 : (elem = dotted_as_name_rule(p)) // dotted_as_name
25279 45171 : &&
25280 45171 : (seq = _loop0_30_rule(p)) // _loop0_30
25281 : )
25282 : {
25283 45171 : D(fprintf(stderr, "%*c+ _gather_29[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_30"));
25284 45171 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
25285 45171 : goto done;
25286 : }
25287 18 : p->mark = _mark;
25288 18 : 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 45189 : done:
25293 45189 : p->level--;
25294 45189 : return _res;
25295 : }
25296 :
25297 : // _tmp_31: 'as' NAME
25298 : static void *
25299 46418 : _tmp_31_rule(Parser *p)
25300 : {
25301 46418 : if (p->level++ == MAXSTACK) {
25302 0 : p->error_indicator = 1;
25303 0 : PyErr_NoMemory();
25304 : }
25305 46418 : if (p->error_indicator) {
25306 0 : p->level--;
25307 0 : return NULL;
25308 : }
25309 46418 : void * _res = NULL;
25310 46418 : int _mark = p->mark;
25311 : { // 'as' NAME
25312 46418 : if (p->error_indicator) {
25313 0 : p->level--;
25314 0 : return NULL;
25315 : }
25316 46418 : 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 46418 : if (
25320 46418 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
25321 1547 : &&
25322 1547 : (z = _PyPegen_name_token(p)) // NAME
25323 : )
25324 : {
25325 1541 : D(fprintf(stderr, "%*c+ _tmp_31[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
25326 1541 : _res = z;
25327 1541 : if (_res == NULL && PyErr_Occurred()) {
25328 0 : p->error_indicator = 1;
25329 0 : p->level--;
25330 0 : return NULL;
25331 : }
25332 1541 : goto done;
25333 : }
25334 44877 : p->mark = _mark;
25335 44877 : 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 44877 : _res = NULL;
25339 46418 : done:
25340 46418 : p->level--;
25341 46418 : return _res;
25342 : }
25343 :
25344 : // _loop1_32: ('@' named_expression NEWLINE)
25345 : static asdl_seq *
25346 403392 : _loop1_32_rule(Parser *p)
25347 : {
25348 403392 : if (p->level++ == MAXSTACK) {
25349 0 : p->error_indicator = 1;
25350 0 : PyErr_NoMemory();
25351 : }
25352 403392 : if (p->error_indicator) {
25353 0 : p->level--;
25354 0 : return NULL;
25355 : }
25356 403392 : void *_res = NULL;
25357 403392 : int _mark = p->mark;
25358 403392 : int _start_mark = p->mark;
25359 403392 : void **_children = PyMem_Malloc(sizeof(void *));
25360 403392 : if (!_children) {
25361 0 : p->error_indicator = 1;
25362 0 : PyErr_NoMemory();
25363 0 : p->level--;
25364 0 : return NULL;
25365 : }
25366 403392 : Py_ssize_t _children_capacity = 1;
25367 403392 : Py_ssize_t _n = 0;
25368 : { // ('@' named_expression NEWLINE)
25369 403392 : if (p->error_indicator) {
25370 0 : p->level--;
25371 0 : return NULL;
25372 : }
25373 403392 : D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)"));
25374 : void *_tmp_222_var;
25375 847228 : while (
25376 443836 : (_tmp_222_var = _tmp_222_rule(p)) // '@' named_expression NEWLINE
25377 : )
25378 : {
25379 40444 : _res = _tmp_222_var;
25380 40444 : if (_n == _children_capacity) {
25381 2689 : _children_capacity *= 2;
25382 2689 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25383 2689 : if (!_new_children) {
25384 0 : p->error_indicator = 1;
25385 0 : PyErr_NoMemory();
25386 0 : p->level--;
25387 0 : return NULL;
25388 : }
25389 2689 : _children = _new_children;
25390 : }
25391 40444 : _children[_n++] = _res;
25392 40444 : _mark = p->mark;
25393 : }
25394 403392 : p->mark = _mark;
25395 403392 : 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 403392 : if (_n == 0 || p->error_indicator) {
25399 365711 : PyMem_Free(_children);
25400 365711 : p->level--;
25401 365711 : return NULL;
25402 : }
25403 37681 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25404 37681 : if (!_seq) {
25405 0 : PyMem_Free(_children);
25406 0 : p->error_indicator = 1;
25407 0 : PyErr_NoMemory();
25408 0 : p->level--;
25409 0 : return NULL;
25410 : }
25411 78125 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25412 37681 : PyMem_Free(_children);
25413 37681 : _PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq);
25414 37681 : p->level--;
25415 37681 : return _seq;
25416 : }
25417 :
25418 : // _tmp_33: '(' arguments? ')'
25419 : static void *
25420 56790 : _tmp_33_rule(Parser *p)
25421 : {
25422 56790 : if (p->level++ == MAXSTACK) {
25423 0 : p->error_indicator = 1;
25424 0 : PyErr_NoMemory();
25425 : }
25426 56790 : if (p->error_indicator) {
25427 0 : p->level--;
25428 0 : return NULL;
25429 : }
25430 56790 : void * _res = NULL;
25431 56790 : int _mark = p->mark;
25432 : { // '(' arguments? ')'
25433 56790 : if (p->error_indicator) {
25434 0 : p->level--;
25435 0 : return NULL;
25436 : }
25437 56790 : 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 56790 : if (
25442 56790 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
25443 42997 : &&
25444 42997 : (z = arguments_rule(p), !p->error_indicator) // arguments?
25445 42991 : &&
25446 42991 : (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
25447 : )
25448 : {
25449 42989 : D(fprintf(stderr, "%*c+ _tmp_33[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
25450 42989 : _res = z;
25451 42989 : if (_res == NULL && PyErr_Occurred()) {
25452 0 : p->error_indicator = 1;
25453 0 : p->level--;
25454 0 : return NULL;
25455 : }
25456 42989 : goto done;
25457 : }
25458 13801 : p->mark = _mark;
25459 13801 : 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 13801 : _res = NULL;
25463 56790 : done:
25464 56790 : p->level--;
25465 56790 : return _res;
25466 : }
25467 :
25468 : // _tmp_34: '->' expression
25469 : static void *
25470 339010 : _tmp_34_rule(Parser *p)
25471 : {
25472 339010 : if (p->level++ == MAXSTACK) {
25473 0 : p->error_indicator = 1;
25474 0 : PyErr_NoMemory();
25475 : }
25476 339010 : if (p->error_indicator) {
25477 0 : p->level--;
25478 0 : return NULL;
25479 : }
25480 339010 : void * _res = NULL;
25481 339010 : int _mark = p->mark;
25482 : { // '->' expression
25483 339010 : if (p->error_indicator) {
25484 0 : p->level--;
25485 0 : return NULL;
25486 : }
25487 339010 : D(fprintf(stderr, "%*c> _tmp_34[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
25488 : Token * _literal;
25489 : expr_ty z;
25490 339010 : if (
25491 339010 : (_literal = _PyPegen_expect_token(p, 51)) // token='->'
25492 32969 : &&
25493 32969 : (z = expression_rule(p)) // expression
25494 : )
25495 : {
25496 32969 : D(fprintf(stderr, "%*c+ _tmp_34[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
25497 32969 : _res = z;
25498 32969 : if (_res == NULL && PyErr_Occurred()) {
25499 0 : p->error_indicator = 1;
25500 0 : p->level--;
25501 0 : return NULL;
25502 : }
25503 32969 : goto done;
25504 : }
25505 306041 : p->mark = _mark;
25506 306041 : 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 306041 : _res = NULL;
25510 339010 : done:
25511 339010 : p->level--;
25512 339010 : return _res;
25513 : }
25514 :
25515 : // _tmp_35: '->' expression
25516 : static void *
25517 3498 : _tmp_35_rule(Parser *p)
25518 : {
25519 3498 : if (p->level++ == MAXSTACK) {
25520 0 : p->error_indicator = 1;
25521 0 : PyErr_NoMemory();
25522 : }
25523 3498 : if (p->error_indicator) {
25524 0 : p->level--;
25525 0 : return NULL;
25526 : }
25527 3498 : void * _res = NULL;
25528 3498 : int _mark = p->mark;
25529 : { // '->' expression
25530 3498 : if (p->error_indicator) {
25531 0 : p->level--;
25532 0 : return NULL;
25533 : }
25534 3498 : D(fprintf(stderr, "%*c> _tmp_35[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
25535 : Token * _literal;
25536 : expr_ty z;
25537 3498 : if (
25538 3498 : (_literal = _PyPegen_expect_token(p, 51)) // token='->'
25539 416 : &&
25540 416 : (z = expression_rule(p)) // expression
25541 : )
25542 : {
25543 416 : 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 3082 : p->mark = _mark;
25553 3082 : 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 3082 : _res = NULL;
25557 3498 : done:
25558 3498 : p->level--;
25559 3498 : return _res;
25560 : }
25561 :
25562 : // _loop0_36: param_no_default
25563 : static asdl_seq *
25564 17415 : _loop0_36_rule(Parser *p)
25565 : {
25566 17415 : if (p->level++ == MAXSTACK) {
25567 0 : p->error_indicator = 1;
25568 0 : PyErr_NoMemory();
25569 : }
25570 17415 : if (p->error_indicator) {
25571 0 : p->level--;
25572 0 : return NULL;
25573 : }
25574 17415 : void *_res = NULL;
25575 17415 : int _mark = p->mark;
25576 17415 : int _start_mark = p->mark;
25577 17415 : void **_children = PyMem_Malloc(sizeof(void *));
25578 17415 : if (!_children) {
25579 0 : p->error_indicator = 1;
25580 0 : PyErr_NoMemory();
25581 0 : p->level--;
25582 0 : return NULL;
25583 : }
25584 17415 : Py_ssize_t _children_capacity = 1;
25585 17415 : Py_ssize_t _n = 0;
25586 : { // param_no_default
25587 17415 : if (p->error_indicator) {
25588 0 : p->level--;
25589 0 : return NULL;
25590 : }
25591 17415 : 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 35030 : while (
25594 17615 : (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 0 : 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 17415 : p->mark = _mark;
25613 17415 : 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 17415 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25617 17415 : if (!_seq) {
25618 0 : PyMem_Free(_children);
25619 0 : p->error_indicator = 1;
25620 0 : PyErr_NoMemory();
25621 0 : p->level--;
25622 0 : return NULL;
25623 : }
25624 17615 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25625 17415 : PyMem_Free(_children);
25626 17415 : _PyPegen_insert_memo(p, _start_mark, _loop0_36_type, _seq);
25627 17415 : p->level--;
25628 17415 : return _seq;
25629 : }
25630 :
25631 : // _loop0_37: param_with_default
25632 : static asdl_seq *
25633 17415 : _loop0_37_rule(Parser *p)
25634 : {
25635 17415 : if (p->level++ == MAXSTACK) {
25636 0 : p->error_indicator = 1;
25637 0 : PyErr_NoMemory();
25638 : }
25639 17415 : if (p->error_indicator) {
25640 0 : p->level--;
25641 0 : return NULL;
25642 : }
25643 17415 : void *_res = NULL;
25644 17415 : int _mark = p->mark;
25645 17415 : int _start_mark = p->mark;
25646 17415 : void **_children = PyMem_Malloc(sizeof(void *));
25647 17415 : if (!_children) {
25648 0 : p->error_indicator = 1;
25649 0 : PyErr_NoMemory();
25650 0 : p->level--;
25651 0 : return NULL;
25652 : }
25653 17415 : Py_ssize_t _children_capacity = 1;
25654 17415 : Py_ssize_t _n = 0;
25655 : { // param_with_default
25656 17415 : if (p->error_indicator) {
25657 0 : p->level--;
25658 0 : return NULL;
25659 : }
25660 17415 : 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 35029 : while (
25663 17614 : (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 0 : 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 17415 : p->mark = _mark;
25682 17415 : 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 17415 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25686 17415 : if (!_seq) {
25687 0 : PyMem_Free(_children);
25688 0 : p->error_indicator = 1;
25689 0 : PyErr_NoMemory();
25690 0 : p->level--;
25691 0 : return NULL;
25692 : }
25693 17614 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25694 17415 : PyMem_Free(_children);
25695 17415 : _PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq);
25696 17415 : p->level--;
25697 17415 : return _seq;
25698 : }
25699 :
25700 : // _loop0_38: param_with_default
25701 : static asdl_seq *
25702 375 : _loop0_38_rule(Parser *p)
25703 : {
25704 375 : if (p->level++ == MAXSTACK) {
25705 0 : p->error_indicator = 1;
25706 0 : PyErr_NoMemory();
25707 : }
25708 375 : if (p->error_indicator) {
25709 0 : p->level--;
25710 0 : return NULL;
25711 : }
25712 375 : void *_res = NULL;
25713 375 : int _mark = p->mark;
25714 375 : int _start_mark = p->mark;
25715 375 : void **_children = PyMem_Malloc(sizeof(void *));
25716 375 : if (!_children) {
25717 0 : p->error_indicator = 1;
25718 0 : PyErr_NoMemory();
25719 0 : p->level--;
25720 0 : return NULL;
25721 : }
25722 375 : Py_ssize_t _children_capacity = 1;
25723 375 : Py_ssize_t _n = 0;
25724 : { // param_with_default
25725 375 : if (p->error_indicator) {
25726 0 : p->level--;
25727 0 : return NULL;
25728 : }
25729 375 : 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 858 : while (
25732 483 : (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 0 : 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 375 : p->mark = _mark;
25751 375 : 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 375 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25755 375 : if (!_seq) {
25756 0 : PyMem_Free(_children);
25757 0 : p->error_indicator = 1;
25758 0 : PyErr_NoMemory();
25759 0 : p->level--;
25760 0 : return NULL;
25761 : }
25762 483 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25763 375 : PyMem_Free(_children);
25764 375 : _PyPegen_insert_memo(p, _start_mark, _loop0_38_type, _seq);
25765 375 : p->level--;
25766 375 : return _seq;
25767 : }
25768 :
25769 : // _loop1_39: param_no_default
25770 : static asdl_seq *
25771 325028 : _loop1_39_rule(Parser *p)
25772 : {
25773 325028 : if (p->level++ == MAXSTACK) {
25774 0 : p->error_indicator = 1;
25775 0 : PyErr_NoMemory();
25776 : }
25777 325028 : if (p->error_indicator) {
25778 0 : p->level--;
25779 0 : return NULL;
25780 : }
25781 325028 : void *_res = NULL;
25782 325028 : int _mark = p->mark;
25783 325028 : int _start_mark = p->mark;
25784 325028 : void **_children = PyMem_Malloc(sizeof(void *));
25785 325028 : if (!_children) {
25786 0 : p->error_indicator = 1;
25787 0 : PyErr_NoMemory();
25788 0 : p->level--;
25789 0 : return NULL;
25790 : }
25791 325028 : Py_ssize_t _children_capacity = 1;
25792 325028 : Py_ssize_t _n = 0;
25793 : { // param_no_default
25794 325028 : if (p->error_indicator) {
25795 0 : p->level--;
25796 0 : return NULL;
25797 : }
25798 325028 : 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 1117140 : while (
25801 792107 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
25802 : )
25803 : {
25804 467079 : _res = param_no_default_var;
25805 467079 : if (_n == _children_capacity) {
25806 149325 : _children_capacity *= 2;
25807 149325 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25808 149325 : if (!_new_children) {
25809 0 : p->error_indicator = 1;
25810 0 : PyErr_NoMemory();
25811 0 : p->level--;
25812 0 : return NULL;
25813 : }
25814 149325 : _children = _new_children;
25815 : }
25816 467079 : _children[_n++] = _res;
25817 467079 : _mark = p->mark;
25818 : }
25819 325028 : p->mark = _mark;
25820 325028 : 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 325028 : if (_n == 0 || p->error_indicator) {
25824 24739 : PyMem_Free(_children);
25825 24739 : p->level--;
25826 24739 : return NULL;
25827 : }
25828 300289 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25829 300289 : if (!_seq) {
25830 0 : PyMem_Free(_children);
25831 0 : p->error_indicator = 1;
25832 0 : PyErr_NoMemory();
25833 0 : p->level--;
25834 0 : return NULL;
25835 : }
25836 767368 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25837 300289 : PyMem_Free(_children);
25838 300289 : _PyPegen_insert_memo(p, _start_mark, _loop1_39_type, _seq);
25839 300289 : p->level--;
25840 300289 : return _seq;
25841 : }
25842 :
25843 : // _loop0_40: param_with_default
25844 : static asdl_seq *
25845 300289 : _loop0_40_rule(Parser *p)
25846 : {
25847 300289 : if (p->level++ == MAXSTACK) {
25848 0 : p->error_indicator = 1;
25849 0 : PyErr_NoMemory();
25850 : }
25851 300289 : if (p->error_indicator) {
25852 0 : p->level--;
25853 0 : return NULL;
25854 : }
25855 300289 : void *_res = NULL;
25856 300289 : int _mark = p->mark;
25857 300289 : int _start_mark = p->mark;
25858 300289 : void **_children = PyMem_Malloc(sizeof(void *));
25859 300289 : if (!_children) {
25860 0 : p->error_indicator = 1;
25861 0 : PyErr_NoMemory();
25862 0 : p->level--;
25863 0 : return NULL;
25864 : }
25865 300289 : Py_ssize_t _children_capacity = 1;
25866 300289 : Py_ssize_t _n = 0;
25867 : { // param_with_default
25868 300289 : if (p->error_indicator) {
25869 0 : p->level--;
25870 0 : return NULL;
25871 : }
25872 300289 : 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 667515 : while (
25875 367226 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
25876 : )
25877 : {
25878 66937 : _res = param_with_default_var;
25879 66937 : if (_n == _children_capacity) {
25880 22594 : _children_capacity *= 2;
25881 22594 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25882 22594 : if (!_new_children) {
25883 0 : p->error_indicator = 1;
25884 0 : PyErr_NoMemory();
25885 0 : p->level--;
25886 0 : return NULL;
25887 : }
25888 22594 : _children = _new_children;
25889 : }
25890 66937 : _children[_n++] = _res;
25891 66937 : _mark = p->mark;
25892 : }
25893 300289 : p->mark = _mark;
25894 300289 : 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 300289 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25898 300289 : if (!_seq) {
25899 0 : PyMem_Free(_children);
25900 0 : p->error_indicator = 1;
25901 0 : PyErr_NoMemory();
25902 0 : p->level--;
25903 0 : return NULL;
25904 : }
25905 367226 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25906 300289 : PyMem_Free(_children);
25907 300289 : _PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq);
25908 300289 : p->level--;
25909 300289 : return _seq;
25910 : }
25911 :
25912 : // _loop1_41: param_with_default
25913 : static asdl_seq *
25914 24739 : _loop1_41_rule(Parser *p)
25915 : {
25916 24739 : if (p->level++ == MAXSTACK) {
25917 0 : p->error_indicator = 1;
25918 0 : PyErr_NoMemory();
25919 : }
25920 24739 : if (p->error_indicator) {
25921 0 : p->level--;
25922 0 : return NULL;
25923 : }
25924 24739 : void *_res = NULL;
25925 24739 : int _mark = p->mark;
25926 24739 : int _start_mark = p->mark;
25927 24739 : void **_children = PyMem_Malloc(sizeof(void *));
25928 24739 : if (!_children) {
25929 0 : p->error_indicator = 1;
25930 0 : PyErr_NoMemory();
25931 0 : p->level--;
25932 0 : return NULL;
25933 : }
25934 24739 : Py_ssize_t _children_capacity = 1;
25935 24739 : Py_ssize_t _n = 0;
25936 : { // param_with_default
25937 24739 : if (p->error_indicator) {
25938 0 : p->level--;
25939 0 : return NULL;
25940 : }
25941 24739 : 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 56221 : while (
25944 31482 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
25945 : )
25946 : {
25947 6743 : _res = param_with_default_var;
25948 6743 : if (_n == _children_capacity) {
25949 2758 : _children_capacity *= 2;
25950 2758 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25951 2758 : if (!_new_children) {
25952 0 : p->error_indicator = 1;
25953 0 : PyErr_NoMemory();
25954 0 : p->level--;
25955 0 : return NULL;
25956 : }
25957 2758 : _children = _new_children;
25958 : }
25959 6743 : _children[_n++] = _res;
25960 6743 : _mark = p->mark;
25961 : }
25962 24739 : p->mark = _mark;
25963 24739 : 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 24739 : if (_n == 0 || p->error_indicator) {
25967 21632 : PyMem_Free(_children);
25968 21632 : p->level--;
25969 21632 : return NULL;
25970 : }
25971 3107 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25972 3107 : if (!_seq) {
25973 0 : PyMem_Free(_children);
25974 0 : p->error_indicator = 1;
25975 0 : PyErr_NoMemory();
25976 0 : p->level--;
25977 0 : return NULL;
25978 : }
25979 9850 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25980 3107 : PyMem_Free(_children);
25981 3107 : _PyPegen_insert_memo(p, _start_mark, _loop1_41_type, _seq);
25982 3107 : p->level--;
25983 3107 : return _seq;
25984 : }
25985 :
25986 : // _loop1_42: param_no_default
25987 : static asdl_seq *
25988 343371 : _loop1_42_rule(Parser *p)
25989 : {
25990 343371 : if (p->level++ == MAXSTACK) {
25991 0 : p->error_indicator = 1;
25992 0 : PyErr_NoMemory();
25993 : }
25994 343371 : if (p->error_indicator) {
25995 0 : p->level--;
25996 0 : return NULL;
25997 : }
25998 343371 : void *_res = NULL;
25999 343371 : int _mark = p->mark;
26000 343371 : int _start_mark = p->mark;
26001 343371 : void **_children = PyMem_Malloc(sizeof(void *));
26002 343371 : if (!_children) {
26003 0 : p->error_indicator = 1;
26004 0 : PyErr_NoMemory();
26005 0 : p->level--;
26006 0 : return NULL;
26007 : }
26008 343371 : Py_ssize_t _children_capacity = 1;
26009 343371 : Py_ssize_t _n = 0;
26010 : { // param_no_default
26011 343371 : if (p->error_indicator) {
26012 0 : p->level--;
26013 0 : return NULL;
26014 : }
26015 343371 : 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 1172850 : while (
26018 829479 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
26019 : )
26020 : {
26021 486108 : _res = param_no_default_var;
26022 486108 : if (_n == _children_capacity) {
26023 149922 : _children_capacity *= 2;
26024 149922 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26025 149922 : if (!_new_children) {
26026 0 : p->error_indicator = 1;
26027 0 : PyErr_NoMemory();
26028 0 : p->level--;
26029 0 : return NULL;
26030 : }
26031 149922 : _children = _new_children;
26032 : }
26033 486108 : _children[_n++] = _res;
26034 486108 : _mark = p->mark;
26035 : }
26036 343371 : p->mark = _mark;
26037 343371 : 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 343371 : if (_n == 0 || p->error_indicator) {
26041 25291 : PyMem_Free(_children);
26042 25291 : p->level--;
26043 25291 : return NULL;
26044 : }
26045 318080 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26046 318080 : if (!_seq) {
26047 0 : PyMem_Free(_children);
26048 0 : p->error_indicator = 1;
26049 0 : PyErr_NoMemory();
26050 0 : p->level--;
26051 0 : return NULL;
26052 : }
26053 804184 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26054 318080 : PyMem_Free(_children);
26055 318080 : _PyPegen_insert_memo(p, _start_mark, _loop1_42_type, _seq);
26056 318080 : p->level--;
26057 318080 : return _seq;
26058 : }
26059 :
26060 : // _loop1_43: param_no_default
26061 : static asdl_seq *
26062 326158 : _loop1_43_rule(Parser *p)
26063 : {
26064 326158 : if (p->level++ == MAXSTACK) {
26065 0 : p->error_indicator = 1;
26066 0 : PyErr_NoMemory();
26067 : }
26068 326158 : if (p->error_indicator) {
26069 0 : p->level--;
26070 0 : return NULL;
26071 : }
26072 326158 : void *_res = NULL;
26073 326158 : int _mark = p->mark;
26074 326158 : int _start_mark = p->mark;
26075 326158 : void **_children = PyMem_Malloc(sizeof(void *));
26076 326158 : if (!_children) {
26077 0 : p->error_indicator = 1;
26078 0 : PyErr_NoMemory();
26079 0 : p->level--;
26080 0 : return NULL;
26081 : }
26082 326158 : Py_ssize_t _children_capacity = 1;
26083 326158 : Py_ssize_t _n = 0;
26084 : { // param_no_default
26085 326158 : if (p->error_indicator) {
26086 0 : p->level--;
26087 0 : return NULL;
26088 : }
26089 326158 : 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 1120760 : while (
26092 794599 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
26093 : )
26094 : {
26095 468441 : _res = param_no_default_var;
26096 468441 : if (_n == _children_capacity) {
26097 149499 : _children_capacity *= 2;
26098 149499 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26099 149499 : if (!_new_children) {
26100 0 : p->error_indicator = 1;
26101 0 : PyErr_NoMemory();
26102 0 : p->level--;
26103 0 : return NULL;
26104 : }
26105 149499 : _children = _new_children;
26106 : }
26107 468441 : _children[_n++] = _res;
26108 468441 : _mark = p->mark;
26109 : }
26110 326158 : p->mark = _mark;
26111 326158 : 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 326158 : if (_n == 0 || p->error_indicator) {
26115 25278 : PyMem_Free(_children);
26116 25278 : p->level--;
26117 25278 : return NULL;
26118 : }
26119 300880 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26120 300880 : if (!_seq) {
26121 0 : PyMem_Free(_children);
26122 0 : p->error_indicator = 1;
26123 0 : PyErr_NoMemory();
26124 0 : p->level--;
26125 0 : return NULL;
26126 : }
26127 769321 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26128 300880 : PyMem_Free(_children);
26129 300880 : _PyPegen_insert_memo(p, _start_mark, _loop1_43_type, _seq);
26130 300880 : p->level--;
26131 300880 : return _seq;
26132 : }
26133 :
26134 : // _loop0_44: param_no_default
26135 : static asdl_seq *
26136 326225 : _loop0_44_rule(Parser *p)
26137 : {
26138 326225 : if (p->level++ == MAXSTACK) {
26139 0 : p->error_indicator = 1;
26140 0 : PyErr_NoMemory();
26141 : }
26142 326225 : if (p->error_indicator) {
26143 0 : p->level--;
26144 0 : return NULL;
26145 : }
26146 326225 : void *_res = NULL;
26147 326225 : int _mark = p->mark;
26148 326225 : int _start_mark = p->mark;
26149 326225 : void **_children = PyMem_Malloc(sizeof(void *));
26150 326225 : if (!_children) {
26151 0 : p->error_indicator = 1;
26152 0 : PyErr_NoMemory();
26153 0 : p->level--;
26154 0 : return NULL;
26155 : }
26156 326225 : Py_ssize_t _children_capacity = 1;
26157 326225 : Py_ssize_t _n = 0;
26158 : { // param_no_default
26159 326225 : if (p->error_indicator) {
26160 0 : p->level--;
26161 0 : return NULL;
26162 : }
26163 326225 : 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 1119920 : while (
26166 793691 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
26167 : )
26168 : {
26169 467466 : _res = param_no_default_var;
26170 467466 : if (_n == _children_capacity) {
26171 149347 : _children_capacity *= 2;
26172 149347 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26173 149347 : if (!_new_children) {
26174 0 : p->error_indicator = 1;
26175 0 : PyErr_NoMemory();
26176 0 : p->level--;
26177 0 : return NULL;
26178 : }
26179 149347 : _children = _new_children;
26180 : }
26181 467466 : _children[_n++] = _res;
26182 467466 : _mark = p->mark;
26183 : }
26184 326225 : p->mark = _mark;
26185 326225 : 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 326225 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26189 326225 : if (!_seq) {
26190 0 : PyMem_Free(_children);
26191 0 : p->error_indicator = 1;
26192 0 : PyErr_NoMemory();
26193 0 : p->level--;
26194 0 : return NULL;
26195 : }
26196 793691 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26197 326225 : PyMem_Free(_children);
26198 326225 : _PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq);
26199 326225 : p->level--;
26200 326225 : return _seq;
26201 : }
26202 :
26203 : // _loop1_45: param_with_default
26204 : static asdl_seq *
26205 326225 : _loop1_45_rule(Parser *p)
26206 : {
26207 326225 : if (p->level++ == MAXSTACK) {
26208 0 : p->error_indicator = 1;
26209 0 : PyErr_NoMemory();
26210 : }
26211 326225 : if (p->error_indicator) {
26212 0 : p->level--;
26213 0 : return NULL;
26214 : }
26215 326225 : void *_res = NULL;
26216 326225 : int _mark = p->mark;
26217 326225 : int _start_mark = p->mark;
26218 326225 : void **_children = PyMem_Malloc(sizeof(void *));
26219 326225 : if (!_children) {
26220 0 : p->error_indicator = 1;
26221 0 : PyErr_NoMemory();
26222 0 : p->level--;
26223 0 : return NULL;
26224 : }
26225 326225 : Py_ssize_t _children_capacity = 1;
26226 326225 : Py_ssize_t _n = 0;
26227 : { // param_with_default
26228 326225 : if (p->error_indicator) {
26229 0 : p->level--;
26230 0 : return NULL;
26231 : }
26232 326225 : 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 726538 : while (
26235 400313 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
26236 : )
26237 : {
26238 74088 : _res = param_with_default_var;
26239 74088 : if (_n == _children_capacity) {
26240 25363 : _children_capacity *= 2;
26241 25363 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26242 25363 : if (!_new_children) {
26243 0 : p->error_indicator = 1;
26244 0 : PyErr_NoMemory();
26245 0 : p->level--;
26246 0 : return NULL;
26247 : }
26248 25363 : _children = _new_children;
26249 : }
26250 74088 : _children[_n++] = _res;
26251 74088 : _mark = p->mark;
26252 : }
26253 326225 : p->mark = _mark;
26254 326225 : 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 326225 : if (_n == 0 || p->error_indicator) {
26258 286087 : PyMem_Free(_children);
26259 286087 : p->level--;
26260 286087 : return NULL;
26261 : }
26262 40138 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26263 40138 : if (!_seq) {
26264 0 : PyMem_Free(_children);
26265 0 : p->error_indicator = 1;
26266 0 : PyErr_NoMemory();
26267 0 : p->level--;
26268 0 : return NULL;
26269 : }
26270 114225 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26271 40138 : PyMem_Free(_children);
26272 40138 : _PyPegen_insert_memo(p, _start_mark, _loop1_45_type, _seq);
26273 40138 : p->level--;
26274 40138 : return _seq;
26275 : }
26276 :
26277 : // _loop0_46: param_no_default
26278 : static asdl_seq *
26279 325862 : _loop0_46_rule(Parser *p)
26280 : {
26281 325862 : if (p->level++ == MAXSTACK) {
26282 0 : p->error_indicator = 1;
26283 0 : PyErr_NoMemory();
26284 : }
26285 325862 : if (p->error_indicator) {
26286 0 : p->level--;
26287 0 : return NULL;
26288 : }
26289 325862 : void *_res = NULL;
26290 325862 : int _mark = p->mark;
26291 325862 : int _start_mark = p->mark;
26292 325862 : void **_children = PyMem_Malloc(sizeof(void *));
26293 325862 : if (!_children) {
26294 0 : p->error_indicator = 1;
26295 0 : PyErr_NoMemory();
26296 0 : p->level--;
26297 0 : return NULL;
26298 : }
26299 325862 : Py_ssize_t _children_capacity = 1;
26300 325862 : Py_ssize_t _n = 0;
26301 : { // param_no_default
26302 325862 : if (p->error_indicator) {
26303 0 : p->level--;
26304 0 : return NULL;
26305 : }
26306 325862 : 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 1118900 : while (
26309 793039 : (param_no_default_var = param_no_default_rule(p)) // param_no_default
26310 : )
26311 : {
26312 467177 : _res = param_no_default_var;
26313 467177 : if (_n == _children_capacity) {
26314 149333 : _children_capacity *= 2;
26315 149333 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26316 149333 : if (!_new_children) {
26317 0 : p->error_indicator = 1;
26318 0 : PyErr_NoMemory();
26319 0 : p->level--;
26320 0 : return NULL;
26321 : }
26322 149333 : _children = _new_children;
26323 : }
26324 467177 : _children[_n++] = _res;
26325 467177 : _mark = p->mark;
26326 : }
26327 325862 : p->mark = _mark;
26328 325862 : 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 325862 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26332 325862 : if (!_seq) {
26333 0 : PyMem_Free(_children);
26334 0 : p->error_indicator = 1;
26335 0 : PyErr_NoMemory();
26336 0 : p->level--;
26337 0 : return NULL;
26338 : }
26339 793039 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26340 325862 : PyMem_Free(_children);
26341 325862 : _PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq);
26342 325862 : p->level--;
26343 325862 : return _seq;
26344 : }
26345 :
26346 : // _loop1_47: param_with_default
26347 : static asdl_seq *
26348 325862 : _loop1_47_rule(Parser *p)
26349 : {
26350 325862 : if (p->level++ == MAXSTACK) {
26351 0 : p->error_indicator = 1;
26352 0 : PyErr_NoMemory();
26353 : }
26354 325862 : if (p->error_indicator) {
26355 0 : p->level--;
26356 0 : return NULL;
26357 : }
26358 325862 : void *_res = NULL;
26359 325862 : int _mark = p->mark;
26360 325862 : int _start_mark = p->mark;
26361 325862 : void **_children = PyMem_Malloc(sizeof(void *));
26362 325862 : if (!_children) {
26363 0 : p->error_indicator = 1;
26364 0 : PyErr_NoMemory();
26365 0 : p->level--;
26366 0 : return NULL;
26367 : }
26368 325862 : Py_ssize_t _children_capacity = 1;
26369 325862 : Py_ssize_t _n = 0;
26370 : { // param_with_default
26371 325862 : if (p->error_indicator) {
26372 0 : p->level--;
26373 0 : return NULL;
26374 : }
26375 325862 : 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 725440 : while (
26378 399578 : (param_with_default_var = param_with_default_rule(p)) // param_with_default
26379 : )
26380 : {
26381 73716 : _res = param_with_default_var;
26382 73716 : if (_n == _children_capacity) {
26383 25352 : _children_capacity *= 2;
26384 25352 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26385 25352 : if (!_new_children) {
26386 0 : p->error_indicator = 1;
26387 0 : PyErr_NoMemory();
26388 0 : p->level--;
26389 0 : return NULL;
26390 : }
26391 25352 : _children = _new_children;
26392 : }
26393 73716 : _children[_n++] = _res;
26394 73716 : _mark = p->mark;
26395 : }
26396 325862 : p->mark = _mark;
26397 325862 : 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 325862 : if (_n == 0 || p->error_indicator) {
26401 286084 : PyMem_Free(_children);
26402 286084 : p->level--;
26403 286084 : return NULL;
26404 : }
26405 39778 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26406 39778 : if (!_seq) {
26407 0 : PyMem_Free(_children);
26408 0 : p->error_indicator = 1;
26409 0 : PyErr_NoMemory();
26410 0 : p->level--;
26411 0 : return NULL;
26412 : }
26413 113494 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26414 39778 : PyMem_Free(_children);
26415 39778 : _PyPegen_insert_memo(p, _start_mark, _loop1_47_type, _seq);
26416 39778 : p->level--;
26417 39778 : return _seq;
26418 : }
26419 :
26420 : // _loop0_48: param_maybe_default
26421 : static asdl_seq *
26422 27138 : _loop0_48_rule(Parser *p)
26423 : {
26424 27138 : if (p->level++ == MAXSTACK) {
26425 0 : p->error_indicator = 1;
26426 0 : PyErr_NoMemory();
26427 : }
26428 27138 : if (p->error_indicator) {
26429 0 : p->level--;
26430 0 : return NULL;
26431 : }
26432 27138 : void *_res = NULL;
26433 27138 : int _mark = p->mark;
26434 27138 : int _start_mark = p->mark;
26435 27138 : void **_children = PyMem_Malloc(sizeof(void *));
26436 27138 : if (!_children) {
26437 0 : p->error_indicator = 1;
26438 0 : PyErr_NoMemory();
26439 0 : p->level--;
26440 0 : return NULL;
26441 : }
26442 27138 : Py_ssize_t _children_capacity = 1;
26443 27138 : Py_ssize_t _n = 0;
26444 : { // param_maybe_default
26445 27138 : if (p->error_indicator) {
26446 0 : p->level--;
26447 0 : return NULL;
26448 : }
26449 27138 : 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 56147 : while (
26452 29009 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
26453 : )
26454 : {
26455 1871 : _res = param_maybe_default_var;
26456 1871 : if (_n == _children_capacity) {
26457 614 : _children_capacity *= 2;
26458 614 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26459 614 : if (!_new_children) {
26460 0 : p->error_indicator = 1;
26461 0 : PyErr_NoMemory();
26462 0 : p->level--;
26463 0 : return NULL;
26464 : }
26465 614 : _children = _new_children;
26466 : }
26467 1871 : _children[_n++] = _res;
26468 1871 : _mark = p->mark;
26469 : }
26470 27138 : p->mark = _mark;
26471 27138 : 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 27138 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26475 27138 : if (!_seq) {
26476 0 : PyMem_Free(_children);
26477 0 : p->error_indicator = 1;
26478 0 : PyErr_NoMemory();
26479 0 : p->level--;
26480 0 : return NULL;
26481 : }
26482 29009 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26483 27138 : PyMem_Free(_children);
26484 27138 : _PyPegen_insert_memo(p, _start_mark, _loop0_48_type, _seq);
26485 27138 : p->level--;
26486 27138 : 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 0 : 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 0 : 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 20 : 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 43 : 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 0 : 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 20 : 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 0 : 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 5922 : _loop1_50_rule(Parser *p)
26561 : {
26562 5922 : if (p->level++ == MAXSTACK) {
26563 0 : p->error_indicator = 1;
26564 0 : PyErr_NoMemory();
26565 : }
26566 5922 : if (p->error_indicator) {
26567 0 : p->level--;
26568 0 : return NULL;
26569 : }
26570 5922 : void *_res = NULL;
26571 5922 : int _mark = p->mark;
26572 5922 : int _start_mark = p->mark;
26573 5922 : void **_children = PyMem_Malloc(sizeof(void *));
26574 5922 : if (!_children) {
26575 0 : p->error_indicator = 1;
26576 0 : PyErr_NoMemory();
26577 0 : p->level--;
26578 0 : return NULL;
26579 : }
26580 5922 : Py_ssize_t _children_capacity = 1;
26581 5922 : Py_ssize_t _n = 0;
26582 : { // param_maybe_default
26583 5922 : if (p->error_indicator) {
26584 0 : p->level--;
26585 0 : return NULL;
26586 : }
26587 5922 : 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 28315 : while (
26590 22393 : (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
26591 : )
26592 : {
26593 16471 : _res = param_maybe_default_var;
26594 16471 : if (_n == _children_capacity) {
26595 6739 : _children_capacity *= 2;
26596 6739 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26597 6739 : if (!_new_children) {
26598 0 : p->error_indicator = 1;
26599 0 : PyErr_NoMemory();
26600 0 : p->level--;
26601 0 : return NULL;
26602 : }
26603 6739 : _children = _new_children;
26604 : }
26605 16471 : _children[_n++] = _res;
26606 16471 : _mark = p->mark;
26607 : }
26608 5922 : p->mark = _mark;
26609 5922 : 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 5922 : if (_n == 0 || p->error_indicator) {
26613 13 : PyMem_Free(_children);
26614 13 : p->level--;
26615 13 : return NULL;
26616 : }
26617 5909 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26618 5909 : if (!_seq) {
26619 0 : PyMem_Free(_children);
26620 0 : p->error_indicator = 1;
26621 0 : PyErr_NoMemory();
26622 0 : p->level--;
26623 0 : return NULL;
26624 : }
26625 22380 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26626 5909 : PyMem_Free(_children);
26627 5909 : _PyPegen_insert_memo(p, _start_mark, _loop1_50_type, _seq);
26628 5909 : p->level--;
26629 5909 : return _seq;
26630 : }
26631 :
26632 : // _loop0_52: ',' with_item
26633 : static asdl_seq *
26634 68 : _loop0_52_rule(Parser *p)
26635 : {
26636 68 : if (p->level++ == MAXSTACK) {
26637 0 : p->error_indicator = 1;
26638 0 : PyErr_NoMemory();
26639 : }
26640 68 : if (p->error_indicator) {
26641 0 : p->level--;
26642 0 : return NULL;
26643 : }
26644 68 : void *_res = NULL;
26645 68 : int _mark = p->mark;
26646 68 : int _start_mark = p->mark;
26647 68 : void **_children = PyMem_Malloc(sizeof(void *));
26648 68 : if (!_children) {
26649 0 : p->error_indicator = 1;
26650 0 : PyErr_NoMemory();
26651 0 : p->level--;
26652 0 : return NULL;
26653 : }
26654 68 : Py_ssize_t _children_capacity = 1;
26655 68 : Py_ssize_t _n = 0;
26656 : { // ',' with_item
26657 68 : if (p->error_indicator) {
26658 0 : p->level--;
26659 0 : return NULL;
26660 : }
26661 68 : 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 174 : while (
26665 106 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
26666 47 : &&
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 0 : 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 68 : p->mark = _mark;
26692 68 : 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 68 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26696 68 : if (!_seq) {
26697 0 : PyMem_Free(_children);
26698 0 : p->error_indicator = 1;
26699 0 : PyErr_NoMemory();
26700 0 : p->level--;
26701 0 : return NULL;
26702 : }
26703 106 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26704 68 : PyMem_Free(_children);
26705 68 : _PyPegen_insert_memo(p, _start_mark, _loop0_52_type, _seq);
26706 68 : p->level--;
26707 68 : return _seq;
26708 : }
26709 :
26710 : // _gather_51: with_item _loop0_52
26711 : static asdl_seq *
26712 69 : _gather_51_rule(Parser *p)
26713 : {
26714 69 : if (p->level++ == MAXSTACK) {
26715 0 : p->error_indicator = 1;
26716 0 : PyErr_NoMemory();
26717 : }
26718 69 : if (p->error_indicator) {
26719 0 : p->level--;
26720 0 : return NULL;
26721 : }
26722 69 : asdl_seq * _res = NULL;
26723 69 : int _mark = p->mark;
26724 : { // with_item _loop0_52
26725 69 : if (p->error_indicator) {
26726 0 : p->level--;
26727 0 : return NULL;
26728 : }
26729 69 : 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 69 : if (
26733 69 : (elem = with_item_rule(p)) // with_item
26734 68 : &&
26735 68 : (seq = _loop0_52_rule(p)) // _loop0_52
26736 : )
26737 : {
26738 68 : D(fprintf(stderr, "%*c+ _gather_51[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_52"));
26739 68 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
26740 68 : goto done;
26741 : }
26742 1 : p->mark = _mark;
26743 1 : 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 69 : done:
26748 69 : p->level--;
26749 69 : return _res;
26750 : }
26751 :
26752 : // _loop0_54: ',' with_item
26753 : static asdl_seq *
26754 38584 : _loop0_54_rule(Parser *p)
26755 : {
26756 38584 : if (p->level++ == MAXSTACK) {
26757 0 : p->error_indicator = 1;
26758 0 : PyErr_NoMemory();
26759 : }
26760 38584 : if (p->error_indicator) {
26761 0 : p->level--;
26762 0 : return NULL;
26763 : }
26764 38584 : void *_res = NULL;
26765 38584 : int _mark = p->mark;
26766 38584 : int _start_mark = p->mark;
26767 38584 : void **_children = PyMem_Malloc(sizeof(void *));
26768 38584 : if (!_children) {
26769 0 : p->error_indicator = 1;
26770 0 : PyErr_NoMemory();
26771 0 : p->level--;
26772 0 : return NULL;
26773 : }
26774 38584 : Py_ssize_t _children_capacity = 1;
26775 38584 : Py_ssize_t _n = 0;
26776 : { // ',' with_item
26777 38584 : if (p->error_indicator) {
26778 0 : p->level--;
26779 0 : return NULL;
26780 : }
26781 38584 : 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 77925 : while (
26785 39341 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
26786 758 : &&
26787 758 : (elem = with_item_rule(p)) // with_item
26788 : )
26789 : {
26790 757 : _res = elem;
26791 757 : 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 757 : 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 0 : PyErr_NoMemory();
26803 0 : p->level--;
26804 0 : return NULL;
26805 : }
26806 73 : _children = _new_children;
26807 : }
26808 757 : _children[_n++] = _res;
26809 757 : _mark = p->mark;
26810 : }
26811 38584 : p->mark = _mark;
26812 38584 : 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 38584 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26816 38584 : if (!_seq) {
26817 0 : PyMem_Free(_children);
26818 0 : p->error_indicator = 1;
26819 0 : PyErr_NoMemory();
26820 0 : p->level--;
26821 0 : return NULL;
26822 : }
26823 39341 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26824 38584 : PyMem_Free(_children);
26825 38584 : _PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq);
26826 38584 : p->level--;
26827 38584 : return _seq;
26828 : }
26829 :
26830 : // _gather_53: with_item _loop0_54
26831 : static asdl_seq *
26832 38604 : _gather_53_rule(Parser *p)
26833 : {
26834 38604 : if (p->level++ == MAXSTACK) {
26835 0 : p->error_indicator = 1;
26836 0 : PyErr_NoMemory();
26837 : }
26838 38604 : if (p->error_indicator) {
26839 0 : p->level--;
26840 0 : return NULL;
26841 : }
26842 38604 : asdl_seq * _res = NULL;
26843 38604 : int _mark = p->mark;
26844 : { // with_item _loop0_54
26845 38604 : if (p->error_indicator) {
26846 0 : p->level--;
26847 0 : return NULL;
26848 : }
26849 38604 : 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 38604 : if (
26853 38604 : (elem = with_item_rule(p)) // with_item
26854 38584 : &&
26855 38584 : (seq = _loop0_54_rule(p)) // _loop0_54
26856 : )
26857 : {
26858 38584 : D(fprintf(stderr, "%*c+ _gather_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_54"));
26859 38584 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
26860 38584 : goto done;
26861 : }
26862 20 : p->mark = _mark;
26863 20 : 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 38604 : done:
26868 38604 : p->level--;
26869 38604 : 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 0 : 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 0 : 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 1 : 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 3 : while (
26905 2 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
26906 1 : &&
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 0 : 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 1 : 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 0 : 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 0 : 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 1 : 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 1 : 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 0 : 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 0 : 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 0 : 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 373 : 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 765 : while (
27025 392 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
27026 19 : &&
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 0 : 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 373 : 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 0 : 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 0 : 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 374 : 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 373 : 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 1 : 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 16845 : _tmp_59_rule(Parser *p)
27115 : {
27116 16845 : if (p->level++ == MAXSTACK) {
27117 0 : p->error_indicator = 1;
27118 0 : PyErr_NoMemory();
27119 : }
27120 16845 : if (p->error_indicator) {
27121 0 : p->level--;
27122 0 : return NULL;
27123 : }
27124 16845 : void * _res = NULL;
27125 16845 : int _mark = p->mark;
27126 : { // ','
27127 16845 : if (p->error_indicator) {
27128 0 : p->level--;
27129 0 : return NULL;
27130 : }
27131 16845 : D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
27132 : Token * _literal;
27133 16845 : if (
27134 16845 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
27135 : )
27136 : {
27137 486 : D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
27138 486 : _res = _literal;
27139 486 : goto done;
27140 : }
27141 16359 : p->mark = _mark;
27142 16359 : 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 16359 : if (p->error_indicator) {
27147 0 : p->level--;
27148 0 : return NULL;
27149 : }
27150 16359 : D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
27151 : Token * _literal;
27152 16359 : if (
27153 16359 : (_literal = _PyPegen_expect_token(p, 8)) // token=')'
27154 : )
27155 : {
27156 13 : D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
27157 13 : _res = _literal;
27158 13 : goto done;
27159 : }
27160 16346 : p->mark = _mark;
27161 16346 : 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 16346 : if (p->error_indicator) {
27166 0 : p->level--;
27167 0 : return NULL;
27168 : }
27169 16346 : D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
27170 : Token * _literal;
27171 16346 : if (
27172 16346 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
27173 : )
27174 : {
27175 16336 : D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
27176 16336 : _res = _literal;
27177 16336 : goto done;
27178 : }
27179 10 : p->mark = _mark;
27180 10 : 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 16845 : done:
27185 16845 : p->level--;
27186 16845 : return _res;
27187 : }
27188 :
27189 : // _loop1_60: except_block
27190 : static asdl_seq *
27191 42157 : _loop1_60_rule(Parser *p)
27192 : {
27193 42157 : if (p->level++ == MAXSTACK) {
27194 0 : p->error_indicator = 1;
27195 0 : PyErr_NoMemory();
27196 : }
27197 42157 : if (p->error_indicator) {
27198 0 : p->level--;
27199 0 : return NULL;
27200 : }
27201 42157 : void *_res = NULL;
27202 42157 : int _mark = p->mark;
27203 42157 : int _start_mark = p->mark;
27204 42157 : void **_children = PyMem_Malloc(sizeof(void *));
27205 42157 : if (!_children) {
27206 0 : p->error_indicator = 1;
27207 0 : PyErr_NoMemory();
27208 0 : p->level--;
27209 0 : return NULL;
27210 : }
27211 42157 : Py_ssize_t _children_capacity = 1;
27212 42157 : Py_ssize_t _n = 0;
27213 : { // except_block
27214 42157 : if (p->error_indicator) {
27215 0 : p->level--;
27216 0 : return NULL;
27217 : }
27218 42157 : D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));
27219 : excepthandler_ty except_block_var;
27220 128830 : while (
27221 86673 : (except_block_var = except_block_rule(p)) // except_block
27222 : )
27223 : {
27224 44516 : _res = except_block_var;
27225 44516 : if (_n == _children_capacity) {
27226 2439 : _children_capacity *= 2;
27227 2439 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27228 2439 : if (!_new_children) {
27229 0 : p->error_indicator = 1;
27230 0 : PyErr_NoMemory();
27231 0 : p->level--;
27232 0 : return NULL;
27233 : }
27234 2439 : _children = _new_children;
27235 : }
27236 44516 : _children[_n++] = _res;
27237 44516 : _mark = p->mark;
27238 : }
27239 42157 : p->mark = _mark;
27240 42157 : 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 42157 : if (_n == 0 || p->error_indicator) {
27244 297 : PyMem_Free(_children);
27245 297 : p->level--;
27246 297 : return NULL;
27247 : }
27248 41860 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27249 41860 : if (!_seq) {
27250 0 : PyMem_Free(_children);
27251 0 : p->error_indicator = 1;
27252 0 : PyErr_NoMemory();
27253 0 : p->level--;
27254 0 : return NULL;
27255 : }
27256 86376 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27257 41860 : PyMem_Free(_children);
27258 41860 : _PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq);
27259 41860 : p->level--;
27260 41860 : 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 0 : 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 0 : 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 297 : 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 911 : 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 0 : 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 297 : 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 0 : 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 42367 : _tmp_62_rule(Parser *p)
27340 : {
27341 42367 : if (p->level++ == MAXSTACK) {
27342 0 : p->error_indicator = 1;
27343 0 : PyErr_NoMemory();
27344 : }
27345 42367 : if (p->error_indicator) {
27346 0 : p->level--;
27347 0 : return NULL;
27348 : }
27349 42367 : void * _res = NULL;
27350 42367 : int _mark = p->mark;
27351 : { // 'as' NAME
27352 42367 : if (p->error_indicator) {
27353 0 : p->level--;
27354 0 : return NULL;
27355 : }
27356 42367 : 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 42367 : if (
27360 42367 : (_keyword = _PyPegen_expect_token(p, 632)) // token='as'
27361 9064 : &&
27362 9064 : (z = _PyPegen_name_token(p)) // NAME
27363 : )
27364 : {
27365 9064 : D(fprintf(stderr, "%*c+ _tmp_62[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
27366 9064 : _res = z;
27367 9064 : if (_res == NULL && PyErr_Occurred()) {
27368 0 : p->error_indicator = 1;
27369 0 : p->level--;
27370 0 : return NULL;
27371 : }
27372 9064 : goto done;
27373 : }
27374 33303 : p->mark = _mark;
27375 33303 : 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 33303 : _res = NULL;
27379 42367 : done:
27380 42367 : p->level--;
27381 42367 : 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 0 : 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 339 : 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 129 : 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 210 : 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 1264 : _loop1_64_rule(Parser *p)
27434 : {
27435 1264 : if (p->level++ == MAXSTACK) {
27436 0 : p->error_indicator = 1;
27437 0 : PyErr_NoMemory();
27438 : }
27439 1264 : if (p->error_indicator) {
27440 0 : p->level--;
27441 0 : return NULL;
27442 : }
27443 1264 : void *_res = NULL;
27444 1264 : int _mark = p->mark;
27445 1264 : int _start_mark = p->mark;
27446 1264 : void **_children = PyMem_Malloc(sizeof(void *));
27447 1264 : if (!_children) {
27448 0 : p->error_indicator = 1;
27449 0 : PyErr_NoMemory();
27450 0 : p->level--;
27451 0 : return NULL;
27452 : }
27453 1264 : Py_ssize_t _children_capacity = 1;
27454 1264 : Py_ssize_t _n = 0;
27455 : { // case_block
27456 1264 : if (p->error_indicator) {
27457 0 : p->level--;
27458 0 : return NULL;
27459 : }
27460 1264 : 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 4303 : while (
27463 3039 : (case_block_var = case_block_rule(p)) // case_block
27464 : )
27465 : {
27466 1775 : _res = case_block_var;
27467 1775 : if (_n == _children_capacity) {
27468 512 : _children_capacity *= 2;
27469 512 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27470 512 : if (!_new_children) {
27471 0 : p->error_indicator = 1;
27472 0 : PyErr_NoMemory();
27473 0 : p->level--;
27474 0 : return NULL;
27475 : }
27476 512 : _children = _new_children;
27477 : }
27478 1775 : _children[_n++] = _res;
27479 1775 : _mark = p->mark;
27480 : }
27481 1264 : p->mark = _mark;
27482 1264 : 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 1264 : if (_n == 0 || p->error_indicator) {
27486 45 : PyMem_Free(_children);
27487 45 : p->level--;
27488 45 : return NULL;
27489 : }
27490 1219 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27491 1219 : if (!_seq) {
27492 0 : PyMem_Free(_children);
27493 0 : p->error_indicator = 1;
27494 0 : PyErr_NoMemory();
27495 0 : p->level--;
27496 0 : return NULL;
27497 : }
27498 2993 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27499 1219 : PyMem_Free(_children);
27500 1219 : _PyPegen_insert_memo(p, _start_mark, _loop1_64_type, _seq);
27501 1219 : p->level--;
27502 1219 : return _seq;
27503 : }
27504 :
27505 : // _loop0_66: '|' closed_pattern
27506 : static asdl_seq *
27507 12593 : _loop0_66_rule(Parser *p)
27508 : {
27509 12593 : if (p->level++ == MAXSTACK) {
27510 0 : p->error_indicator = 1;
27511 0 : PyErr_NoMemory();
27512 : }
27513 12593 : if (p->error_indicator) {
27514 0 : p->level--;
27515 0 : return NULL;
27516 : }
27517 12593 : void *_res = NULL;
27518 12593 : int _mark = p->mark;
27519 12593 : int _start_mark = p->mark;
27520 12593 : void **_children = PyMem_Malloc(sizeof(void *));
27521 12593 : if (!_children) {
27522 0 : p->error_indicator = 1;
27523 0 : PyErr_NoMemory();
27524 0 : p->level--;
27525 0 : return NULL;
27526 : }
27527 12593 : Py_ssize_t _children_capacity = 1;
27528 12593 : Py_ssize_t _n = 0;
27529 : { // '|' closed_pattern
27530 12593 : if (p->error_indicator) {
27531 0 : p->level--;
27532 0 : return NULL;
27533 : }
27534 12593 : 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 26414 : while (
27538 13821 : (_literal = _PyPegen_expect_token(p, 18)) // token='|'
27539 1228 : &&
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 0 : 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 12593 : p->mark = _mark;
27565 12593 : 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 12593 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27569 12593 : if (!_seq) {
27570 0 : PyMem_Free(_children);
27571 0 : p->error_indicator = 1;
27572 0 : PyErr_NoMemory();
27573 0 : p->level--;
27574 0 : return NULL;
27575 : }
27576 13821 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27577 12593 : PyMem_Free(_children);
27578 12593 : _PyPegen_insert_memo(p, _start_mark, _loop0_66_type, _seq);
27579 12593 : p->level--;
27580 12593 : return _seq;
27581 : }
27582 :
27583 : // _gather_65: closed_pattern _loop0_66
27584 : static asdl_seq *
27585 13457 : _gather_65_rule(Parser *p)
27586 : {
27587 13457 : if (p->level++ == MAXSTACK) {
27588 0 : p->error_indicator = 1;
27589 0 : PyErr_NoMemory();
27590 : }
27591 13457 : if (p->error_indicator) {
27592 0 : p->level--;
27593 0 : return NULL;
27594 : }
27595 13457 : asdl_seq * _res = NULL;
27596 13457 : int _mark = p->mark;
27597 : { // closed_pattern _loop0_66
27598 13457 : if (p->error_indicator) {
27599 0 : p->level--;
27600 0 : return NULL;
27601 : }
27602 13457 : 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 13457 : if (
27606 13457 : (elem = closed_pattern_rule(p)) // closed_pattern
27607 12593 : &&
27608 12593 : (seq = _loop0_66_rule(p)) // _loop0_66
27609 : )
27610 : {
27611 12593 : D(fprintf(stderr, "%*c+ _gather_65[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "closed_pattern _loop0_66"));
27612 12593 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
27613 12593 : goto done;
27614 : }
27615 864 : p->mark = _mark;
27616 864 : 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 864 : _res = NULL;
27620 13457 : done:
27621 13457 : p->level--;
27622 13457 : 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 0 : 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 1353 : 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 23 : 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 1330 : 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 1330 : 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 20 : 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 1310 : 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 0 : 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 581 : 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 3 : 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 578 : 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 578 : 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 8 : 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 570 : 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 1807 : _tmp_69_rule(Parser *p)
27744 : {
27745 1807 : if (p->level++ == MAXSTACK) {
27746 0 : p->error_indicator = 1;
27747 0 : PyErr_NoMemory();
27748 : }
27749 1807 : if (p->error_indicator) {
27750 0 : p->level--;
27751 0 : return NULL;
27752 : }
27753 1807 : void * _res = NULL;
27754 1807 : int _mark = p->mark;
27755 : { // '.'
27756 1807 : if (p->error_indicator) {
27757 0 : p->level--;
27758 0 : return NULL;
27759 : }
27760 1807 : D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
27761 : Token * _literal;
27762 1807 : if (
27763 1807 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
27764 : )
27765 : {
27766 111 : 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 1696 : p->mark = _mark;
27771 1696 : 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 1696 : if (p->error_indicator) {
27776 0 : p->level--;
27777 0 : return NULL;
27778 : }
27779 1696 : D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
27780 : Token * _literal;
27781 1696 : if (
27782 1696 : (_literal = _PyPegen_expect_token(p, 7)) // token='('
27783 : )
27784 : {
27785 245 : D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
27786 245 : _res = _literal;
27787 245 : goto done;
27788 : }
27789 1451 : p->mark = _mark;
27790 1451 : 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 1451 : if (p->error_indicator) {
27795 0 : p->level--;
27796 0 : return NULL;
27797 : }
27798 1451 : D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
27799 : Token * _literal;
27800 1451 : if (
27801 1451 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
27802 : )
27803 : {
27804 73 : D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));
27805 73 : _res = _literal;
27806 73 : goto done;
27807 : }
27808 1378 : p->mark = _mark;
27809 1378 : D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ',
27810 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
27811 : }
27812 1378 : _res = NULL;
27813 1807 : done:
27814 1807 : p->level--;
27815 1807 : 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 0 : 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 111 : 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 0 : 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 111 : 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 111 : 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 51 : 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 60 : 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 60 : 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 0 : 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 60 : 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 622 : _loop0_72_rule(Parser *p)
27898 : {
27899 622 : if (p->level++ == MAXSTACK) {
27900 0 : p->error_indicator = 1;
27901 0 : PyErr_NoMemory();
27902 : }
27903 622 : if (p->error_indicator) {
27904 0 : p->level--;
27905 0 : return NULL;
27906 : }
27907 622 : void *_res = NULL;
27908 622 : int _mark = p->mark;
27909 622 : int _start_mark = p->mark;
27910 622 : void **_children = PyMem_Malloc(sizeof(void *));
27911 622 : if (!_children) {
27912 0 : p->error_indicator = 1;
27913 0 : PyErr_NoMemory();
27914 0 : p->level--;
27915 0 : return NULL;
27916 : }
27917 622 : Py_ssize_t _children_capacity = 1;
27918 622 : Py_ssize_t _n = 0;
27919 : { // ',' maybe_star_pattern
27920 622 : if (p->error_indicator) {
27921 0 : p->level--;
27922 0 : return NULL;
27923 : }
27924 622 : 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 1988 : while (
27928 1366 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
27929 771 : &&
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 0 : 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 622 : p->mark = _mark;
27955 622 : 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 622 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27959 622 : if (!_seq) {
27960 0 : PyMem_Free(_children);
27961 0 : p->error_indicator = 1;
27962 0 : PyErr_NoMemory();
27963 0 : p->level--;
27964 0 : return NULL;
27965 : }
27966 1366 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27967 622 : PyMem_Free(_children);
27968 622 : _PyPegen_insert_memo(p, _start_mark, _loop0_72_type, _seq);
27969 622 : p->level--;
27970 622 : return _seq;
27971 : }
27972 :
27973 : // _gather_71: maybe_star_pattern _loop0_72
27974 : static asdl_seq *
27975 748 : _gather_71_rule(Parser *p)
27976 : {
27977 748 : if (p->level++ == MAXSTACK) {
27978 0 : p->error_indicator = 1;
27979 0 : PyErr_NoMemory();
27980 : }
27981 748 : if (p->error_indicator) {
27982 0 : p->level--;
27983 0 : return NULL;
27984 : }
27985 748 : asdl_seq * _res = NULL;
27986 748 : int _mark = p->mark;
27987 : { // maybe_star_pattern _loop0_72
27988 748 : if (p->error_indicator) {
27989 0 : p->level--;
27990 0 : return NULL;
27991 : }
27992 748 : 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 748 : if (
27996 748 : (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern
27997 622 : &&
27998 622 : (seq = _loop0_72_rule(p)) // _loop0_72
27999 : )
28000 : {
28001 622 : D(fprintf(stderr, "%*c+ _gather_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_72"));
28002 622 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28003 622 : goto done;
28004 : }
28005 126 : p->mark = _mark;
28006 126 : 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 748 : done:
28011 748 : p->level--;
28012 748 : 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 0 : 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 0 : 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 622 : 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 1384 : while (
28048 762 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
28049 164 : &&
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 0 : 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 622 : 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 0 : 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 0 : 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 645 : 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 622 : 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 23 : 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 0 : 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 809 : 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 754 : 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 55 : 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 52 : 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 8 : 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 44 : 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 0 : 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 0 : 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 276 : D(fprintf(stderr, "%*c> _loop0_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' pattern"));
28223 : Token * _literal;
28224 : pattern_ty elem;
28225 649 : while (
28226 373 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
28227 186 : &&
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 0 : 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 276 : 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 0 : 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 313 : _gather_76_rule(Parser *p)
28274 : {
28275 313 : if (p->level++ == MAXSTACK) {
28276 0 : p->error_indicator = 1;
28277 0 : PyErr_NoMemory();
28278 : }
28279 313 : if (p->error_indicator) {
28280 0 : p->level--;
28281 0 : return NULL;
28282 : }
28283 313 : asdl_seq * _res = NULL;
28284 313 : int _mark = p->mark;
28285 : { // pattern _loop0_77
28286 313 : if (p->error_indicator) {
28287 0 : p->level--;
28288 0 : return NULL;
28289 : }
28290 313 : 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 313 : if (
28294 313 : (elem = pattern_rule(p)) // pattern
28295 276 : &&
28296 276 : (seq = _loop0_77_rule(p)) // _loop0_77
28297 : )
28298 : {
28299 276 : 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 37 : p->mark = _mark;
28304 37 : 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 37 : _res = NULL;
28308 313 : done:
28309 313 : p->level--;
28310 313 : return _res;
28311 : }
28312 :
28313 : // _loop0_79: ',' keyword_pattern
28314 : static asdl_seq *
28315 75 : _loop0_79_rule(Parser *p)
28316 : {
28317 75 : if (p->level++ == MAXSTACK) {
28318 0 : p->error_indicator = 1;
28319 0 : PyErr_NoMemory();
28320 : }
28321 75 : if (p->error_indicator) {
28322 0 : p->level--;
28323 0 : return NULL;
28324 : }
28325 75 : void *_res = NULL;
28326 75 : int _mark = p->mark;
28327 75 : int _start_mark = p->mark;
28328 75 : void **_children = PyMem_Malloc(sizeof(void *));
28329 75 : if (!_children) {
28330 0 : p->error_indicator = 1;
28331 0 : PyErr_NoMemory();
28332 0 : p->level--;
28333 0 : return NULL;
28334 : }
28335 75 : Py_ssize_t _children_capacity = 1;
28336 75 : Py_ssize_t _n = 0;
28337 : { // ',' keyword_pattern
28338 75 : if (p->error_indicator) {
28339 0 : p->level--;
28340 0 : return NULL;
28341 : }
28342 75 : D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' keyword_pattern"));
28343 : Token * _literal;
28344 : KeyPatternPair* elem;
28345 194 : while (
28346 119 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
28347 56 : &&
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 0 : 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 75 : p->mark = _mark;
28373 75 : 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 75 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28377 75 : if (!_seq) {
28378 0 : PyMem_Free(_children);
28379 0 : p->error_indicator = 1;
28380 0 : PyErr_NoMemory();
28381 0 : p->level--;
28382 0 : return NULL;
28383 : }
28384 119 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28385 75 : PyMem_Free(_children);
28386 75 : _PyPegen_insert_memo(p, _start_mark, _loop0_79_type, _seq);
28387 75 : p->level--;
28388 75 : return _seq;
28389 : }
28390 :
28391 : // _gather_78: keyword_pattern _loop0_79
28392 : static asdl_seq *
28393 118 : _gather_78_rule(Parser *p)
28394 : {
28395 118 : if (p->level++ == MAXSTACK) {
28396 0 : p->error_indicator = 1;
28397 0 : PyErr_NoMemory();
28398 : }
28399 118 : if (p->error_indicator) {
28400 0 : p->level--;
28401 0 : return NULL;
28402 : }
28403 118 : asdl_seq * _res = NULL;
28404 118 : int _mark = p->mark;
28405 : { // keyword_pattern _loop0_79
28406 118 : if (p->error_indicator) {
28407 0 : p->level--;
28408 0 : return NULL;
28409 : }
28410 118 : 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 118 : if (
28414 118 : (elem = keyword_pattern_rule(p)) // keyword_pattern
28415 75 : &&
28416 75 : (seq = _loop0_79_rule(p)) // _loop0_79
28417 : )
28418 : {
28419 75 : D(fprintf(stderr, "%*c+ _gather_78[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_79"));
28420 75 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28421 75 : goto done;
28422 : }
28423 43 : p->mark = _mark;
28424 43 : 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 118 : done:
28429 118 : p->level--;
28430 118 : return _res;
28431 : }
28432 :
28433 : // _loop1_80: (',' expression)
28434 : static asdl_seq *
28435 73442 : _loop1_80_rule(Parser *p)
28436 : {
28437 73442 : if (p->level++ == MAXSTACK) {
28438 0 : p->error_indicator = 1;
28439 0 : PyErr_NoMemory();
28440 : }
28441 73442 : if (p->error_indicator) {
28442 0 : p->level--;
28443 0 : return NULL;
28444 : }
28445 73442 : void *_res = NULL;
28446 73442 : int _mark = p->mark;
28447 73442 : int _start_mark = p->mark;
28448 73442 : void **_children = PyMem_Malloc(sizeof(void *));
28449 73442 : if (!_children) {
28450 0 : p->error_indicator = 1;
28451 0 : PyErr_NoMemory();
28452 0 : p->level--;
28453 0 : return NULL;
28454 : }
28455 73442 : Py_ssize_t _children_capacity = 1;
28456 73442 : Py_ssize_t _n = 0;
28457 : { // (',' expression)
28458 73442 : if (p->error_indicator) {
28459 0 : p->level--;
28460 0 : return NULL;
28461 : }
28462 73442 : D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)"));
28463 : void *_tmp_223_var;
28464 588106 : while (
28465 514664 : (_tmp_223_var = _tmp_223_rule(p)) // ',' expression
28466 : )
28467 : {
28468 441222 : _res = _tmp_223_var;
28469 441222 : 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 0 : PyErr_NoMemory();
28475 0 : p->level--;
28476 0 : return NULL;
28477 : }
28478 297 : _children = _new_children;
28479 : }
28480 441222 : _children[_n++] = _res;
28481 441222 : _mark = p->mark;
28482 : }
28483 73442 : p->mark = _mark;
28484 73442 : 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 73442 : if (_n == 0 || p->error_indicator) {
28488 73225 : PyMem_Free(_children);
28489 73225 : p->level--;
28490 73225 : return NULL;
28491 : }
28492 217 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28493 217 : if (!_seq) {
28494 0 : PyMem_Free(_children);
28495 0 : p->error_indicator = 1;
28496 0 : PyErr_NoMemory();
28497 0 : p->level--;
28498 0 : return NULL;
28499 : }
28500 441439 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28501 217 : PyMem_Free(_children);
28502 217 : _PyPegen_insert_memo(p, _start_mark, _loop1_80_type, _seq);
28503 217 : p->level--;
28504 217 : return _seq;
28505 : }
28506 :
28507 : // _loop1_81: (',' star_expression)
28508 : static asdl_seq *
28509 2105940 : _loop1_81_rule(Parser *p)
28510 : {
28511 2105940 : if (p->level++ == MAXSTACK) {
28512 0 : p->error_indicator = 1;
28513 0 : PyErr_NoMemory();
28514 : }
28515 2105940 : if (p->error_indicator) {
28516 0 : p->level--;
28517 0 : return NULL;
28518 : }
28519 2105940 : void *_res = NULL;
28520 2105940 : int _mark = p->mark;
28521 2105940 : int _start_mark = p->mark;
28522 2105940 : void **_children = PyMem_Malloc(sizeof(void *));
28523 2105940 : if (!_children) {
28524 0 : p->error_indicator = 1;
28525 0 : PyErr_NoMemory();
28526 0 : p->level--;
28527 0 : return NULL;
28528 : }
28529 2105940 : Py_ssize_t _children_capacity = 1;
28530 2105940 : Py_ssize_t _n = 0;
28531 : { // (',' star_expression)
28532 2105940 : if (p->error_indicator) {
28533 0 : p->level--;
28534 0 : return NULL;
28535 : }
28536 2105940 : D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)"));
28537 : void *_tmp_224_var;
28538 4240040 : while (
28539 2134100 : (_tmp_224_var = _tmp_224_rule(p)) // ',' star_expression
28540 : )
28541 : {
28542 28158 : _res = _tmp_224_var;
28543 28158 : if (_n == _children_capacity) {
28544 7358 : _children_capacity *= 2;
28545 7358 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28546 7358 : if (!_new_children) {
28547 0 : p->error_indicator = 1;
28548 0 : PyErr_NoMemory();
28549 0 : p->level--;
28550 0 : return NULL;
28551 : }
28552 7358 : _children = _new_children;
28553 : }
28554 28158 : _children[_n++] = _res;
28555 28158 : _mark = p->mark;
28556 : }
28557 2105940 : p->mark = _mark;
28558 2105940 : 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 2105940 : if (_n == 0 || p->error_indicator) {
28562 2086270 : PyMem_Free(_children);
28563 2086270 : p->level--;
28564 2086270 : return NULL;
28565 : }
28566 19674 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28567 19674 : if (!_seq) {
28568 0 : PyMem_Free(_children);
28569 0 : p->error_indicator = 1;
28570 0 : PyErr_NoMemory();
28571 0 : p->level--;
28572 0 : return NULL;
28573 : }
28574 47832 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28575 19674 : PyMem_Free(_children);
28576 19674 : _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq);
28577 19674 : p->level--;
28578 19674 : return _seq;
28579 : }
28580 :
28581 : // _loop0_83: ',' star_named_expression
28582 : static asdl_seq *
28583 650587 : _loop0_83_rule(Parser *p)
28584 : {
28585 650587 : if (p->level++ == MAXSTACK) {
28586 0 : p->error_indicator = 1;
28587 0 : PyErr_NoMemory();
28588 : }
28589 650587 : if (p->error_indicator) {
28590 0 : p->level--;
28591 0 : return NULL;
28592 : }
28593 650587 : void *_res = NULL;
28594 650587 : int _mark = p->mark;
28595 650587 : int _start_mark = p->mark;
28596 650587 : void **_children = PyMem_Malloc(sizeof(void *));
28597 650587 : if (!_children) {
28598 0 : p->error_indicator = 1;
28599 0 : PyErr_NoMemory();
28600 0 : p->level--;
28601 0 : return NULL;
28602 : }
28603 650587 : Py_ssize_t _children_capacity = 1;
28604 650587 : Py_ssize_t _n = 0;
28605 : { // ',' star_named_expression
28606 650587 : if (p->error_indicator) {
28607 0 : p->level--;
28608 0 : return NULL;
28609 : }
28610 650587 : 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 4255850 : while (
28614 3605260 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
28615 2977990 : &&
28616 2977990 : (elem = star_named_expression_rule(p)) // star_named_expression
28617 : )
28618 : {
28619 2954680 : _res = elem;
28620 2954680 : 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 2954680 : if (_n == _children_capacity) {
28627 340444 : _children_capacity *= 2;
28628 340444 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28629 340444 : if (!_new_children) {
28630 0 : p->error_indicator = 1;
28631 0 : PyErr_NoMemory();
28632 0 : p->level--;
28633 0 : return NULL;
28634 : }
28635 340444 : _children = _new_children;
28636 : }
28637 2954680 : _children[_n++] = _res;
28638 2954680 : _mark = p->mark;
28639 : }
28640 650587 : p->mark = _mark;
28641 650587 : 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 650587 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28645 650587 : if (!_seq) {
28646 0 : PyMem_Free(_children);
28647 0 : p->error_indicator = 1;
28648 0 : PyErr_NoMemory();
28649 0 : p->level--;
28650 0 : return NULL;
28651 : }
28652 3605260 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28653 650587 : PyMem_Free(_children);
28654 650587 : _PyPegen_insert_memo(p, _start_mark, _loop0_83_type, _seq);
28655 650587 : p->level--;
28656 650587 : return _seq;
28657 : }
28658 :
28659 : // _gather_82: star_named_expression _loop0_83
28660 : static asdl_seq *
28661 826180 : _gather_82_rule(Parser *p)
28662 : {
28663 826180 : if (p->level++ == MAXSTACK) {
28664 0 : p->error_indicator = 1;
28665 0 : PyErr_NoMemory();
28666 : }
28667 826180 : if (p->error_indicator) {
28668 0 : p->level--;
28669 0 : return NULL;
28670 : }
28671 826180 : asdl_seq * _res = NULL;
28672 826180 : int _mark = p->mark;
28673 : { // star_named_expression _loop0_83
28674 826180 : if (p->error_indicator) {
28675 0 : p->level--;
28676 0 : return NULL;
28677 : }
28678 826180 : 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 826180 : if (
28682 826180 : (elem = star_named_expression_rule(p)) // star_named_expression
28683 650587 : &&
28684 650587 : (seq = _loop0_83_rule(p)) // _loop0_83
28685 : )
28686 : {
28687 650587 : D(fprintf(stderr, "%*c+ _gather_82[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_83"));
28688 650587 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28689 650587 : goto done;
28690 : }
28691 175593 : p->mark = _mark;
28692 175593 : 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 175593 : _res = NULL;
28696 826180 : done:
28697 826180 : p->level--;
28698 826180 : return _res;
28699 : }
28700 :
28701 : // _loop1_84: ('or' conjunction)
28702 : static asdl_seq *
28703 9747010 : _loop1_84_rule(Parser *p)
28704 : {
28705 9747010 : if (p->level++ == MAXSTACK) {
28706 0 : p->error_indicator = 1;
28707 0 : PyErr_NoMemory();
28708 : }
28709 9747010 : if (p->error_indicator) {
28710 0 : p->level--;
28711 0 : return NULL;
28712 : }
28713 9747010 : void *_res = NULL;
28714 9747010 : int _mark = p->mark;
28715 9747010 : int _start_mark = p->mark;
28716 9747010 : void **_children = PyMem_Malloc(sizeof(void *));
28717 9747010 : if (!_children) {
28718 0 : p->error_indicator = 1;
28719 0 : PyErr_NoMemory();
28720 0 : p->level--;
28721 0 : return NULL;
28722 : }
28723 9747010 : Py_ssize_t _children_capacity = 1;
28724 9747010 : Py_ssize_t _n = 0;
28725 : { // ('or' conjunction)
28726 9747010 : if (p->error_indicator) {
28727 0 : p->level--;
28728 0 : return NULL;
28729 : }
28730 9747010 : D(fprintf(stderr, "%*c> _loop1_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)"));
28731 : void *_tmp_225_var;
28732 19523000 : while (
28733 9775950 : (_tmp_225_var = _tmp_225_rule(p)) // 'or' conjunction
28734 : )
28735 : {
28736 28940 : _res = _tmp_225_var;
28737 28940 : if (_n == _children_capacity) {
28738 2367 : _children_capacity *= 2;
28739 2367 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28740 2367 : if (!_new_children) {
28741 0 : p->error_indicator = 1;
28742 0 : PyErr_NoMemory();
28743 0 : p->level--;
28744 0 : return NULL;
28745 : }
28746 2367 : _children = _new_children;
28747 : }
28748 28940 : _children[_n++] = _res;
28749 28940 : _mark = p->mark;
28750 : }
28751 9747010 : p->mark = _mark;
28752 9747010 : 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 9747010 : if (_n == 0 || p->error_indicator) {
28756 9720810 : PyMem_Free(_children);
28757 9720810 : p->level--;
28758 9720810 : return NULL;
28759 : }
28760 26195 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28761 26195 : if (!_seq) {
28762 0 : PyMem_Free(_children);
28763 0 : p->error_indicator = 1;
28764 0 : PyErr_NoMemory();
28765 0 : p->level--;
28766 0 : return NULL;
28767 : }
28768 55135 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28769 26195 : PyMem_Free(_children);
28770 26195 : _PyPegen_insert_memo(p, _start_mark, _loop1_84_type, _seq);
28771 26195 : p->level--;
28772 26195 : return _seq;
28773 : }
28774 :
28775 : // _loop1_85: ('and' inversion)
28776 : static asdl_seq *
28777 9775950 : _loop1_85_rule(Parser *p)
28778 : {
28779 9775950 : if (p->level++ == MAXSTACK) {
28780 0 : p->error_indicator = 1;
28781 0 : PyErr_NoMemory();
28782 : }
28783 9775950 : if (p->error_indicator) {
28784 0 : p->level--;
28785 0 : return NULL;
28786 : }
28787 9775950 : void *_res = NULL;
28788 9775950 : int _mark = p->mark;
28789 9775950 : int _start_mark = p->mark;
28790 9775950 : void **_children = PyMem_Malloc(sizeof(void *));
28791 9775950 : if (!_children) {
28792 0 : p->error_indicator = 1;
28793 0 : PyErr_NoMemory();
28794 0 : p->level--;
28795 0 : return NULL;
28796 : }
28797 9775950 : Py_ssize_t _children_capacity = 1;
28798 9775950 : Py_ssize_t _n = 0;
28799 : { // ('and' inversion)
28800 9775950 : if (p->error_indicator) {
28801 0 : p->level--;
28802 0 : return NULL;
28803 : }
28804 9775950 : D(fprintf(stderr, "%*c> _loop1_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)"));
28805 : void *_tmp_226_var;
28806 19598100 : while (
28807 9822190 : (_tmp_226_var = _tmp_226_rule(p)) // 'and' inversion
28808 : )
28809 : {
28810 46240 : _res = _tmp_226_var;
28811 46240 : if (_n == _children_capacity) {
28812 6045 : _children_capacity *= 2;
28813 6045 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28814 6045 : if (!_new_children) {
28815 0 : p->error_indicator = 1;
28816 0 : PyErr_NoMemory();
28817 0 : p->level--;
28818 0 : return NULL;
28819 : }
28820 6045 : _children = _new_children;
28821 : }
28822 46240 : _children[_n++] = _res;
28823 46240 : _mark = p->mark;
28824 : }
28825 9775950 : p->mark = _mark;
28826 9775950 : 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 9775950 : if (_n == 0 || p->error_indicator) {
28830 9736580 : PyMem_Free(_children);
28831 9736580 : p->level--;
28832 9736580 : return NULL;
28833 : }
28834 39371 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28835 39371 : if (!_seq) {
28836 0 : PyMem_Free(_children);
28837 0 : p->error_indicator = 1;
28838 0 : PyErr_NoMemory();
28839 0 : p->level--;
28840 0 : return NULL;
28841 : }
28842 85611 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28843 39371 : PyMem_Free(_children);
28844 39371 : _PyPegen_insert_memo(p, _start_mark, _loop1_85_type, _seq);
28845 39371 : p->level--;
28846 39371 : return _seq;
28847 : }
28848 :
28849 : // _loop1_86: compare_op_bitwise_or_pair
28850 : static asdl_seq *
28851 9822190 : _loop1_86_rule(Parser *p)
28852 : {
28853 9822190 : if (p->level++ == MAXSTACK) {
28854 0 : p->error_indicator = 1;
28855 0 : PyErr_NoMemory();
28856 : }
28857 9822190 : if (p->error_indicator) {
28858 0 : p->level--;
28859 0 : return NULL;
28860 : }
28861 9822190 : void *_res = NULL;
28862 9822190 : int _mark = p->mark;
28863 9822190 : int _start_mark = p->mark;
28864 9822190 : void **_children = PyMem_Malloc(sizeof(void *));
28865 9822190 : if (!_children) {
28866 0 : p->error_indicator = 1;
28867 0 : PyErr_NoMemory();
28868 0 : p->level--;
28869 0 : return NULL;
28870 : }
28871 9822190 : Py_ssize_t _children_capacity = 1;
28872 9822190 : Py_ssize_t _n = 0;
28873 : { // compare_op_bitwise_or_pair
28874 9822190 : if (p->error_indicator) {
28875 0 : p->level--;
28876 0 : return NULL;
28877 : }
28878 9822190 : 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 19890500 : while (
28881 10068300 : (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p)) // compare_op_bitwise_or_pair
28882 : )
28883 : {
28884 246101 : _res = compare_op_bitwise_or_pair_var;
28885 246101 : if (_n == _children_capacity) {
28886 3157 : _children_capacity *= 2;
28887 3157 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28888 3157 : if (!_new_children) {
28889 0 : p->error_indicator = 1;
28890 0 : PyErr_NoMemory();
28891 0 : p->level--;
28892 0 : return NULL;
28893 : }
28894 3157 : _children = _new_children;
28895 : }
28896 246101 : _children[_n++] = _res;
28897 246101 : _mark = p->mark;
28898 : }
28899 9822190 : p->mark = _mark;
28900 9822190 : 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 9822190 : if (_n == 0 || p->error_indicator) {
28904 9579400 : PyMem_Free(_children);
28905 9579400 : p->level--;
28906 9579400 : return NULL;
28907 : }
28908 242788 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28909 242788 : if (!_seq) {
28910 0 : PyMem_Free(_children);
28911 0 : p->error_indicator = 1;
28912 0 : PyErr_NoMemory();
28913 0 : p->level--;
28914 0 : return NULL;
28915 : }
28916 488889 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28917 242788 : PyMem_Free(_children);
28918 242788 : _PyPegen_insert_memo(p, _start_mark, _loop1_86_type, _seq);
28919 242788 : p->level--;
28920 242788 : return _seq;
28921 : }
28922 :
28923 : // _tmp_87: '!='
28924 : static void *
28925 9996680 : _tmp_87_rule(Parser *p)
28926 : {
28927 9996680 : if (p->level++ == MAXSTACK) {
28928 0 : p->error_indicator = 1;
28929 0 : PyErr_NoMemory();
28930 : }
28931 9996680 : if (p->error_indicator) {
28932 0 : p->level--;
28933 0 : return NULL;
28934 : }
28935 9996680 : void * _res = NULL;
28936 9996680 : int _mark = p->mark;
28937 : { // '!='
28938 9996680 : if (p->error_indicator) {
28939 0 : p->level--;
28940 0 : return NULL;
28941 : }
28942 9996680 : D(fprintf(stderr, "%*c> _tmp_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='"));
28943 : Token * tok;
28944 9996680 : if (
28945 9996680 : (tok = _PyPegen_expect_token(p, 28)) // token='!='
28946 : )
28947 : {
28948 17661 : D(fprintf(stderr, "%*c+ _tmp_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='"));
28949 17661 : _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok;
28950 17661 : if (_res == NULL && PyErr_Occurred()) {
28951 1 : p->error_indicator = 1;
28952 1 : p->level--;
28953 1 : return NULL;
28954 : }
28955 17660 : goto done;
28956 : }
28957 9979020 : p->mark = _mark;
28958 9979020 : D(fprintf(stderr, "%*c%s _tmp_87[%d-%d]: %s failed!\n", p->level, ' ',
28959 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='"));
28960 : }
28961 9979020 : _res = NULL;
28962 9996680 : done:
28963 9996680 : p->level--;
28964 9996680 : 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 0 : 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 0 : 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 21669 : 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 69158 : while (
29000 47489 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
29001 26250 : &&
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 0 : 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 21669 : 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 0 : 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 0 : 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 21764 : 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 21669 : 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 95 : 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 69157 : _tmp_90_rule(Parser *p)
29090 : {
29091 69157 : if (p->level++ == MAXSTACK) {
29092 0 : p->error_indicator = 1;
29093 0 : PyErr_NoMemory();
29094 : }
29095 69157 : if (p->error_indicator) {
29096 0 : p->level--;
29097 0 : return NULL;
29098 : }
29099 69157 : void * _res = NULL;
29100 69157 : int _mark = p->mark;
29101 : { // ':' expression?
29102 69157 : if (p->error_indicator) {
29103 0 : p->level--;
29104 0 : return NULL;
29105 : }
29106 69157 : D(fprintf(stderr, "%*c> _tmp_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?"));
29107 : Token * _literal;
29108 : void *d;
29109 69157 : if (
29110 69157 : (_literal = _PyPegen_expect_token(p, 11)) // token=':'
29111 3186 : &&
29112 3186 : (d = expression_rule(p), !p->error_indicator) // expression?
29113 : )
29114 : {
29115 3182 : D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?"));
29116 3182 : _res = d;
29117 3182 : if (_res == NULL && PyErr_Occurred()) {
29118 0 : p->error_indicator = 1;
29119 0 : p->level--;
29120 0 : return NULL;
29121 : }
29122 3182 : goto done;
29123 : }
29124 65975 : p->mark = _mark;
29125 65975 : 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 65975 : _res = NULL;
29129 69157 : done:
29130 69157 : p->level--;
29131 69157 : return _res;
29132 : }
29133 :
29134 : // _tmp_91: tuple | group | genexp
29135 : static void *
29136 866593 : _tmp_91_rule(Parser *p)
29137 : {
29138 866593 : if (p->level++ == MAXSTACK) {
29139 0 : p->error_indicator = 1;
29140 0 : PyErr_NoMemory();
29141 : }
29142 866593 : if (p->error_indicator) {
29143 0 : p->level--;
29144 0 : return NULL;
29145 : }
29146 866593 : void * _res = NULL;
29147 866593 : int _mark = p->mark;
29148 : { // tuple
29149 866593 : if (p->error_indicator) {
29150 0 : p->level--;
29151 0 : return NULL;
29152 : }
29153 866593 : D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));
29154 : expr_ty tuple_var;
29155 866593 : if (
29156 866593 : (tuple_var = tuple_rule(p)) // tuple
29157 : )
29158 : {
29159 572580 : D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
29160 572580 : _res = tuple_var;
29161 572580 : goto done;
29162 : }
29163 294013 : p->mark = _mark;
29164 294013 : 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 294013 : if (p->error_indicator) {
29169 51 : p->level--;
29170 51 : return NULL;
29171 : }
29172 293962 : D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group"));
29173 : expr_ty group_var;
29174 293962 : if (
29175 293962 : (group_var = group_rule(p)) // group
29176 : )
29177 : {
29178 288434 : D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group"));
29179 288434 : _res = group_var;
29180 288434 : goto done;
29181 : }
29182 5528 : p->mark = _mark;
29183 5528 : 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 5528 : if (p->error_indicator) {
29188 10 : p->level--;
29189 10 : return NULL;
29190 : }
29191 5518 : D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp"));
29192 : expr_ty genexp_var;
29193 5518 : if (
29194 5518 : (genexp_var = genexp_rule(p)) // genexp
29195 : )
29196 : {
29197 5399 : D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"));
29198 5399 : _res = genexp_var;
29199 5399 : goto done;
29200 : }
29201 119 : p->mark = _mark;
29202 119 : 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 866532 : done:
29207 866532 : p->level--;
29208 866532 : return _res;
29209 : }
29210 :
29211 : // _tmp_92: list | listcomp
29212 : static void *
29213 262274 : _tmp_92_rule(Parser *p)
29214 : {
29215 262274 : if (p->level++ == MAXSTACK) {
29216 0 : p->error_indicator = 1;
29217 0 : PyErr_NoMemory();
29218 : }
29219 262274 : if (p->error_indicator) {
29220 0 : p->level--;
29221 0 : return NULL;
29222 : }
29223 262274 : void * _res = NULL;
29224 262274 : int _mark = p->mark;
29225 : { // list
29226 262274 : if (p->error_indicator) {
29227 0 : p->level--;
29228 0 : return NULL;
29229 : }
29230 262274 : D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));
29231 : expr_ty list_var;
29232 262274 : if (
29233 262274 : (list_var = list_rule(p)) // list
29234 : )
29235 : {
29236 232819 : D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
29237 232819 : _res = list_var;
29238 232819 : goto done;
29239 : }
29240 29455 : p->mark = _mark;
29241 29455 : 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 29455 : if (p->error_indicator) {
29246 34 : p->level--;
29247 34 : return NULL;
29248 : }
29249 29421 : D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp"));
29250 : expr_ty listcomp_var;
29251 29421 : if (
29252 29421 : (listcomp_var = listcomp_rule(p)) // listcomp
29253 : )
29254 : {
29255 29332 : D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp"));
29256 29332 : _res = listcomp_var;
29257 29332 : goto done;
29258 : }
29259 89 : p->mark = _mark;
29260 89 : 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 262240 : done:
29265 262240 : p->level--;
29266 262240 : return _res;
29267 : }
29268 :
29269 : // _tmp_93: dict | set | dictcomp | setcomp
29270 : static void *
29271 112966 : _tmp_93_rule(Parser *p)
29272 : {
29273 112966 : if (p->level++ == MAXSTACK) {
29274 0 : p->error_indicator = 1;
29275 0 : PyErr_NoMemory();
29276 : }
29277 112966 : if (p->error_indicator) {
29278 0 : p->level--;
29279 0 : return NULL;
29280 : }
29281 112966 : void * _res = NULL;
29282 112966 : int _mark = p->mark;
29283 : { // dict
29284 112966 : if (p->error_indicator) {
29285 0 : p->level--;
29286 0 : return NULL;
29287 : }
29288 112966 : D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict"));
29289 : expr_ty dict_var;
29290 112966 : if (
29291 112966 : (dict_var = dict_rule(p)) // dict
29292 : )
29293 : {
29294 99192 : D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict"));
29295 99192 : _res = dict_var;
29296 99192 : goto done;
29297 : }
29298 13774 : p->mark = _mark;
29299 13774 : 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 13774 : if (p->error_indicator) {
29304 32 : p->level--;
29305 32 : return NULL;
29306 : }
29307 13742 : D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set"));
29308 : expr_ty set_var;
29309 13742 : if (
29310 13742 : (set_var = set_rule(p)) // set
29311 : )
29312 : {
29313 8371 : D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set"));
29314 8371 : _res = set_var;
29315 8371 : goto done;
29316 : }
29317 5371 : p->mark = _mark;
29318 5371 : 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 5371 : if (p->error_indicator) {
29323 5 : p->level--;
29324 5 : return NULL;
29325 : }
29326 5366 : D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp"));
29327 : expr_ty dictcomp_var;
29328 5366 : if (
29329 5366 : (dictcomp_var = dictcomp_rule(p)) // dictcomp
29330 : )
29331 : {
29332 3788 : D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp"));
29333 3788 : _res = dictcomp_var;
29334 3788 : goto done;
29335 : }
29336 1578 : p->mark = _mark;
29337 1578 : 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 1578 : if (p->error_indicator) {
29342 1 : p->level--;
29343 1 : return NULL;
29344 : }
29345 1577 : D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp"));
29346 : expr_ty setcomp_var;
29347 1577 : if (
29348 1577 : (setcomp_var = setcomp_rule(p)) // setcomp
29349 : )
29350 : {
29351 1519 : D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp"));
29352 1519 : _res = setcomp_var;
29353 1519 : goto done;
29354 : }
29355 58 : p->mark = _mark;
29356 58 : 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 112928 : done:
29361 112928 : p->level--;
29362 112928 : return _res;
29363 : }
29364 :
29365 : // _tmp_94: yield_expr | named_expression
29366 : static void *
29367 293962 : _tmp_94_rule(Parser *p)
29368 : {
29369 293962 : if (p->level++ == MAXSTACK) {
29370 0 : p->error_indicator = 1;
29371 0 : PyErr_NoMemory();
29372 : }
29373 293962 : if (p->error_indicator) {
29374 0 : p->level--;
29375 0 : return NULL;
29376 : }
29377 293962 : void * _res = NULL;
29378 293962 : int _mark = p->mark;
29379 : { // yield_expr
29380 293962 : if (p->error_indicator) {
29381 0 : p->level--;
29382 0 : return NULL;
29383 : }
29384 293962 : D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
29385 : expr_ty yield_expr_var;
29386 293962 : if (
29387 293962 : (yield_expr_var = yield_expr_rule(p)) // yield_expr
29388 : )
29389 : {
29390 520 : D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
29391 520 : _res = yield_expr_var;
29392 520 : goto done;
29393 : }
29394 293442 : p->mark = _mark;
29395 293442 : 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 293442 : if (p->error_indicator) {
29400 0 : p->level--;
29401 0 : return NULL;
29402 : }
29403 293442 : D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
29404 : expr_ty named_expression_var;
29405 293442 : if (
29406 293442 : (named_expression_var = named_expression_rule(p)) // named_expression
29407 : )
29408 : {
29409 293382 : D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
29410 293382 : _res = named_expression_var;
29411 293382 : goto done;
29412 : }
29413 60 : p->mark = _mark;
29414 60 : 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 293962 : done:
29419 293962 : p->level--;
29420 293962 : 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 0 : 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 0 : 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 79 : 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 190 : 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 0 : 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 79 : 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 0 : 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 0 : 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 0 : 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 79 : 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 198 : 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 0 : 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 79 : 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 0 : 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 0 : 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 0 : 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 58 : 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 161 : 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 0 : 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 58 : 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 0 : 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 37423 : _loop1_98_rule(Parser *p)
29633 : {
29634 37423 : if (p->level++ == MAXSTACK) {
29635 0 : p->error_indicator = 1;
29636 0 : PyErr_NoMemory();
29637 : }
29638 37423 : if (p->error_indicator) {
29639 0 : p->level--;
29640 0 : return NULL;
29641 : }
29642 37423 : void *_res = NULL;
29643 37423 : int _mark = p->mark;
29644 37423 : int _start_mark = p->mark;
29645 37423 : void **_children = PyMem_Malloc(sizeof(void *));
29646 37423 : if (!_children) {
29647 0 : p->error_indicator = 1;
29648 0 : PyErr_NoMemory();
29649 0 : p->level--;
29650 0 : return NULL;
29651 : }
29652 37423 : Py_ssize_t _children_capacity = 1;
29653 37423 : Py_ssize_t _n = 0;
29654 : { // lambda_param_no_default
29655 37423 : if (p->error_indicator) {
29656 0 : p->level--;
29657 0 : return NULL;
29658 : }
29659 37423 : 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 243983 : while (
29662 206560 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
29663 : )
29664 : {
29665 169137 : _res = lambda_param_no_default_var;
29666 169137 : if (_n == _children_capacity) {
29667 82224 : _children_capacity *= 2;
29668 82224 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29669 82224 : if (!_new_children) {
29670 0 : p->error_indicator = 1;
29671 0 : PyErr_NoMemory();
29672 0 : p->level--;
29673 0 : return NULL;
29674 : }
29675 82224 : _children = _new_children;
29676 : }
29677 169137 : _children[_n++] = _res;
29678 169137 : _mark = p->mark;
29679 : }
29680 37423 : p->mark = _mark;
29681 37423 : 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 37423 : if (_n == 0 || p->error_indicator) {
29685 3131 : PyMem_Free(_children);
29686 3131 : p->level--;
29687 3131 : return NULL;
29688 : }
29689 34292 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29690 34292 : if (!_seq) {
29691 0 : PyMem_Free(_children);
29692 0 : p->error_indicator = 1;
29693 0 : PyErr_NoMemory();
29694 0 : p->level--;
29695 0 : return NULL;
29696 : }
29697 203429 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29698 34292 : PyMem_Free(_children);
29699 34292 : _PyPegen_insert_memo(p, _start_mark, _loop1_98_type, _seq);
29700 34292 : p->level--;
29701 34292 : return _seq;
29702 : }
29703 :
29704 : // _loop0_99: lambda_param_with_default
29705 : static asdl_seq *
29706 34292 : _loop0_99_rule(Parser *p)
29707 : {
29708 34292 : if (p->level++ == MAXSTACK) {
29709 0 : p->error_indicator = 1;
29710 0 : PyErr_NoMemory();
29711 : }
29712 34292 : if (p->error_indicator) {
29713 0 : p->level--;
29714 0 : return NULL;
29715 : }
29716 34292 : void *_res = NULL;
29717 34292 : int _mark = p->mark;
29718 34292 : int _start_mark = p->mark;
29719 34292 : void **_children = PyMem_Malloc(sizeof(void *));
29720 34292 : if (!_children) {
29721 0 : p->error_indicator = 1;
29722 0 : PyErr_NoMemory();
29723 0 : p->level--;
29724 0 : return NULL;
29725 : }
29726 34292 : Py_ssize_t _children_capacity = 1;
29727 34292 : Py_ssize_t _n = 0;
29728 : { // lambda_param_with_default
29729 34292 : if (p->error_indicator) {
29730 0 : p->level--;
29731 0 : return NULL;
29732 : }
29733 34292 : 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 68686 : while (
29736 34394 : (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 0 : 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 34292 : p->mark = _mark;
29755 34292 : 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 34292 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29759 34292 : if (!_seq) {
29760 0 : PyMem_Free(_children);
29761 0 : p->error_indicator = 1;
29762 0 : PyErr_NoMemory();
29763 0 : p->level--;
29764 0 : return NULL;
29765 : }
29766 34394 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29767 34292 : PyMem_Free(_children);
29768 34292 : _PyPegen_insert_memo(p, _start_mark, _loop0_99_type, _seq);
29769 34292 : p->level--;
29770 34292 : return _seq;
29771 : }
29772 :
29773 : // _loop1_100: lambda_param_with_default
29774 : static asdl_seq *
29775 3131 : _loop1_100_rule(Parser *p)
29776 : {
29777 3131 : if (p->level++ == MAXSTACK) {
29778 0 : p->error_indicator = 1;
29779 0 : PyErr_NoMemory();
29780 : }
29781 3131 : if (p->error_indicator) {
29782 0 : p->level--;
29783 0 : return NULL;
29784 : }
29785 3131 : void *_res = NULL;
29786 3131 : int _mark = p->mark;
29787 3131 : int _start_mark = p->mark;
29788 3131 : void **_children = PyMem_Malloc(sizeof(void *));
29789 3131 : if (!_children) {
29790 0 : p->error_indicator = 1;
29791 0 : PyErr_NoMemory();
29792 0 : p->level--;
29793 0 : return NULL;
29794 : }
29795 3131 : Py_ssize_t _children_capacity = 1;
29796 3131 : Py_ssize_t _n = 0;
29797 : { // lambda_param_with_default
29798 3131 : if (p->error_indicator) {
29799 0 : p->level--;
29800 0 : return NULL;
29801 : }
29802 3131 : 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 6412 : while (
29805 3281 : (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 0 : 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 3131 : p->mark = _mark;
29824 3131 : 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 3131 : if (_n == 0 || p->error_indicator) {
29828 2987 : PyMem_Free(_children);
29829 2987 : p->level--;
29830 2987 : 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 0 : 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 37633 : _loop1_101_rule(Parser *p)
29850 : {
29851 37633 : if (p->level++ == MAXSTACK) {
29852 0 : p->error_indicator = 1;
29853 0 : PyErr_NoMemory();
29854 : }
29855 37633 : if (p->error_indicator) {
29856 0 : p->level--;
29857 0 : return NULL;
29858 : }
29859 37633 : void *_res = NULL;
29860 37633 : int _mark = p->mark;
29861 37633 : int _start_mark = p->mark;
29862 37633 : void **_children = PyMem_Malloc(sizeof(void *));
29863 37633 : if (!_children) {
29864 0 : p->error_indicator = 1;
29865 0 : PyErr_NoMemory();
29866 0 : p->level--;
29867 0 : return NULL;
29868 : }
29869 37633 : Py_ssize_t _children_capacity = 1;
29870 37633 : Py_ssize_t _n = 0;
29871 : { // lambda_param_no_default
29872 37633 : if (p->error_indicator) {
29873 0 : p->level--;
29874 0 : return NULL;
29875 : }
29876 37633 : 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 244536 : while (
29879 206903 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
29880 : )
29881 : {
29882 169270 : _res = lambda_param_no_default_var;
29883 169270 : if (_n == _children_capacity) {
29884 82239 : _children_capacity *= 2;
29885 82239 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29886 82239 : if (!_new_children) {
29887 0 : p->error_indicator = 1;
29888 0 : PyErr_NoMemory();
29889 0 : p->level--;
29890 0 : return NULL;
29891 : }
29892 82239 : _children = _new_children;
29893 : }
29894 169270 : _children[_n++] = _res;
29895 169270 : _mark = p->mark;
29896 : }
29897 37633 : p->mark = _mark;
29898 37633 : 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 37633 : if (_n == 0 || p->error_indicator) {
29902 3223 : PyMem_Free(_children);
29903 3223 : p->level--;
29904 3223 : return NULL;
29905 : }
29906 34410 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29907 34410 : if (!_seq) {
29908 0 : PyMem_Free(_children);
29909 0 : p->error_indicator = 1;
29910 0 : PyErr_NoMemory();
29911 0 : p->level--;
29912 0 : return NULL;
29913 : }
29914 203680 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29915 34410 : PyMem_Free(_children);
29916 34410 : _PyPegen_insert_memo(p, _start_mark, _loop1_101_type, _seq);
29917 34410 : p->level--;
29918 34410 : return _seq;
29919 : }
29920 :
29921 : // _loop1_102: lambda_param_no_default
29922 : static asdl_seq *
29923 37557 : _loop1_102_rule(Parser *p)
29924 : {
29925 37557 : if (p->level++ == MAXSTACK) {
29926 0 : p->error_indicator = 1;
29927 0 : PyErr_NoMemory();
29928 : }
29929 37557 : if (p->error_indicator) {
29930 0 : p->level--;
29931 0 : return NULL;
29932 : }
29933 37557 : void *_res = NULL;
29934 37557 : int _mark = p->mark;
29935 37557 : int _start_mark = p->mark;
29936 37557 : void **_children = PyMem_Malloc(sizeof(void *));
29937 37557 : if (!_children) {
29938 0 : p->error_indicator = 1;
29939 0 : PyErr_NoMemory();
29940 0 : p->level--;
29941 0 : return NULL;
29942 : }
29943 37557 : Py_ssize_t _children_capacity = 1;
29944 37557 : Py_ssize_t _n = 0;
29945 : { // lambda_param_no_default
29946 37557 : if (p->error_indicator) {
29947 0 : p->level--;
29948 0 : return NULL;
29949 : }
29950 37557 : 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 244297 : while (
29953 206740 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
29954 : )
29955 : {
29956 169183 : _res = lambda_param_no_default_var;
29957 169183 : if (_n == _children_capacity) {
29958 82228 : _children_capacity *= 2;
29959 82228 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29960 82228 : if (!_new_children) {
29961 0 : p->error_indicator = 1;
29962 0 : PyErr_NoMemory();
29963 0 : p->level--;
29964 0 : return NULL;
29965 : }
29966 82228 : _children = _new_children;
29967 : }
29968 169183 : _children[_n++] = _res;
29969 169183 : _mark = p->mark;
29970 : }
29971 37557 : p->mark = _mark;
29972 37557 : 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 37557 : if (_n == 0 || p->error_indicator) {
29976 3223 : PyMem_Free(_children);
29977 3223 : p->level--;
29978 3223 : return NULL;
29979 : }
29980 34334 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29981 34334 : if (!_seq) {
29982 0 : PyMem_Free(_children);
29983 0 : p->error_indicator = 1;
29984 0 : PyErr_NoMemory();
29985 0 : p->level--;
29986 0 : return NULL;
29987 : }
29988 203517 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29989 34334 : PyMem_Free(_children);
29990 34334 : _PyPegen_insert_memo(p, _start_mark, _loop1_102_type, _seq);
29991 34334 : p->level--;
29992 34334 : return _seq;
29993 : }
29994 :
29995 : // _loop0_103: lambda_param_no_default
29996 : static asdl_seq *
29997 37596 : _loop0_103_rule(Parser *p)
29998 : {
29999 37596 : if (p->level++ == MAXSTACK) {
30000 0 : p->error_indicator = 1;
30001 0 : PyErr_NoMemory();
30002 : }
30003 37596 : if (p->error_indicator) {
30004 0 : p->level--;
30005 0 : return NULL;
30006 : }
30007 37596 : void *_res = NULL;
30008 37596 : int _mark = p->mark;
30009 37596 : int _start_mark = p->mark;
30010 37596 : void **_children = PyMem_Malloc(sizeof(void *));
30011 37596 : if (!_children) {
30012 0 : p->error_indicator = 1;
30013 0 : PyErr_NoMemory();
30014 0 : p->level--;
30015 0 : return NULL;
30016 : }
30017 37596 : Py_ssize_t _children_capacity = 1;
30018 37596 : Py_ssize_t _n = 0;
30019 : { // lambda_param_no_default
30020 37596 : if (p->error_indicator) {
30021 0 : p->level--;
30022 0 : return NULL;
30023 : }
30024 37596 : 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 244358 : while (
30027 206762 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
30028 : )
30029 : {
30030 169166 : _res = lambda_param_no_default_var;
30031 169166 : if (_n == _children_capacity) {
30032 82224 : _children_capacity *= 2;
30033 82224 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30034 82224 : if (!_new_children) {
30035 0 : p->error_indicator = 1;
30036 0 : PyErr_NoMemory();
30037 0 : p->level--;
30038 0 : return NULL;
30039 : }
30040 82224 : _children = _new_children;
30041 : }
30042 169166 : _children[_n++] = _res;
30043 169166 : _mark = p->mark;
30044 : }
30045 37596 : p->mark = _mark;
30046 37596 : 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 37596 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30050 37596 : if (!_seq) {
30051 0 : PyMem_Free(_children);
30052 0 : p->error_indicator = 1;
30053 0 : PyErr_NoMemory();
30054 0 : p->level--;
30055 0 : return NULL;
30056 : }
30057 206762 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30058 37596 : PyMem_Free(_children);
30059 37596 : _PyPegen_insert_memo(p, _start_mark, _loop0_103_type, _seq);
30060 37596 : p->level--;
30061 37596 : return _seq;
30062 : }
30063 :
30064 : // _loop1_104: lambda_param_with_default
30065 : static asdl_seq *
30066 37596 : _loop1_104_rule(Parser *p)
30067 : {
30068 37596 : if (p->level++ == MAXSTACK) {
30069 0 : p->error_indicator = 1;
30070 0 : PyErr_NoMemory();
30071 : }
30072 37596 : if (p->error_indicator) {
30073 0 : p->level--;
30074 0 : return NULL;
30075 : }
30076 37596 : void *_res = NULL;
30077 37596 : int _mark = p->mark;
30078 37596 : int _start_mark = p->mark;
30079 37596 : void **_children = PyMem_Malloc(sizeof(void *));
30080 37596 : if (!_children) {
30081 0 : p->error_indicator = 1;
30082 0 : PyErr_NoMemory();
30083 0 : p->level--;
30084 0 : return NULL;
30085 : }
30086 37596 : Py_ssize_t _children_capacity = 1;
30087 37596 : Py_ssize_t _n = 0;
30088 : { // lambda_param_with_default
30089 37596 : if (p->error_indicator) {
30090 0 : p->level--;
30091 0 : return NULL;
30092 : }
30093 37596 : 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 75553 : while (
30096 37957 : (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 0 : 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 37596 : p->mark = _mark;
30115 37596 : 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 37596 : if (_n == 0 || p->error_indicator) {
30119 37284 : PyMem_Free(_children);
30120 37284 : p->level--;
30121 37284 : 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 0 : 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 37539 : _loop0_105_rule(Parser *p)
30141 : {
30142 37539 : if (p->level++ == MAXSTACK) {
30143 0 : p->error_indicator = 1;
30144 0 : PyErr_NoMemory();
30145 : }
30146 37539 : if (p->error_indicator) {
30147 0 : p->level--;
30148 0 : return NULL;
30149 : }
30150 37539 : void *_res = NULL;
30151 37539 : int _mark = p->mark;
30152 37539 : int _start_mark = p->mark;
30153 37539 : void **_children = PyMem_Malloc(sizeof(void *));
30154 37539 : if (!_children) {
30155 0 : p->error_indicator = 1;
30156 0 : PyErr_NoMemory();
30157 0 : p->level--;
30158 0 : return NULL;
30159 : }
30160 37539 : Py_ssize_t _children_capacity = 1;
30161 37539 : Py_ssize_t _n = 0;
30162 : { // lambda_param_no_default
30163 37539 : if (p->error_indicator) {
30164 0 : p->level--;
30165 0 : return NULL;
30166 : }
30167 37539 : 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 244243 : while (
30170 206704 : (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
30171 : )
30172 : {
30173 169165 : _res = lambda_param_no_default_var;
30174 169165 : if (_n == _children_capacity) {
30175 82224 : _children_capacity *= 2;
30176 82224 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30177 82224 : if (!_new_children) {
30178 0 : p->error_indicator = 1;
30179 0 : PyErr_NoMemory();
30180 0 : p->level--;
30181 0 : return NULL;
30182 : }
30183 82224 : _children = _new_children;
30184 : }
30185 169165 : _children[_n++] = _res;
30186 169165 : _mark = p->mark;
30187 : }
30188 37539 : p->mark = _mark;
30189 37539 : 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 37539 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30193 37539 : if (!_seq) {
30194 0 : PyMem_Free(_children);
30195 0 : p->error_indicator = 1;
30196 0 : PyErr_NoMemory();
30197 0 : p->level--;
30198 0 : return NULL;
30199 : }
30200 206704 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30201 37539 : PyMem_Free(_children);
30202 37539 : _PyPegen_insert_memo(p, _start_mark, _loop0_105_type, _seq);
30203 37539 : p->level--;
30204 37539 : return _seq;
30205 : }
30206 :
30207 : // _loop1_106: lambda_param_with_default
30208 : static asdl_seq *
30209 37539 : _loop1_106_rule(Parser *p)
30210 : {
30211 37539 : if (p->level++ == MAXSTACK) {
30212 0 : p->error_indicator = 1;
30213 0 : PyErr_NoMemory();
30214 : }
30215 37539 : if (p->error_indicator) {
30216 0 : p->level--;
30217 0 : return NULL;
30218 : }
30219 37539 : void *_res = NULL;
30220 37539 : int _mark = p->mark;
30221 37539 : int _start_mark = p->mark;
30222 37539 : void **_children = PyMem_Malloc(sizeof(void *));
30223 37539 : if (!_children) {
30224 0 : p->error_indicator = 1;
30225 0 : PyErr_NoMemory();
30226 0 : p->level--;
30227 0 : return NULL;
30228 : }
30229 37539 : Py_ssize_t _children_capacity = 1;
30230 37539 : Py_ssize_t _n = 0;
30231 : { // lambda_param_with_default
30232 37539 : if (p->error_indicator) {
30233 0 : p->level--;
30234 0 : return NULL;
30235 : }
30236 37539 : 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 75347 : while (
30239 37808 : (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 0 : 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 37539 : p->mark = _mark;
30258 37539 : 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 37539 : if (_n == 0 || p->error_indicator) {
30262 37282 : PyMem_Free(_children);
30263 37282 : p->level--;
30264 37282 : 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 0 : 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 302 : _loop0_107_rule(Parser *p)
30284 : {
30285 302 : if (p->level++ == MAXSTACK) {
30286 0 : p->error_indicator = 1;
30287 0 : PyErr_NoMemory();
30288 : }
30289 302 : if (p->error_indicator) {
30290 0 : p->level--;
30291 0 : return NULL;
30292 : }
30293 302 : void *_res = NULL;
30294 302 : int _mark = p->mark;
30295 302 : int _start_mark = p->mark;
30296 302 : void **_children = PyMem_Malloc(sizeof(void *));
30297 302 : if (!_children) {
30298 0 : p->error_indicator = 1;
30299 0 : PyErr_NoMemory();
30300 0 : p->level--;
30301 0 : return NULL;
30302 : }
30303 302 : Py_ssize_t _children_capacity = 1;
30304 302 : Py_ssize_t _n = 0;
30305 : { // lambda_param_maybe_default
30306 302 : if (p->error_indicator) {
30307 0 : p->level--;
30308 0 : return NULL;
30309 : }
30310 302 : 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 679 : while (
30313 377 : (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 0 : 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 302 : p->mark = _mark;
30332 302 : 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 302 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30336 302 : if (!_seq) {
30337 0 : PyMem_Free(_children);
30338 0 : p->error_indicator = 1;
30339 0 : PyErr_NoMemory();
30340 0 : p->level--;
30341 0 : return NULL;
30342 : }
30343 377 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30344 302 : PyMem_Free(_children);
30345 302 : _PyPegen_insert_memo(p, _start_mark, _loop0_107_type, _seq);
30346 302 : p->level--;
30347 302 : 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 0 : 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 0 : 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 103 : 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 347 : 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 0 : 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 103 : 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 0 : 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 1611000 : _loop1_109_rule(Parser *p)
30427 : {
30428 1611000 : if (p->level++ == MAXSTACK) {
30429 0 : p->error_indicator = 1;
30430 0 : PyErr_NoMemory();
30431 : }
30432 1611000 : if (p->error_indicator) {
30433 0 : p->level--;
30434 0 : return NULL;
30435 : }
30436 1611000 : void *_res = NULL;
30437 1611000 : int _mark = p->mark;
30438 1611000 : int _start_mark = p->mark;
30439 1611000 : void **_children = PyMem_Malloc(sizeof(void *));
30440 1611000 : if (!_children) {
30441 0 : p->error_indicator = 1;
30442 0 : PyErr_NoMemory();
30443 0 : p->level--;
30444 0 : return NULL;
30445 : }
30446 1611000 : Py_ssize_t _children_capacity = 1;
30447 1611000 : Py_ssize_t _n = 0;
30448 : { // STRING
30449 1611000 : if (p->error_indicator) {
30450 0 : p->level--;
30451 0 : return NULL;
30452 : }
30453 1611000 : D(fprintf(stderr, "%*c> _loop1_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING"));
30454 : expr_ty string_var;
30455 4913450 : while (
30456 3302440 : (string_var = _PyPegen_string_token(p)) // STRING
30457 : )
30458 : {
30459 1691440 : _res = string_var;
30460 1691440 : if (_n == _children_capacity) {
30461 25957 : _children_capacity *= 2;
30462 25957 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30463 25957 : if (!_new_children) {
30464 0 : p->error_indicator = 1;
30465 0 : PyErr_NoMemory();
30466 0 : p->level--;
30467 0 : return NULL;
30468 : }
30469 25957 : _children = _new_children;
30470 : }
30471 1691440 : _children[_n++] = _res;
30472 1691440 : _mark = p->mark;
30473 : }
30474 1611000 : p->mark = _mark;
30475 1611000 : 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 1611000 : if (_n == 0 || p->error_indicator) {
30479 3328 : PyMem_Free(_children);
30480 3328 : p->level--;
30481 3328 : return NULL;
30482 : }
30483 1607680 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30484 1607680 : if (!_seq) {
30485 0 : PyMem_Free(_children);
30486 0 : p->error_indicator = 1;
30487 0 : PyErr_NoMemory();
30488 0 : p->level--;
30489 0 : return NULL;
30490 : }
30491 3299110 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30492 1607680 : PyMem_Free(_children);
30493 1607680 : _PyPegen_insert_memo(p, _start_mark, _loop1_109_type, _seq);
30494 1607680 : p->level--;
30495 1607680 : return _seq;
30496 : }
30497 :
30498 : // _tmp_110: star_named_expression ',' star_named_expressions?
30499 : static void *
30500 866646 : _tmp_110_rule(Parser *p)
30501 : {
30502 866646 : if (p->level++ == MAXSTACK) {
30503 0 : p->error_indicator = 1;
30504 0 : PyErr_NoMemory();
30505 : }
30506 866646 : if (p->error_indicator) {
30507 0 : p->level--;
30508 0 : return NULL;
30509 : }
30510 866646 : void * _res = NULL;
30511 866646 : int _mark = p->mark;
30512 : { // star_named_expression ',' star_named_expressions?
30513 866646 : if (p->error_indicator) {
30514 0 : p->level--;
30515 0 : return NULL;
30516 : }
30517 866646 : 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 866646 : if (
30522 866646 : (y = star_named_expression_rule(p)) // star_named_expression
30523 843531 : &&
30524 843531 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
30525 550114 : &&
30526 550114 : (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions?
30527 : )
30528 : {
30529 550097 : D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
30530 550097 : _res = _PyPegen_seq_insert_in_front ( p , y , z );
30531 550097 : if (_res == NULL && PyErr_Occurred()) {
30532 0 : p->error_indicator = 1;
30533 0 : p->level--;
30534 0 : return NULL;
30535 : }
30536 550097 : goto done;
30537 : }
30538 316549 : p->mark = _mark;
30539 316549 : 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 316549 : _res = NULL;
30543 866646 : done:
30544 866646 : p->level--;
30545 866646 : return _res;
30546 : }
30547 :
30548 : // _loop0_112: ',' double_starred_kvpair
30549 : static asdl_seq *
30550 65010 : _loop0_112_rule(Parser *p)
30551 : {
30552 65010 : if (p->level++ == MAXSTACK) {
30553 0 : p->error_indicator = 1;
30554 0 : PyErr_NoMemory();
30555 : }
30556 65010 : if (p->error_indicator) {
30557 0 : p->level--;
30558 0 : return NULL;
30559 : }
30560 65010 : void *_res = NULL;
30561 65010 : int _mark = p->mark;
30562 65010 : int _start_mark = p->mark;
30563 65010 : void **_children = PyMem_Malloc(sizeof(void *));
30564 65010 : if (!_children) {
30565 0 : p->error_indicator = 1;
30566 0 : PyErr_NoMemory();
30567 0 : p->level--;
30568 0 : return NULL;
30569 : }
30570 65010 : Py_ssize_t _children_capacity = 1;
30571 65010 : Py_ssize_t _n = 0;
30572 : { // ',' double_starred_kvpair
30573 65010 : if (p->error_indicator) {
30574 0 : p->level--;
30575 0 : return NULL;
30576 : }
30577 65010 : 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 1589310 : while (
30581 1524300 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
30582 1481730 : &&
30583 1481730 : (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
30584 : )
30585 : {
30586 1459290 : _res = elem;
30587 1459290 : 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 1459290 : if (_n == _children_capacity) {
30594 109337 : _children_capacity *= 2;
30595 109337 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30596 109337 : if (!_new_children) {
30597 0 : p->error_indicator = 1;
30598 0 : PyErr_NoMemory();
30599 0 : p->level--;
30600 0 : return NULL;
30601 : }
30602 109337 : _children = _new_children;
30603 : }
30604 1459290 : _children[_n++] = _res;
30605 1459290 : _mark = p->mark;
30606 : }
30607 65010 : p->mark = _mark;
30608 65010 : 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 65010 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30612 65010 : if (!_seq) {
30613 0 : PyMem_Free(_children);
30614 0 : p->error_indicator = 1;
30615 0 : PyErr_NoMemory();
30616 0 : p->level--;
30617 0 : return NULL;
30618 : }
30619 1524300 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30620 65010 : PyMem_Free(_children);
30621 65010 : _PyPegen_insert_memo(p, _start_mark, _loop0_112_type, _seq);
30622 65010 : p->level--;
30623 65010 : return _seq;
30624 : }
30625 :
30626 : // _gather_111: double_starred_kvpair _loop0_112
30627 : static asdl_seq *
30628 112966 : _gather_111_rule(Parser *p)
30629 : {
30630 112966 : if (p->level++ == MAXSTACK) {
30631 0 : p->error_indicator = 1;
30632 0 : PyErr_NoMemory();
30633 : }
30634 112966 : if (p->error_indicator) {
30635 0 : p->level--;
30636 0 : return NULL;
30637 : }
30638 112966 : asdl_seq * _res = NULL;
30639 112966 : int _mark = p->mark;
30640 : { // double_starred_kvpair _loop0_112
30641 112966 : if (p->error_indicator) {
30642 0 : p->level--;
30643 0 : return NULL;
30644 : }
30645 112966 : 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 112966 : if (
30649 112966 : (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
30650 65010 : &&
30651 65010 : (seq = _loop0_112_rule(p)) // _loop0_112
30652 : )
30653 : {
30654 65010 : D(fprintf(stderr, "%*c+ _gather_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_112"));
30655 65010 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
30656 65010 : goto done;
30657 : }
30658 47956 : p->mark = _mark;
30659 47956 : 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 47956 : _res = NULL;
30663 112966 : done:
30664 112966 : p->level--;
30665 112966 : return _res;
30666 : }
30667 :
30668 : // _loop1_113: for_if_clause
30669 : static asdl_seq *
30670 2133110 : _loop1_113_rule(Parser *p)
30671 : {
30672 2133110 : if (p->level++ == MAXSTACK) {
30673 0 : p->error_indicator = 1;
30674 0 : PyErr_NoMemory();
30675 : }
30676 2133110 : if (p->error_indicator) {
30677 0 : p->level--;
30678 0 : return NULL;
30679 : }
30680 2133110 : void *_res = NULL;
30681 2133110 : int _mark = p->mark;
30682 2133110 : int _start_mark = p->mark;
30683 2133110 : void **_children = PyMem_Malloc(sizeof(void *));
30684 2133110 : if (!_children) {
30685 0 : p->error_indicator = 1;
30686 0 : PyErr_NoMemory();
30687 0 : p->level--;
30688 0 : return NULL;
30689 : }
30690 2133110 : Py_ssize_t _children_capacity = 1;
30691 2133110 : Py_ssize_t _n = 0;
30692 : { // for_if_clause
30693 2133110 : if (p->error_indicator) {
30694 0 : p->level--;
30695 0 : return NULL;
30696 : }
30697 2133110 : 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 4318110 : while (
30700 2185000 : (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause
30701 : )
30702 : {
30703 51889 : _res = for_if_clause_var;
30704 51889 : if (_n == _children_capacity) {
30705 2004 : _children_capacity *= 2;
30706 2004 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30707 2004 : if (!_new_children) {
30708 0 : p->error_indicator = 1;
30709 0 : PyErr_NoMemory();
30710 0 : p->level--;
30711 0 : return NULL;
30712 : }
30713 2004 : _children = _new_children;
30714 : }
30715 51889 : _children[_n++] = _res;
30716 51889 : _mark = p->mark;
30717 : }
30718 2133110 : p->mark = _mark;
30719 2133110 : 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 2133110 : if (_n == 0 || p->error_indicator) {
30723 2083230 : PyMem_Free(_children);
30724 2083230 : p->level--;
30725 2083230 : return NULL;
30726 : }
30727 49885 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30728 49885 : if (!_seq) {
30729 0 : PyMem_Free(_children);
30730 0 : p->error_indicator = 1;
30731 0 : PyErr_NoMemory();
30732 0 : p->level--;
30733 0 : return NULL;
30734 : }
30735 101774 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30736 49885 : PyMem_Free(_children);
30737 49885 : _PyPegen_insert_memo(p, _start_mark, _loop1_113_type, _seq);
30738 49885 : p->level--;
30739 49885 : 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 0 : 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 0 : 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 508 : D(fprintf(stderr, "%*c> _loop0_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
30772 : void *_tmp_228_var;
30773 1076 : 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 0 : 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 508 : 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 0 : 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 51383 : _loop0_115_rule(Parser *p)
30814 : {
30815 51383 : if (p->level++ == MAXSTACK) {
30816 0 : p->error_indicator = 1;
30817 0 : PyErr_NoMemory();
30818 : }
30819 51383 : if (p->error_indicator) {
30820 0 : p->level--;
30821 0 : return NULL;
30822 : }
30823 51383 : void *_res = NULL;
30824 51383 : int _mark = p->mark;
30825 51383 : int _start_mark = p->mark;
30826 51383 : void **_children = PyMem_Malloc(sizeof(void *));
30827 51383 : if (!_children) {
30828 0 : p->error_indicator = 1;
30829 0 : PyErr_NoMemory();
30830 0 : p->level--;
30831 0 : return NULL;
30832 : }
30833 51383 : Py_ssize_t _children_capacity = 1;
30834 51383 : Py_ssize_t _n = 0;
30835 : { // ('if' disjunction)
30836 51383 : if (p->error_indicator) {
30837 0 : p->level--;
30838 0 : return NULL;
30839 : }
30840 51383 : D(fprintf(stderr, "%*c> _loop0_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
30841 : void *_tmp_229_var;
30842 115342 : while (
30843 63959 : (_tmp_229_var = _tmp_229_rule(p)) // 'if' disjunction
30844 : )
30845 : {
30846 12576 : _res = _tmp_229_var;
30847 12576 : 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 0 : PyErr_NoMemory();
30853 0 : p->level--;
30854 0 : return NULL;
30855 : }
30856 22 : _children = _new_children;
30857 : }
30858 12576 : _children[_n++] = _res;
30859 12576 : _mark = p->mark;
30860 : }
30861 51383 : p->mark = _mark;
30862 51383 : 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 51383 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30866 51383 : if (!_seq) {
30867 0 : PyMem_Free(_children);
30868 0 : p->error_indicator = 1;
30869 0 : PyErr_NoMemory();
30870 0 : p->level--;
30871 0 : return NULL;
30872 : }
30873 63959 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30874 51383 : PyMem_Free(_children);
30875 51383 : _PyPegen_insert_memo(p, _start_mark, _loop0_115_type, _seq);
30876 51383 : p->level--;
30877 51383 : return _seq;
30878 : }
30879 :
30880 : // _tmp_116: assignment_expression | expression !':='
30881 : static void *
30882 3099980 : _tmp_116_rule(Parser *p)
30883 : {
30884 3099980 : if (p->level++ == MAXSTACK) {
30885 0 : p->error_indicator = 1;
30886 0 : PyErr_NoMemory();
30887 : }
30888 3099980 : if (p->error_indicator) {
30889 0 : p->level--;
30890 0 : return NULL;
30891 : }
30892 3099980 : void * _res = NULL;
30893 3099980 : int _mark = p->mark;
30894 : { // assignment_expression
30895 3099980 : if (p->error_indicator) {
30896 0 : p->level--;
30897 0 : return NULL;
30898 : }
30899 3099980 : D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
30900 : expr_ty assignment_expression_var;
30901 3099980 : if (
30902 3099980 : (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
30903 : )
30904 : {
30905 58 : 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 3099920 : p->mark = _mark;
30910 3099920 : 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 3099920 : if (p->error_indicator) {
30915 27 : p->level--;
30916 27 : return NULL;
30917 : }
30918 3099890 : D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
30919 : expr_ty expression_var;
30920 3099890 : if (
30921 3099890 : (expression_var = expression_rule(p)) // expression
30922 2098060 : &&
30923 2098060 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
30924 : )
30925 : {
30926 2098060 : D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
30927 2098060 : _res = expression_var;
30928 2098060 : goto done;
30929 : }
30930 1001840 : p->mark = _mark;
30931 1001840 : 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 1001840 : _res = NULL;
30935 3099950 : done:
30936 3099950 : p->level--;
30937 3099950 : return _res;
30938 : }
30939 :
30940 : // _loop0_118: ',' (starred_expression | (assignment_expression | expression !':=') !'=')
30941 : static asdl_seq *
30942 1349900 : _loop0_118_rule(Parser *p)
30943 : {
30944 1349900 : if (p->level++ == MAXSTACK) {
30945 0 : p->error_indicator = 1;
30946 0 : PyErr_NoMemory();
30947 : }
30948 1349900 : if (p->error_indicator) {
30949 0 : p->level--;
30950 0 : return NULL;
30951 : }
30952 1349900 : void *_res = NULL;
30953 1349900 : int _mark = p->mark;
30954 1349900 : int _start_mark = p->mark;
30955 1349900 : void **_children = PyMem_Malloc(sizeof(void *));
30956 1349900 : if (!_children) {
30957 0 : p->error_indicator = 1;
30958 0 : PyErr_NoMemory();
30959 0 : p->level--;
30960 0 : return NULL;
30961 : }
30962 1349900 : Py_ssize_t _children_capacity = 1;
30963 1349900 : Py_ssize_t _n = 0;
30964 : { // ',' (starred_expression | (assignment_expression | expression !':=') !'=')
30965 1349900 : if (p->error_indicator) {
30966 0 : p->level--;
30967 0 : return NULL;
30968 : }
30969 1349900 : 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 3452510 : while (
30973 2102610 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
30974 825455 : &&
30975 825455 : (elem = _tmp_230_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'='
30976 : )
30977 : {
30978 752713 : _res = elem;
30979 752713 : 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 752713 : if (_n == _children_capacity) {
30986 165958 : _children_capacity *= 2;
30987 165958 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30988 165958 : if (!_new_children) {
30989 0 : p->error_indicator = 1;
30990 0 : PyErr_NoMemory();
30991 0 : p->level--;
30992 0 : return NULL;
30993 : }
30994 165958 : _children = _new_children;
30995 : }
30996 752713 : _children[_n++] = _res;
30997 752713 : _mark = p->mark;
30998 : }
30999 1349900 : p->mark = _mark;
31000 1349900 : 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 1349900 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31004 1349900 : if (!_seq) {
31005 0 : PyMem_Free(_children);
31006 0 : p->error_indicator = 1;
31007 0 : PyErr_NoMemory();
31008 0 : p->level--;
31009 0 : return NULL;
31010 : }
31011 2102610 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31012 1349900 : PyMem_Free(_children);
31013 1349900 : _PyPegen_insert_memo(p, _start_mark, _loop0_118_type, _seq);
31014 1349900 : p->level--;
31015 1349900 : return _seq;
31016 : }
31017 :
31018 : // _gather_117:
31019 : // | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118
31020 : static asdl_seq *
31021 1934900 : _gather_117_rule(Parser *p)
31022 : {
31023 1934900 : if (p->level++ == MAXSTACK) {
31024 0 : p->error_indicator = 1;
31025 0 : PyErr_NoMemory();
31026 : }
31027 1934900 : if (p->error_indicator) {
31028 0 : p->level--;
31029 0 : return NULL;
31030 : }
31031 1934900 : asdl_seq * _res = NULL;
31032 1934900 : int _mark = p->mark;
31033 : { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118
31034 1934900 : if (p->error_indicator) {
31035 0 : p->level--;
31036 0 : return NULL;
31037 : }
31038 1934900 : 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 1934900 : if (
31042 1934900 : (elem = _tmp_230_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'='
31043 1349900 : &&
31044 1349900 : (seq = _loop0_118_rule(p)) // _loop0_118
31045 : )
31046 : {
31047 1349900 : D(fprintf(stderr, "%*c+ _gather_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_118"));
31048 1349900 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31049 1349900 : goto done;
31050 : }
31051 585005 : p->mark = _mark;
31052 585005 : 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 585005 : _res = NULL;
31056 1934900 : done:
31057 1934900 : p->level--;
31058 1934900 : return _res;
31059 : }
31060 :
31061 : // _tmp_119: ',' kwargs
31062 : static void *
31063 1349900 : _tmp_119_rule(Parser *p)
31064 : {
31065 1349900 : if (p->level++ == MAXSTACK) {
31066 0 : p->error_indicator = 1;
31067 0 : PyErr_NoMemory();
31068 : }
31069 1349900 : if (p->error_indicator) {
31070 14 : p->level--;
31071 14 : return NULL;
31072 : }
31073 1349880 : void * _res = NULL;
31074 1349880 : int _mark = p->mark;
31075 : { // ',' kwargs
31076 1349880 : if (p->error_indicator) {
31077 0 : p->level--;
31078 0 : return NULL;
31079 : }
31080 1349880 : D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs"));
31081 : Token * _literal;
31082 : asdl_seq* k;
31083 1349880 : if (
31084 1349880 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31085 72728 : &&
31086 72728 : (k = kwargs_rule(p)) // kwargs
31087 : )
31088 : {
31089 67638 : D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs"));
31090 67638 : _res = k;
31091 67638 : if (_res == NULL && PyErr_Occurred()) {
31092 0 : p->error_indicator = 1;
31093 0 : p->level--;
31094 0 : return NULL;
31095 : }
31096 67638 : goto done;
31097 : }
31098 1282250 : p->mark = _mark;
31099 1282250 : 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 1282250 : _res = NULL;
31103 1349880 : done:
31104 1349880 : p->level--;
31105 1349880 : return _res;
31106 : }
31107 :
31108 : // _loop0_121: ',' kwarg_or_starred
31109 : static asdl_seq *
31110 98915 : _loop0_121_rule(Parser *p)
31111 : {
31112 98915 : if (p->level++ == MAXSTACK) {
31113 0 : p->error_indicator = 1;
31114 0 : PyErr_NoMemory();
31115 : }
31116 98915 : if (p->error_indicator) {
31117 0 : p->level--;
31118 0 : return NULL;
31119 : }
31120 98915 : void *_res = NULL;
31121 98915 : int _mark = p->mark;
31122 98915 : int _start_mark = p->mark;
31123 98915 : void **_children = PyMem_Malloc(sizeof(void *));
31124 98915 : if (!_children) {
31125 0 : p->error_indicator = 1;
31126 0 : PyErr_NoMemory();
31127 0 : p->level--;
31128 0 : return NULL;
31129 : }
31130 98915 : Py_ssize_t _children_capacity = 1;
31131 98915 : Py_ssize_t _n = 0;
31132 : { // ',' kwarg_or_starred
31133 98915 : if (p->error_indicator) {
31134 0 : p->level--;
31135 0 : return NULL;
31136 : }
31137 98915 : 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 274461 : while (
31141 175546 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31142 85190 : &&
31143 85190 : (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
31144 : )
31145 : {
31146 76631 : _res = elem;
31147 76631 : 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 76631 : if (_n == _children_capacity) {
31154 29887 : _children_capacity *= 2;
31155 29887 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31156 29887 : if (!_new_children) {
31157 0 : p->error_indicator = 1;
31158 0 : PyErr_NoMemory();
31159 0 : p->level--;
31160 0 : return NULL;
31161 : }
31162 29887 : _children = _new_children;
31163 : }
31164 76631 : _children[_n++] = _res;
31165 76631 : _mark = p->mark;
31166 : }
31167 98915 : p->mark = _mark;
31168 98915 : 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 98915 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31172 98915 : if (!_seq) {
31173 0 : PyMem_Free(_children);
31174 0 : p->error_indicator = 1;
31175 0 : PyErr_NoMemory();
31176 0 : p->level--;
31177 0 : return NULL;
31178 : }
31179 175546 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31180 98915 : PyMem_Free(_children);
31181 98915 : _PyPegen_insert_memo(p, _start_mark, _loop0_121_type, _seq);
31182 98915 : p->level--;
31183 98915 : return _seq;
31184 : }
31185 :
31186 : // _gather_120: kwarg_or_starred _loop0_121
31187 : static asdl_seq *
31188 657731 : _gather_120_rule(Parser *p)
31189 : {
31190 657731 : if (p->level++ == MAXSTACK) {
31191 0 : p->error_indicator = 1;
31192 0 : PyErr_NoMemory();
31193 : }
31194 657731 : if (p->error_indicator) {
31195 0 : p->level--;
31196 0 : return NULL;
31197 : }
31198 657731 : asdl_seq * _res = NULL;
31199 657731 : int _mark = p->mark;
31200 : { // kwarg_or_starred _loop0_121
31201 657731 : if (p->error_indicator) {
31202 0 : p->level--;
31203 0 : return NULL;
31204 : }
31205 657731 : 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 657731 : if (
31209 657731 : (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
31210 98915 : &&
31211 98915 : (seq = _loop0_121_rule(p)) // _loop0_121
31212 : )
31213 : {
31214 98915 : D(fprintf(stderr, "%*c+ _gather_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_121"));
31215 98915 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31216 98915 : goto done;
31217 : }
31218 558816 : p->mark = _mark;
31219 558816 : 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 558816 : _res = NULL;
31223 657731 : done:
31224 657731 : p->level--;
31225 657731 : return _res;
31226 : }
31227 :
31228 : // _loop0_123: ',' kwarg_or_double_starred
31229 : static asdl_seq *
31230 1039 : _loop0_123_rule(Parser *p)
31231 : {
31232 1039 : if (p->level++ == MAXSTACK) {
31233 0 : p->error_indicator = 1;
31234 0 : PyErr_NoMemory();
31235 : }
31236 1039 : if (p->error_indicator) {
31237 0 : p->level--;
31238 0 : return NULL;
31239 : }
31240 1039 : void *_res = NULL;
31241 1039 : int _mark = p->mark;
31242 1039 : int _start_mark = p->mark;
31243 1039 : void **_children = PyMem_Malloc(sizeof(void *));
31244 1039 : if (!_children) {
31245 0 : p->error_indicator = 1;
31246 0 : PyErr_NoMemory();
31247 0 : p->level--;
31248 0 : return NULL;
31249 : }
31250 1039 : Py_ssize_t _children_capacity = 1;
31251 1039 : Py_ssize_t _n = 0;
31252 : { // ',' kwarg_or_double_starred
31253 1039 : if (p->error_indicator) {
31254 0 : p->level--;
31255 0 : return NULL;
31256 : }
31257 1039 : 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 2094 : while (
31261 1055 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31262 29 : &&
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 0 : 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 1039 : p->mark = _mark;
31288 1039 : 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 1039 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31292 1039 : if (!_seq) {
31293 0 : PyMem_Free(_children);
31294 0 : p->error_indicator = 1;
31295 0 : PyErr_NoMemory();
31296 0 : p->level--;
31297 0 : return NULL;
31298 : }
31299 1055 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31300 1039 : PyMem_Free(_children);
31301 1039 : _PyPegen_insert_memo(p, _start_mark, _loop0_123_type, _seq);
31302 1039 : p->level--;
31303 1039 : return _seq;
31304 : }
31305 :
31306 : // _gather_122: kwarg_or_double_starred _loop0_123
31307 : static asdl_seq *
31308 8559 : _gather_122_rule(Parser *p)
31309 : {
31310 8559 : if (p->level++ == MAXSTACK) {
31311 0 : p->error_indicator = 1;
31312 0 : PyErr_NoMemory();
31313 : }
31314 8559 : if (p->error_indicator) {
31315 0 : p->level--;
31316 0 : return NULL;
31317 : }
31318 8559 : asdl_seq * _res = NULL;
31319 8559 : int _mark = p->mark;
31320 : { // kwarg_or_double_starred _loop0_123
31321 8559 : if (p->error_indicator) {
31322 0 : p->level--;
31323 0 : return NULL;
31324 : }
31325 8559 : 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 8559 : if (
31329 8559 : (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
31330 1039 : &&
31331 1039 : (seq = _loop0_123_rule(p)) // _loop0_123
31332 : )
31333 : {
31334 1039 : D(fprintf(stderr, "%*c+ _gather_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_123"));
31335 1039 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31336 1039 : goto done;
31337 : }
31338 7520 : p->mark = _mark;
31339 7520 : 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 7520 : _res = NULL;
31343 8559 : done:
31344 8559 : p->level--;
31345 8559 : return _res;
31346 : }
31347 :
31348 : // _loop0_125: ',' kwarg_or_starred
31349 : static asdl_seq *
31350 97876 : _loop0_125_rule(Parser *p)
31351 : {
31352 97876 : if (p->level++ == MAXSTACK) {
31353 0 : p->error_indicator = 1;
31354 0 : PyErr_NoMemory();
31355 : }
31356 97876 : if (p->error_indicator) {
31357 0 : p->level--;
31358 0 : return NULL;
31359 : }
31360 97876 : void *_res = NULL;
31361 97876 : int _mark = p->mark;
31362 97876 : int _start_mark = p->mark;
31363 97876 : void **_children = PyMem_Malloc(sizeof(void *));
31364 97876 : if (!_children) {
31365 0 : p->error_indicator = 1;
31366 0 : PyErr_NoMemory();
31367 0 : p->level--;
31368 0 : return NULL;
31369 : }
31370 97876 : Py_ssize_t _children_capacity = 1;
31371 97876 : Py_ssize_t _n = 0;
31372 : { // ',' kwarg_or_starred
31373 97876 : if (p->error_indicator) {
31374 0 : p->level--;
31375 0 : return NULL;
31376 : }
31377 97876 : 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 270978 : while (
31381 173102 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31382 82746 : &&
31383 82746 : (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
31384 : )
31385 : {
31386 75226 : _res = elem;
31387 75226 : 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 75226 : if (_n == _children_capacity) {
31394 29253 : _children_capacity *= 2;
31395 29253 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31396 29253 : if (!_new_children) {
31397 0 : p->error_indicator = 1;
31398 0 : PyErr_NoMemory();
31399 0 : p->level--;
31400 0 : return NULL;
31401 : }
31402 29253 : _children = _new_children;
31403 : }
31404 75226 : _children[_n++] = _res;
31405 75226 : _mark = p->mark;
31406 : }
31407 97876 : p->mark = _mark;
31408 97876 : 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 97876 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31412 97876 : if (!_seq) {
31413 0 : PyMem_Free(_children);
31414 0 : p->error_indicator = 1;
31415 0 : PyErr_NoMemory();
31416 0 : p->level--;
31417 0 : return NULL;
31418 : }
31419 173102 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31420 97876 : PyMem_Free(_children);
31421 97876 : _PyPegen_insert_memo(p, _start_mark, _loop0_125_type, _seq);
31422 97876 : p->level--;
31423 97876 : return _seq;
31424 : }
31425 :
31426 : // _gather_124: kwarg_or_starred _loop0_125
31427 : static asdl_seq *
31428 656678 : _gather_124_rule(Parser *p)
31429 : {
31430 656678 : if (p->level++ == MAXSTACK) {
31431 0 : p->error_indicator = 1;
31432 0 : PyErr_NoMemory();
31433 : }
31434 656678 : if (p->error_indicator) {
31435 0 : p->level--;
31436 0 : return NULL;
31437 : }
31438 656678 : asdl_seq * _res = NULL;
31439 656678 : int _mark = p->mark;
31440 : { // kwarg_or_starred _loop0_125
31441 656678 : if (p->error_indicator) {
31442 0 : p->level--;
31443 0 : return NULL;
31444 : }
31445 656678 : 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 656678 : if (
31449 656678 : (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
31450 97876 : &&
31451 97876 : (seq = _loop0_125_rule(p)) // _loop0_125
31452 : )
31453 : {
31454 97876 : D(fprintf(stderr, "%*c+ _gather_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_125"));
31455 97876 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31456 97876 : goto done;
31457 : }
31458 558802 : p->mark = _mark;
31459 558802 : 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 558802 : _res = NULL;
31463 656678 : done:
31464 656678 : p->level--;
31465 656678 : return _res;
31466 : }
31467 :
31468 : // _loop0_127: ',' kwarg_or_double_starred
31469 : static asdl_seq *
31470 7541 : _loop0_127_rule(Parser *p)
31471 : {
31472 7541 : if (p->level++ == MAXSTACK) {
31473 0 : p->error_indicator = 1;
31474 0 : PyErr_NoMemory();
31475 : }
31476 7541 : if (p->error_indicator) {
31477 0 : p->level--;
31478 0 : return NULL;
31479 : }
31480 7541 : void *_res = NULL;
31481 7541 : int _mark = p->mark;
31482 7541 : int _start_mark = p->mark;
31483 7541 : void **_children = PyMem_Malloc(sizeof(void *));
31484 7541 : if (!_children) {
31485 0 : p->error_indicator = 1;
31486 0 : PyErr_NoMemory();
31487 0 : p->level--;
31488 0 : return NULL;
31489 : }
31490 7541 : Py_ssize_t _children_capacity = 1;
31491 7541 : Py_ssize_t _n = 0;
31492 : { // ',' kwarg_or_double_starred
31493 7541 : if (p->error_indicator) {
31494 0 : p->level--;
31495 0 : return NULL;
31496 : }
31497 7541 : 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 15130 : while (
31501 7589 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31502 62 : &&
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 0 : 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 7541 : p->mark = _mark;
31528 7541 : 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 7541 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31532 7541 : if (!_seq) {
31533 0 : PyMem_Free(_children);
31534 0 : p->error_indicator = 1;
31535 0 : PyErr_NoMemory();
31536 0 : p->level--;
31537 0 : return NULL;
31538 : }
31539 7589 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31540 7541 : PyMem_Free(_children);
31541 7541 : _PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq);
31542 7541 : p->level--;
31543 7541 : return _seq;
31544 : }
31545 :
31546 : // _gather_126: kwarg_or_double_starred _loop0_127
31547 : static asdl_seq *
31548 558802 : _gather_126_rule(Parser *p)
31549 : {
31550 558802 : if (p->level++ == MAXSTACK) {
31551 0 : p->error_indicator = 1;
31552 0 : PyErr_NoMemory();
31553 : }
31554 558802 : if (p->error_indicator) {
31555 0 : p->level--;
31556 0 : return NULL;
31557 : }
31558 558802 : asdl_seq * _res = NULL;
31559 558802 : int _mark = p->mark;
31560 : { // kwarg_or_double_starred _loop0_127
31561 558802 : if (p->error_indicator) {
31562 0 : p->level--;
31563 0 : return NULL;
31564 : }
31565 558802 : 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 558802 : if (
31569 558802 : (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
31570 7541 : &&
31571 7541 : (seq = _loop0_127_rule(p)) // _loop0_127
31572 : )
31573 : {
31574 7541 : D(fprintf(stderr, "%*c+ _gather_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_127"));
31575 7541 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31576 7541 : goto done;
31577 : }
31578 551261 : p->mark = _mark;
31579 551261 : 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 551261 : _res = NULL;
31583 558802 : done:
31584 558802 : p->level--;
31585 558802 : return _res;
31586 : }
31587 :
31588 : // _loop0_128: (',' star_target)
31589 : static asdl_seq *
31590 57095 : _loop0_128_rule(Parser *p)
31591 : {
31592 57095 : if (p->level++ == MAXSTACK) {
31593 0 : p->error_indicator = 1;
31594 0 : PyErr_NoMemory();
31595 : }
31596 57095 : if (p->error_indicator) {
31597 0 : p->level--;
31598 0 : return NULL;
31599 : }
31600 57095 : void *_res = NULL;
31601 57095 : int _mark = p->mark;
31602 57095 : int _start_mark = p->mark;
31603 57095 : void **_children = PyMem_Malloc(sizeof(void *));
31604 57095 : if (!_children) {
31605 0 : p->error_indicator = 1;
31606 0 : PyErr_NoMemory();
31607 0 : p->level--;
31608 0 : return NULL;
31609 : }
31610 57095 : Py_ssize_t _children_capacity = 1;
31611 57095 : Py_ssize_t _n = 0;
31612 : { // (',' star_target)
31613 57095 : if (p->error_indicator) {
31614 0 : p->level--;
31615 0 : return NULL;
31616 : }
31617 57095 : D(fprintf(stderr, "%*c> _loop0_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
31618 : void *_tmp_231_var;
31619 193327 : while (
31620 136232 : (_tmp_231_var = _tmp_231_rule(p)) // ',' star_target
31621 : )
31622 : {
31623 79137 : _res = _tmp_231_var;
31624 79137 : if (_n == _children_capacity) {
31625 17297 : _children_capacity *= 2;
31626 17297 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31627 17297 : if (!_new_children) {
31628 0 : p->error_indicator = 1;
31629 0 : PyErr_NoMemory();
31630 0 : p->level--;
31631 0 : return NULL;
31632 : }
31633 17297 : _children = _new_children;
31634 : }
31635 79137 : _children[_n++] = _res;
31636 79137 : _mark = p->mark;
31637 : }
31638 57095 : p->mark = _mark;
31639 57095 : 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 57095 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31643 57095 : if (!_seq) {
31644 0 : PyMem_Free(_children);
31645 0 : p->error_indicator = 1;
31646 0 : PyErr_NoMemory();
31647 0 : p->level--;
31648 0 : return NULL;
31649 : }
31650 136232 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31651 57095 : PyMem_Free(_children);
31652 57095 : _PyPegen_insert_memo(p, _start_mark, _loop0_128_type, _seq);
31653 57095 : p->level--;
31654 57095 : return _seq;
31655 : }
31656 :
31657 : // _loop0_130: ',' star_target
31658 : static asdl_seq *
31659 12171 : _loop0_130_rule(Parser *p)
31660 : {
31661 12171 : if (p->level++ == MAXSTACK) {
31662 0 : p->error_indicator = 1;
31663 0 : PyErr_NoMemory();
31664 : }
31665 12171 : if (p->error_indicator) {
31666 0 : p->level--;
31667 0 : return NULL;
31668 : }
31669 12171 : void *_res = NULL;
31670 12171 : int _mark = p->mark;
31671 12171 : int _start_mark = p->mark;
31672 12171 : void **_children = PyMem_Malloc(sizeof(void *));
31673 12171 : if (!_children) {
31674 0 : p->error_indicator = 1;
31675 0 : PyErr_NoMemory();
31676 0 : p->level--;
31677 0 : return NULL;
31678 : }
31679 12171 : Py_ssize_t _children_capacity = 1;
31680 12171 : Py_ssize_t _n = 0;
31681 : { // ',' star_target
31682 12171 : if (p->error_indicator) {
31683 0 : p->level--;
31684 0 : return NULL;
31685 : }
31686 12171 : 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 28278 : while (
31690 16107 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31691 4451 : &&
31692 4451 : (elem = star_target_rule(p)) // star_target
31693 : )
31694 : {
31695 3936 : _res = elem;
31696 3936 : 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 3936 : 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 0 : PyErr_NoMemory();
31708 0 : p->level--;
31709 0 : return NULL;
31710 : }
31711 1283 : _children = _new_children;
31712 : }
31713 3936 : _children[_n++] = _res;
31714 3936 : _mark = p->mark;
31715 : }
31716 12171 : p->mark = _mark;
31717 12171 : 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 12171 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31721 12171 : if (!_seq) {
31722 0 : PyMem_Free(_children);
31723 0 : p->error_indicator = 1;
31724 0 : PyErr_NoMemory();
31725 0 : p->level--;
31726 0 : return NULL;
31727 : }
31728 16107 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31729 12171 : PyMem_Free(_children);
31730 12171 : _PyPegen_insert_memo(p, _start_mark, _loop0_130_type, _seq);
31731 12171 : p->level--;
31732 12171 : return _seq;
31733 : }
31734 :
31735 : // _gather_129: star_target _loop0_130
31736 : static asdl_seq *
31737 42800 : _gather_129_rule(Parser *p)
31738 : {
31739 42800 : if (p->level++ == MAXSTACK) {
31740 0 : p->error_indicator = 1;
31741 0 : PyErr_NoMemory();
31742 : }
31743 42800 : if (p->error_indicator) {
31744 0 : p->level--;
31745 0 : return NULL;
31746 : }
31747 42800 : asdl_seq * _res = NULL;
31748 42800 : int _mark = p->mark;
31749 : { // star_target _loop0_130
31750 42800 : if (p->error_indicator) {
31751 0 : p->level--;
31752 0 : return NULL;
31753 : }
31754 42800 : 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 42800 : if (
31758 42800 : (elem = star_target_rule(p)) // star_target
31759 12171 : &&
31760 12171 : (seq = _loop0_130_rule(p)) // _loop0_130
31761 : )
31762 : {
31763 12171 : D(fprintf(stderr, "%*c+ _gather_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_130"));
31764 12171 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31765 12171 : goto done;
31766 : }
31767 30629 : p->mark = _mark;
31768 30629 : 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 30629 : _res = NULL;
31772 42800 : done:
31773 42800 : p->level--;
31774 42800 : return _res;
31775 : }
31776 :
31777 : // _loop1_131: (',' star_target)
31778 : static asdl_seq *
31779 16570 : _loop1_131_rule(Parser *p)
31780 : {
31781 16570 : if (p->level++ == MAXSTACK) {
31782 0 : p->error_indicator = 1;
31783 0 : PyErr_NoMemory();
31784 : }
31785 16570 : if (p->error_indicator) {
31786 0 : p->level--;
31787 0 : return NULL;
31788 : }
31789 16570 : void *_res = NULL;
31790 16570 : int _mark = p->mark;
31791 16570 : int _start_mark = p->mark;
31792 16570 : void **_children = PyMem_Malloc(sizeof(void *));
31793 16570 : if (!_children) {
31794 0 : p->error_indicator = 1;
31795 0 : PyErr_NoMemory();
31796 0 : p->level--;
31797 0 : return NULL;
31798 : }
31799 16570 : Py_ssize_t _children_capacity = 1;
31800 16570 : Py_ssize_t _n = 0;
31801 : { // (',' star_target)
31802 16570 : if (p->error_indicator) {
31803 0 : p->level--;
31804 0 : return NULL;
31805 : }
31806 16570 : D(fprintf(stderr, "%*c> _loop1_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
31807 : void *_tmp_232_var;
31808 49580 : while (
31809 33010 : (_tmp_232_var = _tmp_232_rule(p)) // ',' star_target
31810 : )
31811 : {
31812 16440 : _res = _tmp_232_var;
31813 16440 : if (_n == _children_capacity) {
31814 3870 : _children_capacity *= 2;
31815 3870 : void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31816 3870 : if (!_new_children) {
31817 0 : p->error_indicator = 1;
31818 0 : PyErr_NoMemory();
31819 0 : p->level--;
31820 0 : return NULL;
31821 : }
31822 3870 : _children = _new_children;
31823 : }
31824 16440 : _children[_n++] = _res;
31825 16440 : _mark = p->mark;
31826 : }
31827 16570 : p->mark = _mark;
31828 16570 : 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 16570 : if (_n == 0 || p->error_indicator) {
31832 8944 : PyMem_Free(_children);
31833 8944 : p->level--;
31834 8944 : return NULL;
31835 : }
31836 7626 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31837 7626 : if (!_seq) {
31838 0 : PyMem_Free(_children);
31839 0 : p->error_indicator = 1;
31840 0 : PyErr_NoMemory();
31841 0 : p->level--;
31842 0 : return NULL;
31843 : }
31844 24066 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31845 7626 : PyMem_Free(_children);
31846 7626 : _PyPegen_insert_memo(p, _start_mark, _loop1_131_type, _seq);
31847 7626 : p->level--;
31848 7626 : return _seq;
31849 : }
31850 :
31851 : // _tmp_132: !'*' star_target
31852 : static void *
31853 735 : _tmp_132_rule(Parser *p)
31854 : {
31855 735 : if (p->level++ == MAXSTACK) {
31856 0 : p->error_indicator = 1;
31857 0 : PyErr_NoMemory();
31858 : }
31859 735 : if (p->error_indicator) {
31860 0 : p->level--;
31861 0 : return NULL;
31862 : }
31863 735 : void * _res = NULL;
31864 735 : int _mark = p->mark;
31865 : { // !'*' star_target
31866 735 : if (p->error_indicator) {
31867 0 : p->level--;
31868 0 : return NULL;
31869 : }
31870 735 : D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target"));
31871 : expr_ty star_target_var;
31872 735 : if (
31873 735 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*'
31874 735 : &&
31875 735 : (star_target_var = star_target_rule(p)) // star_target
31876 : )
31877 : {
31878 699 : D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target"));
31879 699 : _res = star_target_var;
31880 699 : goto done;
31881 : }
31882 36 : p->mark = _mark;
31883 36 : 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 735 : done:
31888 735 : p->level--;
31889 735 : return _res;
31890 : }
31891 :
31892 : // _loop0_134: ',' del_target
31893 : static asdl_seq *
31894 8999 : _loop0_134_rule(Parser *p)
31895 : {
31896 8999 : if (p->level++ == MAXSTACK) {
31897 0 : p->error_indicator = 1;
31898 0 : PyErr_NoMemory();
31899 : }
31900 8999 : if (p->error_indicator) {
31901 0 : p->level--;
31902 0 : return NULL;
31903 : }
31904 8999 : void *_res = NULL;
31905 8999 : int _mark = p->mark;
31906 8999 : int _start_mark = p->mark;
31907 8999 : void **_children = PyMem_Malloc(sizeof(void *));
31908 8999 : if (!_children) {
31909 0 : p->error_indicator = 1;
31910 0 : PyErr_NoMemory();
31911 0 : p->level--;
31912 0 : return NULL;
31913 : }
31914 8999 : Py_ssize_t _children_capacity = 1;
31915 8999 : Py_ssize_t _n = 0;
31916 : { // ',' del_target
31917 8999 : if (p->error_indicator) {
31918 0 : p->level--;
31919 0 : return NULL;
31920 : }
31921 8999 : 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 19742 : while (
31925 10743 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
31926 1757 : &&
31927 1757 : (elem = del_target_rule(p)) // del_target
31928 : )
31929 : {
31930 1744 : _res = elem;
31931 1744 : 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 1744 : 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 0 : PyErr_NoMemory();
31943 0 : p->level--;
31944 0 : return NULL;
31945 : }
31946 546 : _children = _new_children;
31947 : }
31948 1744 : _children[_n++] = _res;
31949 1744 : _mark = p->mark;
31950 : }
31951 8999 : p->mark = _mark;
31952 8999 : 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 8999 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31956 8999 : if (!_seq) {
31957 0 : PyMem_Free(_children);
31958 0 : p->error_indicator = 1;
31959 0 : PyErr_NoMemory();
31960 0 : p->level--;
31961 0 : return NULL;
31962 : }
31963 10743 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31964 8999 : PyMem_Free(_children);
31965 8999 : _PyPegen_insert_memo(p, _start_mark, _loop0_134_type, _seq);
31966 8999 : p->level--;
31967 8999 : return _seq;
31968 : }
31969 :
31970 : // _gather_133: del_target _loop0_134
31971 : static asdl_seq *
31972 9065 : _gather_133_rule(Parser *p)
31973 : {
31974 9065 : if (p->level++ == MAXSTACK) {
31975 0 : p->error_indicator = 1;
31976 0 : PyErr_NoMemory();
31977 : }
31978 9065 : if (p->error_indicator) {
31979 0 : p->level--;
31980 0 : return NULL;
31981 : }
31982 9065 : asdl_seq * _res = NULL;
31983 9065 : int _mark = p->mark;
31984 : { // del_target _loop0_134
31985 9065 : if (p->error_indicator) {
31986 0 : p->level--;
31987 0 : return NULL;
31988 : }
31989 9065 : 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 9065 : if (
31993 9065 : (elem = del_target_rule(p)) // del_target
31994 8999 : &&
31995 8999 : (seq = _loop0_134_rule(p)) // _loop0_134
31996 : )
31997 : {
31998 8999 : D(fprintf(stderr, "%*c+ _gather_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_134"));
31999 8999 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
32000 8999 : goto done;
32001 : }
32002 66 : p->mark = _mark;
32003 66 : 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 9065 : done:
32008 9065 : p->level--;
32009 9065 : 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 0 : 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 0 : 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 10 : D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
32042 : Token * _literal;
32043 : expr_ty elem;
32044 24 : while (
32045 14 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
32046 9 : &&
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 0 : 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 10 : 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 0 : 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 0 : 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 18 : 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 10 : 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 8 : 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 0 : 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 0 : 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 9 : D(fprintf(stderr, "%*c> _loop0_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
32162 : Token * _literal;
32163 : expr_ty elem;
32164 22 : while (
32165 13 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
32166 8 : &&
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 0 : 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 9 : 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 0 : 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 0 : 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 17 : 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 9 : 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 8 : 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 0 : 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 0 : 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 7 : D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
32282 : Token * _literal;
32283 : expr_ty elem;
32284 18 : while (
32285 11 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
32286 6 : &&
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 0 : 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 7 : 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 0 : 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 0 : 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 15 : 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 7 : 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 8 : 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 0 : 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 0 : 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 5 : D(fprintf(stderr, "%*c> _loop0_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
32402 : Token * _literal;
32403 : expr_ty elem;
32404 14 : while (
32405 9 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
32406 4 : &&
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 0 : 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 5 : 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 0 : 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 0 : 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 8 : 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 5 : 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 3 : 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 0 : 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 27 : 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 27 : 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 0 : 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 0 : 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 11 : 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 9 : 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 2 : 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 1 : 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 0 : 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 1 : 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 0 : 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 1130 : 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 1 : 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 1129 : 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 1129 : 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 1 : 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 1128 : 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 1128 : 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 2 : 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 1126 : 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 0 : 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 1125 : 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 167 : 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 958 : 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 0 : 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 2706 : 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 63 : 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 2643 : 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 2643 : 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 31 : 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 2612 : 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 0 : 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 7 : 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 2 : 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 5 : 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 5 : 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 1 : 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 4 : 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 0 : 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 11 : 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 3 : 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 8 : 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 8 : 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 0 : 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 8 : 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 0 : 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 1239 : 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 5 : 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 1234 : 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 1234 : 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 17 : 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 1217 : 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 1217 : 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 4 : 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 1213 : 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 1213 : 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 27 : 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 1186 : 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 1186 : 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 12 : 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 1174 : 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 1174 : 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 1 : 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 1173 : 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 0 : 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 34 : 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 3 : 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 31 : 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 31 : 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 0 : 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 31 : 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 0 : 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 0 : 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 5 : 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 13 : 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 0 : 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 5 : 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 0 : 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 0 : 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 0 : 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 796 : D(fprintf(stderr, "%*c> _loop0_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
33182 : void *_tmp_233_var;
33183 1599 : 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 0 : 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 796 : 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 0 : 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 0 : 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 0 : 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 774 : D(fprintf(stderr, "%*c> _loop0_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
33251 : void *_tmp_234_var;
33252 1553 : 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 0 : 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 774 : 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 0 : 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 0 : 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 14 : 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 0 : 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 14 : 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 14 : 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 14 : 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 0 : 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 0 : 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 2906 : 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 71 : 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 2835 : 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 2835 : 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 272 : 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 2563 : 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 2563 : 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 79 : 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 2484 : 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 0 : 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 2900 : 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 66 : 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 2834 : 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 2834 : 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 79 : 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 2755 : 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 0 : 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 2896 : 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 63 : 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 2833 : 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 2833 : 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 78 : 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 2755 : 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 0 : 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 0 : 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 302 : 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 669 : 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 0 : 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 302 : 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 0 : 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 0 : 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 0 : 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 284 : 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 628 : 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 0 : 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 284 : 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 0 : 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 0 : 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 0 : 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 4 : 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 20 : 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 0 : 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 4 : 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 0 : 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 0 : 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 275 : 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 12 : 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 263 : 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 263 : 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 2 : 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 261 : 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 0 : 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 0 : 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 14 : 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 39 : 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 0 : 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 14 : 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 0 : 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 0 : 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 265 : 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 3 : 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 262 : 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 262 : 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 1 : 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 261 : 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 0 : 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 0 : 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 265 : 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 579 : 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 0 : 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 265 : 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 0 : 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 0 : 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 41 : 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 15 : 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 26 : 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 26 : 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 18 : 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 8 : 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 0 : 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 0 : 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 33 : 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 82 : 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 0 : 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 33 : 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 0 : 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 0 : 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 0 : 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 253 : 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 554 : 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 0 : 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 253 : 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 0 : 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 0 : 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 245 : 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 0 : 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 245 : 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 245 : 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 5 : 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 240 : 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 0 : 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 29 : 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 2 : 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 27 : 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 27 : 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 1 : 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 26 : 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 0 : 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 23 : 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 12 : 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 11 : 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 11 : 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 7 : 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 4 : 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 0 : 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 0 : 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 19 : 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 46 : 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 0 : 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 19 : 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 0 : 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 0 : 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 4 : 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 4 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 5 : 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 1 : 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 4 : 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 4 : 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 1 : 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 3 : 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 3 : 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 3 : 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 0 : 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 0 : 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 0 : 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 288 : 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 584 : 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 0 : 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 288 : 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 0 : 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 0 : 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 0 : 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 52 : 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 132 : 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 0 : 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 52 : 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 0 : 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 0 : 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 0 : 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 47 : 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 120 : 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 0 : 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 47 : 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 0 : 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 0 : 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 0 : 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 4 : 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 16 : while (
34834 12 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
34835 8 : &&
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 0 : 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 4 : 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 0 : 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 0 : 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 5 : 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 4 : 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 1 : 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 0 : 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 40 : 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 8 : 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 32 : 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 32 : 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 2 : 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 30 : 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 0 : 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 0 : 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 10 : 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 27 : 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 0 : 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 10 : 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 0 : 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 0 : 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 33 : 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 2 : 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 31 : 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 31 : 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 1 : 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 30 : 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 0 : 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 0 : 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 33 : 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 84 : 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 0 : 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 33 : 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 0 : 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 0 : 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 17 : 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 3 : 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 14 : 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 14 : 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 12 : 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 2 : 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 0 : 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 0 : 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 15 : 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 42 : 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 0 : 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 15 : 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 0 : 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 0 : 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 0 : 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 26 : 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 70 : 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 0 : 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 26 : 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 0 : 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 0 : 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 0 : 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 47 : 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 98 : 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 0 : 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 47 : 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 0 : 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 0 : 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 10 : 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 1 : 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 9 : 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 9 : 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 0 : 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 9 : 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 0 : 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 8 : 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 8 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 8 : 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 23 : 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 0 : 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 8 : 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 0 : 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 0 : 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 4 : 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 4 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 4 : 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 1 : 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 3 : 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 3 : 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 1 : 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 2 : 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 2 : 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 2 : 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 0 : 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 0 : 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 14 : 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 1 : 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 13 : 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 13 : 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 0 : 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 13 : 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 13 : 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 10 : 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 3 : 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 0 : 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 0 : 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 7 : 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 17 : while (
35883 10 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
35884 3 : &&
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 0 : 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 7 : 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 0 : 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 0 : 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 11 : 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 7 : 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 4 : 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 0 : 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 0 : 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 3 : 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 7 : while (
36003 4 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
36004 1 : &&
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 0 : 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 3 : 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 0 : 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 0 : 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 3 : 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 3 : 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 0 : 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 0 : 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 0 : 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 22 : 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 50 : while (
36123 28 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
36124 6 : &&
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 0 : 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 22 : 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 0 : 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 0 : 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 29 : 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 22 : 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 7 : 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 0 : 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 0 : 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 6 : 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 15 : while (
36243 9 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
36244 3 : &&
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 0 : 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 6 : 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 0 : 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 0 : 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 6 : 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 6 : 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 0 : 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 0 : 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 41 : 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 31 : 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 10 : 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 10 : 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 9 : 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 1 : 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 0 : 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 0 : 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 49 : D(fprintf(stderr, "%*c> _loop0_203[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block"));
36418 : asdl_stmt_seq* block_var;
36419 138 : 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 0 : 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 49 : 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 0 : 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 0 : 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 49 : 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 5 : 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 44 : 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 30 : 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 6 : 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 24 : 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 0 : 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 0 : 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 11 : D(fprintf(stderr, "%*c> _loop0_205[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block"));
36545 : asdl_stmt_seq* block_var;
36546 22 : 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 0 : 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 11 : 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 0 : 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 0 : 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 8 : 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 4 : 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 4 : 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 0 : 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 29 : 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 12 : 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 17 : 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 0 : 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 23 : 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 0 : 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 23 : 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 23 : 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 4 : 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 19 : 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 0 : 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 21 : 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 4 : 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 17 : 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 0 : 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 18 : 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 5 : 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 13 : 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 0 : 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 4 : 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 1 : 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 3 : 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 0 : 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 66 : 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 0 : 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 66 : 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 0 : 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 6 : 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 1 : 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 5 : 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 0 : 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 5 : 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 1 : 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 4 : 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 3800 : _loop0_216_rule(Parser *p)
36989 : {
36990 3800 : if (p->level++ == MAXSTACK) {
36991 0 : p->error_indicator = 1;
36992 0 : PyErr_NoMemory();
36993 : }
36994 3800 : if (p->error_indicator) {
36995 0 : p->level--;
36996 0 : return NULL;
36997 : }
36998 3800 : void *_res = NULL;
36999 3800 : int _mark = p->mark;
37000 3800 : int _start_mark = p->mark;
37001 3800 : void **_children = PyMem_Malloc(sizeof(void *));
37002 3800 : if (!_children) {
37003 0 : p->error_indicator = 1;
37004 0 : PyErr_NoMemory();
37005 0 : p->level--;
37006 0 : return NULL;
37007 : }
37008 3800 : Py_ssize_t _children_capacity = 1;
37009 3800 : Py_ssize_t _n = 0;
37010 : { // ',' double_starred_kvpair
37011 3800 : if (p->error_indicator) {
37012 0 : p->level--;
37013 0 : return NULL;
37014 : }
37015 3800 : 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 7608 : while (
37019 3808 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37020 11 : &&
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 0 : 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 3800 : p->mark = _mark;
37046 3800 : 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 3800 : asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37050 3800 : if (!_seq) {
37051 0 : PyMem_Free(_children);
37052 0 : p->error_indicator = 1;
37053 0 : PyErr_NoMemory();
37054 0 : p->level--;
37055 0 : return NULL;
37056 : }
37057 3808 : for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37058 3800 : PyMem_Free(_children);
37059 3800 : _PyPegen_insert_memo(p, _start_mark, _loop0_216_type, _seq);
37060 3800 : p->level--;
37061 3800 : return _seq;
37062 : }
37063 :
37064 : // _gather_215: double_starred_kvpair _loop0_216
37065 : static asdl_seq *
37066 13748 : _gather_215_rule(Parser *p)
37067 : {
37068 13748 : if (p->level++ == MAXSTACK) {
37069 0 : p->error_indicator = 1;
37070 0 : PyErr_NoMemory();
37071 : }
37072 13748 : if (p->error_indicator) {
37073 0 : p->level--;
37074 0 : return NULL;
37075 : }
37076 13748 : asdl_seq * _res = NULL;
37077 13748 : int _mark = p->mark;
37078 : { // double_starred_kvpair _loop0_216
37079 13748 : if (p->error_indicator) {
37080 0 : p->level--;
37081 0 : return NULL;
37082 : }
37083 13748 : 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 13748 : if (
37087 13748 : (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
37088 3800 : &&
37089 3800 : (seq = _loop0_216_rule(p)) // _loop0_216
37090 : )
37091 : {
37092 3800 : D(fprintf(stderr, "%*c+ _gather_215[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_216"));
37093 3800 : _res = _PyPegen_seq_insert_in_front(p, elem, seq);
37094 3800 : goto done;
37095 : }
37096 9948 : p->mark = _mark;
37097 9948 : 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 9948 : _res = NULL;
37101 13748 : done:
37102 13748 : p->level--;
37103 13748 : return _res;
37104 : }
37105 :
37106 : // _tmp_217: '}' | ','
37107 : static void *
37108 3807 : _tmp_217_rule(Parser *p)
37109 : {
37110 3807 : if (p->level++ == MAXSTACK) {
37111 0 : p->error_indicator = 1;
37112 0 : PyErr_NoMemory();
37113 : }
37114 3807 : if (p->error_indicator) {
37115 0 : p->level--;
37116 0 : return NULL;
37117 : }
37118 3807 : void * _res = NULL;
37119 3807 : int _mark = p->mark;
37120 : { // '}'
37121 3807 : if (p->error_indicator) {
37122 0 : p->level--;
37123 0 : return NULL;
37124 : }
37125 3807 : D(fprintf(stderr, "%*c> _tmp_217[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
37126 : Token * _literal;
37127 3807 : if (
37128 3807 : (_literal = _PyPegen_expect_token(p, 26)) // token='}'
37129 : )
37130 : {
37131 1 : 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 3806 : p->mark = _mark;
37136 3806 : 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 3806 : if (p->error_indicator) {
37141 0 : p->level--;
37142 0 : return NULL;
37143 : }
37144 3806 : D(fprintf(stderr, "%*c> _tmp_217[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
37145 : Token * _literal;
37146 3806 : if (
37147 3806 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37148 : )
37149 : {
37150 0 : 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 3806 : p->mark = _mark;
37155 3806 : D(fprintf(stderr, "%*c%s _tmp_217[%d-%d]: %s failed!\n", p->level, ' ',
37156 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
37157 : }
37158 3806 : _res = NULL;
37159 3807 : done:
37160 3807 : p->level--;
37161 3807 : 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 0 : 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 1 : 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 1 : 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 0 : 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 0 : 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 0 : 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 0 : 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 4035830 : _tmp_219_rule(Parser *p)
37225 : {
37226 4035830 : if (p->level++ == MAXSTACK) {
37227 0 : p->error_indicator = 1;
37228 0 : PyErr_NoMemory();
37229 : }
37230 4035830 : if (p->error_indicator) {
37231 0 : p->level--;
37232 0 : return NULL;
37233 : }
37234 4035830 : void * _res = NULL;
37235 4035830 : int _mark = p->mark;
37236 : { // star_targets '='
37237 4035830 : if (p->error_indicator) {
37238 0 : p->level--;
37239 0 : return NULL;
37240 : }
37241 4035830 : 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 4035830 : if (
37245 4035830 : (z = star_targets_rule(p)) // star_targets
37246 2168100 : &&
37247 2168100 : (_literal = _PyPegen_expect_token(p, 22)) // token='='
37248 : )
37249 : {
37250 817078 : D(fprintf(stderr, "%*c+ _tmp_219[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
37251 817078 : _res = z;
37252 817078 : if (_res == NULL && PyErr_Occurred()) {
37253 0 : p->error_indicator = 1;
37254 0 : p->level--;
37255 0 : return NULL;
37256 : }
37257 817078 : goto done;
37258 : }
37259 3218750 : p->mark = _mark;
37260 3218750 : 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 3218750 : _res = NULL;
37264 4035830 : done:
37265 4035830 : p->level--;
37266 4035830 : return _res;
37267 : }
37268 :
37269 : // _tmp_220: '.' | '...'
37270 : static void *
37271 57973 : _tmp_220_rule(Parser *p)
37272 : {
37273 57973 : if (p->level++ == MAXSTACK) {
37274 0 : p->error_indicator = 1;
37275 0 : PyErr_NoMemory();
37276 : }
37277 57973 : if (p->error_indicator) {
37278 0 : p->level--;
37279 0 : return NULL;
37280 : }
37281 57973 : void * _res = NULL;
37282 57973 : int _mark = p->mark;
37283 : { // '.'
37284 57973 : if (p->error_indicator) {
37285 0 : p->level--;
37286 0 : return NULL;
37287 : }
37288 57973 : D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
37289 : Token * _literal;
37290 57973 : if (
37291 57973 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
37292 : )
37293 : {
37294 11796 : D(fprintf(stderr, "%*c+ _tmp_220[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
37295 11796 : _res = _literal;
37296 11796 : goto done;
37297 : }
37298 46177 : p->mark = _mark;
37299 46177 : 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 46177 : if (p->error_indicator) {
37304 0 : p->level--;
37305 0 : return NULL;
37306 : }
37307 46177 : D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
37308 : Token * _literal;
37309 46177 : if (
37310 46177 : (_literal = _PyPegen_expect_token(p, 52)) // token='...'
37311 : )
37312 : {
37313 6 : 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 46171 : p->mark = _mark;
37318 46171 : D(fprintf(stderr, "%*c%s _tmp_220[%d-%d]: %s failed!\n", p->level, ' ',
37319 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
37320 : }
37321 46171 : _res = NULL;
37322 57973 : done:
37323 57973 : p->level--;
37324 57973 : return _res;
37325 : }
37326 :
37327 : // _tmp_221: '.' | '...'
37328 : static void *
37329 2644 : _tmp_221_rule(Parser *p)
37330 : {
37331 2644 : if (p->level++ == MAXSTACK) {
37332 0 : p->error_indicator = 1;
37333 0 : PyErr_NoMemory();
37334 : }
37335 2644 : if (p->error_indicator) {
37336 0 : p->level--;
37337 0 : return NULL;
37338 : }
37339 2644 : void * _res = NULL;
37340 2644 : int _mark = p->mark;
37341 : { // '.'
37342 2644 : if (p->error_indicator) {
37343 0 : p->level--;
37344 0 : return NULL;
37345 : }
37346 2644 : D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
37347 : Token * _literal;
37348 2644 : if (
37349 2644 : (_literal = _PyPegen_expect_token(p, 23)) // token='.'
37350 : )
37351 : {
37352 1369 : D(fprintf(stderr, "%*c+ _tmp_221[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
37353 1369 : _res = _literal;
37354 1369 : goto done;
37355 : }
37356 1275 : p->mark = _mark;
37357 1275 : 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 1275 : if (p->error_indicator) {
37362 0 : p->level--;
37363 0 : return NULL;
37364 : }
37365 1275 : D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
37366 : Token * _literal;
37367 1275 : if (
37368 1275 : (_literal = _PyPegen_expect_token(p, 52)) // token='...'
37369 : )
37370 : {
37371 1 : 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 1274 : p->mark = _mark;
37376 1274 : D(fprintf(stderr, "%*c%s _tmp_221[%d-%d]: %s failed!\n", p->level, ' ',
37377 : p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
37378 : }
37379 1274 : _res = NULL;
37380 2644 : done:
37381 2644 : p->level--;
37382 2644 : return _res;
37383 : }
37384 :
37385 : // _tmp_222: '@' named_expression NEWLINE
37386 : static void *
37387 443836 : _tmp_222_rule(Parser *p)
37388 : {
37389 443836 : if (p->level++ == MAXSTACK) {
37390 0 : p->error_indicator = 1;
37391 0 : PyErr_NoMemory();
37392 : }
37393 443836 : if (p->error_indicator) {
37394 0 : p->level--;
37395 0 : return NULL;
37396 : }
37397 443836 : void * _res = NULL;
37398 443836 : int _mark = p->mark;
37399 : { // '@' named_expression NEWLINE
37400 443836 : if (p->error_indicator) {
37401 0 : p->level--;
37402 0 : return NULL;
37403 : }
37404 443836 : 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 443836 : if (
37409 443836 : (_literal = _PyPegen_expect_token(p, 49)) // token='@'
37410 40473 : &&
37411 40473 : (f = named_expression_rule(p)) // named_expression
37412 40454 : &&
37413 40454 : (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
37414 : )
37415 : {
37416 40444 : D(fprintf(stderr, "%*c+ _tmp_222[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE"));
37417 40444 : _res = f;
37418 40444 : if (_res == NULL && PyErr_Occurred()) {
37419 0 : p->error_indicator = 1;
37420 0 : p->level--;
37421 0 : return NULL;
37422 : }
37423 40444 : goto done;
37424 : }
37425 403392 : p->mark = _mark;
37426 403392 : 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 403392 : _res = NULL;
37430 443836 : done:
37431 443836 : p->level--;
37432 443836 : return _res;
37433 : }
37434 :
37435 : // _tmp_223: ',' expression
37436 : static void *
37437 514664 : _tmp_223_rule(Parser *p)
37438 : {
37439 514664 : if (p->level++ == MAXSTACK) {
37440 0 : p->error_indicator = 1;
37441 0 : PyErr_NoMemory();
37442 : }
37443 514664 : if (p->error_indicator) {
37444 0 : p->level--;
37445 0 : return NULL;
37446 : }
37447 514664 : void * _res = NULL;
37448 514664 : int _mark = p->mark;
37449 : { // ',' expression
37450 514664 : if (p->error_indicator) {
37451 0 : p->level--;
37452 0 : return NULL;
37453 : }
37454 514664 : D(fprintf(stderr, "%*c> _tmp_223[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
37455 : Token * _literal;
37456 : expr_ty c;
37457 514664 : if (
37458 514664 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37459 441245 : &&
37460 441245 : (c = expression_rule(p)) // expression
37461 : )
37462 : {
37463 441222 : D(fprintf(stderr, "%*c+ _tmp_223[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression"));
37464 441222 : _res = c;
37465 441222 : if (_res == NULL && PyErr_Occurred()) {
37466 0 : p->error_indicator = 1;
37467 0 : p->level--;
37468 0 : return NULL;
37469 : }
37470 441222 : goto done;
37471 : }
37472 73442 : p->mark = _mark;
37473 73442 : 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 73442 : _res = NULL;
37477 514664 : done:
37478 514664 : p->level--;
37479 514664 : return _res;
37480 : }
37481 :
37482 : // _tmp_224: ',' star_expression
37483 : static void *
37484 2134100 : _tmp_224_rule(Parser *p)
37485 : {
37486 2134100 : if (p->level++ == MAXSTACK) {
37487 0 : p->error_indicator = 1;
37488 0 : PyErr_NoMemory();
37489 : }
37490 2134100 : if (p->error_indicator) {
37491 0 : p->level--;
37492 0 : return NULL;
37493 : }
37494 2134100 : void * _res = NULL;
37495 2134100 : int _mark = p->mark;
37496 : { // ',' star_expression
37497 2134100 : if (p->error_indicator) {
37498 0 : p->level--;
37499 0 : return NULL;
37500 : }
37501 2134100 : 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 2134100 : if (
37505 2134100 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37506 28451 : &&
37507 28451 : (c = star_expression_rule(p)) // star_expression
37508 : )
37509 : {
37510 28158 : D(fprintf(stderr, "%*c+ _tmp_224[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression"));
37511 28158 : _res = c;
37512 28158 : if (_res == NULL && PyErr_Occurred()) {
37513 0 : p->error_indicator = 1;
37514 0 : p->level--;
37515 0 : return NULL;
37516 : }
37517 28158 : goto done;
37518 : }
37519 2105940 : p->mark = _mark;
37520 2105940 : 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 2105940 : _res = NULL;
37524 2134100 : done:
37525 2134100 : p->level--;
37526 2134100 : return _res;
37527 : }
37528 :
37529 : // _tmp_225: 'or' conjunction
37530 : static void *
37531 9775950 : _tmp_225_rule(Parser *p)
37532 : {
37533 9775950 : if (p->level++ == MAXSTACK) {
37534 0 : p->error_indicator = 1;
37535 0 : PyErr_NoMemory();
37536 : }
37537 9775950 : if (p->error_indicator) {
37538 0 : p->level--;
37539 0 : return NULL;
37540 : }
37541 9775950 : void * _res = NULL;
37542 9775950 : int _mark = p->mark;
37543 : { // 'or' conjunction
37544 9775950 : if (p->error_indicator) {
37545 0 : p->level--;
37546 0 : return NULL;
37547 : }
37548 9775950 : 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 9775950 : if (
37552 9775950 : (_keyword = _PyPegen_expect_token(p, 574)) // token='or'
37553 28940 : &&
37554 28940 : (c = conjunction_rule(p)) // conjunction
37555 : )
37556 : {
37557 28940 : D(fprintf(stderr, "%*c+ _tmp_225[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction"));
37558 28940 : _res = c;
37559 28940 : if (_res == NULL && PyErr_Occurred()) {
37560 0 : p->error_indicator = 1;
37561 0 : p->level--;
37562 0 : return NULL;
37563 : }
37564 28940 : goto done;
37565 : }
37566 9747010 : p->mark = _mark;
37567 9747010 : 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 9747010 : _res = NULL;
37571 9775950 : done:
37572 9775950 : p->level--;
37573 9775950 : return _res;
37574 : }
37575 :
37576 : // _tmp_226: 'and' inversion
37577 : static void *
37578 9822190 : _tmp_226_rule(Parser *p)
37579 : {
37580 9822190 : if (p->level++ == MAXSTACK) {
37581 0 : p->error_indicator = 1;
37582 0 : PyErr_NoMemory();
37583 : }
37584 9822190 : if (p->error_indicator) {
37585 0 : p->level--;
37586 0 : return NULL;
37587 : }
37588 9822190 : void * _res = NULL;
37589 9822190 : int _mark = p->mark;
37590 : { // 'and' inversion
37591 9822190 : if (p->error_indicator) {
37592 0 : p->level--;
37593 0 : return NULL;
37594 : }
37595 9822190 : 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 9822190 : if (
37599 9822190 : (_keyword = _PyPegen_expect_token(p, 575)) // token='and'
37600 46240 : &&
37601 46240 : (c = inversion_rule(p)) // inversion
37602 : )
37603 : {
37604 46240 : D(fprintf(stderr, "%*c+ _tmp_226[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion"));
37605 46240 : _res = c;
37606 46240 : if (_res == NULL && PyErr_Occurred()) {
37607 0 : p->error_indicator = 1;
37608 0 : p->level--;
37609 0 : return NULL;
37610 : }
37611 46240 : goto done;
37612 : }
37613 9775950 : p->mark = _mark;
37614 9775950 : 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 9775950 : _res = NULL;
37618 9822190 : done:
37619 9822190 : p->level--;
37620 9822190 : 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 0 : 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 48014 : 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 45944 : 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 2070 : 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 2068 : 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 1545 : 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 523 : 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 0 : 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 568 : 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 60 : 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 508 : 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 63959 : _tmp_229_rule(Parser *p)
37731 : {
37732 63959 : if (p->level++ == MAXSTACK) {
37733 0 : p->error_indicator = 1;
37734 0 : PyErr_NoMemory();
37735 : }
37736 63959 : if (p->error_indicator) {
37737 0 : p->level--;
37738 0 : return NULL;
37739 : }
37740 63959 : void * _res = NULL;
37741 63959 : int _mark = p->mark;
37742 : { // 'if' disjunction
37743 63959 : if (p->error_indicator) {
37744 0 : p->level--;
37745 0 : return NULL;
37746 : }
37747 63959 : 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 63959 : if (
37751 63959 : (_keyword = _PyPegen_expect_token(p, 634)) // token='if'
37752 12576 : &&
37753 12576 : (z = disjunction_rule(p)) // disjunction
37754 : )
37755 : {
37756 12576 : D(fprintf(stderr, "%*c+ _tmp_229[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
37757 12576 : _res = z;
37758 12576 : if (_res == NULL && PyErr_Occurred()) {
37759 0 : p->error_indicator = 1;
37760 0 : p->level--;
37761 0 : return NULL;
37762 : }
37763 12576 : goto done;
37764 : }
37765 51383 : p->mark = _mark;
37766 51383 : 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 51383 : _res = NULL;
37770 63959 : done:
37771 63959 : p->level--;
37772 63959 : return _res;
37773 : }
37774 :
37775 : // _tmp_230: starred_expression | (assignment_expression | expression !':=') !'='
37776 : static void *
37777 2760360 : _tmp_230_rule(Parser *p)
37778 : {
37779 2760360 : if (p->level++ == MAXSTACK) {
37780 0 : p->error_indicator = 1;
37781 0 : PyErr_NoMemory();
37782 : }
37783 2760360 : if (p->error_indicator) {
37784 0 : p->level--;
37785 0 : return NULL;
37786 : }
37787 2760360 : void * _res = NULL;
37788 2760360 : int _mark = p->mark;
37789 : { // starred_expression
37790 2760360 : if (p->error_indicator) {
37791 0 : p->level--;
37792 0 : return NULL;
37793 : }
37794 2760360 : D(fprintf(stderr, "%*c> _tmp_230[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
37795 : expr_ty starred_expression_var;
37796 2760360 : if (
37797 2760360 : (starred_expression_var = starred_expression_rule(p)) // starred_expression
37798 : )
37799 : {
37800 10955 : D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
37801 10955 : _res = starred_expression_var;
37802 10955 : goto done;
37803 : }
37804 2749400 : p->mark = _mark;
37805 2749400 : 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 2749400 : if (p->error_indicator) {
37810 10 : p->level--;
37811 10 : return NULL;
37812 : }
37813 2749390 : D(fprintf(stderr, "%*c> _tmp_230[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
37814 : void *_tmp_243_var;
37815 2749390 : if (
37816 2749390 : (_tmp_243_var = _tmp_243_rule(p)) // assignment_expression | expression !':='
37817 2190600 : &&
37818 2190600 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='='
37819 : )
37820 : {
37821 2091660 : D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
37822 2091660 : _res = _tmp_243_var;
37823 2091660 : goto done;
37824 : }
37825 657737 : p->mark = _mark;
37826 657737 : 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 657737 : _res = NULL;
37830 2760350 : done:
37831 2760350 : p->level--;
37832 2760350 : return _res;
37833 : }
37834 :
37835 : // _tmp_231: ',' star_target
37836 : static void *
37837 136232 : _tmp_231_rule(Parser *p)
37838 : {
37839 136232 : if (p->level++ == MAXSTACK) {
37840 0 : p->error_indicator = 1;
37841 0 : PyErr_NoMemory();
37842 : }
37843 136232 : if (p->error_indicator) {
37844 0 : p->level--;
37845 0 : return NULL;
37846 : }
37847 136232 : void * _res = NULL;
37848 136232 : int _mark = p->mark;
37849 : { // ',' star_target
37850 136232 : if (p->error_indicator) {
37851 0 : p->level--;
37852 0 : return NULL;
37853 : }
37854 136232 : 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 136232 : if (
37858 136232 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37859 80301 : &&
37860 80301 : (c = star_target_rule(p)) // star_target
37861 : )
37862 : {
37863 79137 : D(fprintf(stderr, "%*c+ _tmp_231[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target"));
37864 79137 : _res = c;
37865 79137 : if (_res == NULL && PyErr_Occurred()) {
37866 0 : p->error_indicator = 1;
37867 0 : p->level--;
37868 0 : return NULL;
37869 : }
37870 79137 : goto done;
37871 : }
37872 57095 : p->mark = _mark;
37873 57095 : 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 57095 : _res = NULL;
37877 136232 : done:
37878 136232 : p->level--;
37879 136232 : return _res;
37880 : }
37881 :
37882 : // _tmp_232: ',' star_target
37883 : static void *
37884 33010 : _tmp_232_rule(Parser *p)
37885 : {
37886 33010 : if (p->level++ == MAXSTACK) {
37887 0 : p->error_indicator = 1;
37888 0 : PyErr_NoMemory();
37889 : }
37890 33010 : if (p->error_indicator) {
37891 0 : p->level--;
37892 0 : return NULL;
37893 : }
37894 33010 : void * _res = NULL;
37895 33010 : int _mark = p->mark;
37896 : { // ',' star_target
37897 33010 : if (p->error_indicator) {
37898 0 : p->level--;
37899 0 : return NULL;
37900 : }
37901 33010 : 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 33010 : if (
37905 33010 : (_literal = _PyPegen_expect_token(p, 12)) // token=','
37906 18741 : &&
37907 18741 : (c = star_target_rule(p)) // star_target
37908 : )
37909 : {
37910 16440 : D(fprintf(stderr, "%*c+ _tmp_232[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target"));
37911 16440 : _res = c;
37912 16440 : if (_res == NULL && PyErr_Occurred()) {
37913 0 : p->error_indicator = 1;
37914 0 : p->level--;
37915 0 : return NULL;
37916 : }
37917 16440 : goto done;
37918 : }
37919 16570 : p->mark = _mark;
37920 16570 : 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 16570 : _res = NULL;
37924 33010 : done:
37925 33010 : p->level--;
37926 33010 : 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 0 : 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 803 : 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 7 : 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 796 : 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 0 : 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 779 : 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 5 : 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 774 : 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 0 : 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 9 : 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 0 : 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 9 : 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 9 : 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 1 : 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 8 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 0 : 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 14 : 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 10 : 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 4 : 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 0 : 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 4 : 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 4 : 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 0 : 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 0 : 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 35 : 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 28 : 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 7 : 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 0 : 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 9 : 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 9 : 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 0 : 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 0 : 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 49 : 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 5 : 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 44 : 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 0 : 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 30 : 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 6 : 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 24 : 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 2749390 : _tmp_243_rule(Parser *p)
38388 : {
38389 2749390 : if (p->level++ == MAXSTACK) {
38390 0 : p->error_indicator = 1;
38391 0 : PyErr_NoMemory();
38392 : }
38393 2749390 : if (p->error_indicator) {
38394 0 : p->level--;
38395 0 : return NULL;
38396 : }
38397 2749390 : void * _res = NULL;
38398 2749390 : int _mark = p->mark;
38399 : { // assignment_expression
38400 2749390 : if (p->error_indicator) {
38401 0 : p->level--;
38402 0 : return NULL;
38403 : }
38404 2749390 : D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
38405 : expr_ty assignment_expression_var;
38406 2749390 : if (
38407 2749390 : (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
38408 : )
38409 : {
38410 33 : 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 2749360 : p->mark = _mark;
38415 2749360 : 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 2749360 : if (p->error_indicator) {
38420 6 : p->level--;
38421 6 : return NULL;
38422 : }
38423 2749350 : D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
38424 : expr_ty expression_var;
38425 2749350 : if (
38426 2749350 : (expression_var = expression_rule(p)) // expression
38427 2190570 : &&
38428 2190570 : _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
38429 : )
38430 : {
38431 2190570 : D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
38432 2190570 : _res = expression_var;
38433 2190570 : goto done;
38434 : }
38435 558783 : p->mark = _mark;
38436 558783 : 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 558783 : _res = NULL;
38440 2749390 : done:
38441 2749390 : p->level--;
38442 2749390 : 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 0 : 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 10 : 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 4 : 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 6 : 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 0 : 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 4 : 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 3 : 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 1 : 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 0 : 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 28 : 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 11 : 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 17 : 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 0 : 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 9 : 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 7 : 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 2 : 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 0 : 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 0 : 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 49 : D(fprintf(stderr, "%*c> _loop1_248[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));
38643 : excepthandler_ty except_block_var;
38644 106 : 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 0 : 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 49 : 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 0 : 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 0 : 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 0 : 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 30 : 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 69 : 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 0 : 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 30 : 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 0 : 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 225947 : _PyPegen_parse(Parser *p)
38763 : {
38764 : // Initialize keywords
38765 225947 : p->keywords = reserved_keywords;
38766 225947 : p->n_keyword_lists = n_keyword_lists;
38767 225947 : p->soft_keywords = soft_keywords;
38768 :
38769 : // Run parser
38770 225947 : void *result = NULL;
38771 225947 : if (p->start_rule == Py_file_input) {
38772 49568 : result = file_rule(p);
38773 176379 : } else if (p->start_rule == Py_single_input) {
38774 5080 : result = interactive_rule(p);
38775 171299 : } else if (p->start_rule == Py_eval_input) {
38776 75155 : result = eval_rule(p);
38777 96144 : } else if (p->start_rule == Py_func_type_input) {
38778 18 : result = func_type_rule(p);
38779 96126 : } else if (p->start_rule == Py_fstring_input) {
38780 96126 : result = fstring_rule(p);
38781 : }
38782 :
38783 225947 : return result;
38784 : }
|
