Debian Codegraph @

Parser/parser.c

raw
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 # ifdef Py_DEBUG
12 # define MAXSTACK 1000
13 # else
14 # define MAXSTACK 4000
15 # endif
16 #else
17 # define MAXSTACK 6000
18 #endif
19 static const int n_keyword_lists = 9;
20 static KeywordToken *reserved_keywords[] = {
21 (KeywordToken[]) {{NULL, -1}},
22 (KeywordToken[]) {{NULL, -1}},
23 (KeywordToken[]) {
24 {"if", 660},
25 {"as", 658},
26 {"in", 671},
27 {"or", 581},
28 {"is", 589},
29 {NULL, -1},
30 },
31 (KeywordToken[]) {
32 {"del", 616},
33 {"def", 675},
34 {"for", 670},
35 {"try", 642},
36 {"and", 582},
37 {"not", 679},
38 {NULL, -1},
39 },
40 (KeywordToken[]) {
41 {"from", 621},
42 {"pass", 504},
43 {"with", 633},
44 {"elif", 662},
45 {"else", 663},
46 {"None", 614},
47 {"True", 613},
48 {NULL, -1},
49 },
50 (KeywordToken[]) {
51 {"raise", 525},
52 {"yield", 580},
53 {"break", 508},
54 {"async", 674},
55 {"class", 677},
56 {"while", 665},
57 {"False", 615},
58 {"await", 590},
59 {NULL, -1},
60 },
61 (KeywordToken[]) {
62 {"return", 522},
63 {"import", 622},
64 {"assert", 529},
65 {"global", 526},
66 {"except", 655},
67 {"lambda", 612},
68 {NULL, -1},
69 },
70 (KeywordToken[]) {
71 {"finally", 651},
72 {NULL, -1},
73 },
74 (KeywordToken[]) {
75 {"continue", 509},
76 {"nonlocal", 527},
77 {NULL, -1},
78 },
79 };
80 static char *soft_keywords[] = {
81 "_",
82 "case",
83 "match",
84 "type",
85 NULL,
86 };
87 #define file_type 1000
88 #define interactive_type 1001
89 #define eval_type 1002
90 #define func_type_type 1003
91 #define statements_type 1004
92 #define statement_type 1005
93 #define statement_newline_type 1006
94 #define simple_stmts_type 1007
95 #define simple_stmt_type 1008
96 #define compound_stmt_type 1009
97 #define assignment_type 1010
98 #define annotated_rhs_type 1011
99 #define augassign_type 1012
100 #define return_stmt_type 1013
101 #define raise_stmt_type 1014
102 #define global_stmt_type 1015
103 #define nonlocal_stmt_type 1016
104 #define del_stmt_type 1017
105 #define yield_stmt_type 1018
106 #define assert_stmt_type 1019
107 #define import_stmt_type 1020
108 #define import_name_type 1021
109 #define import_from_type 1022
110 #define import_from_targets_type 1023
111 #define import_from_as_names_type 1024
112 #define import_from_as_name_type 1025
113 #define dotted_as_names_type 1026
114 #define dotted_as_name_type 1027
115 #define dotted_name_type 1028 // Left-recursive
116 #define block_type 1029
117 #define decorators_type 1030
118 #define class_def_type 1031
119 #define class_def_raw_type 1032
120 #define function_def_type 1033
121 #define function_def_raw_type 1034
122 #define params_type 1035
123 #define parameters_type 1036
124 #define slash_no_default_type 1037
125 #define slash_with_default_type 1038
126 #define star_etc_type 1039
127 #define kwds_type 1040
128 #define param_no_default_type 1041
129 #define param_no_default_star_annotation_type 1042
130 #define param_with_default_type 1043
131 #define param_maybe_default_type 1044
132 #define param_type 1045
133 #define param_star_annotation_type 1046
134 #define annotation_type 1047
135 #define star_annotation_type 1048
136 #define default_type 1049
137 #define if_stmt_type 1050
138 #define elif_stmt_type 1051
139 #define else_block_type 1052
140 #define while_stmt_type 1053
141 #define for_stmt_type 1054
142 #define with_stmt_type 1055
143 #define with_item_type 1056
144 #define try_stmt_type 1057
145 #define except_block_type 1058
146 #define except_star_block_type 1059
147 #define finally_block_type 1060
148 #define match_stmt_type 1061
149 #define subject_expr_type 1062
150 #define case_block_type 1063
151 #define guard_type 1064
152 #define patterns_type 1065
153 #define pattern_type 1066
154 #define as_pattern_type 1067
155 #define or_pattern_type 1068
156 #define closed_pattern_type 1069
157 #define literal_pattern_type 1070
158 #define literal_expr_type 1071
159 #define complex_number_type 1072
160 #define signed_number_type 1073
161 #define signed_real_number_type 1074
162 #define real_number_type 1075
163 #define imaginary_number_type 1076
164 #define capture_pattern_type 1077
165 #define pattern_capture_target_type 1078
166 #define wildcard_pattern_type 1079
167 #define value_pattern_type 1080
168 #define attr_type 1081 // Left-recursive
169 #define name_or_attr_type 1082 // Left-recursive
170 #define group_pattern_type 1083
171 #define sequence_pattern_type 1084
172 #define open_sequence_pattern_type 1085
173 #define maybe_sequence_pattern_type 1086
174 #define maybe_star_pattern_type 1087
175 #define star_pattern_type 1088
176 #define mapping_pattern_type 1089
177 #define items_pattern_type 1090
178 #define key_value_pattern_type 1091
179 #define double_star_pattern_type 1092
180 #define class_pattern_type 1093
181 #define positional_patterns_type 1094
182 #define keyword_patterns_type 1095
183 #define keyword_pattern_type 1096
184 #define type_alias_type 1097
185 #define type_params_type 1098
186 #define type_param_seq_type 1099
187 #define type_param_type 1100
188 #define type_param_bound_type 1101
189 #define type_param_default_type 1102
190 #define type_param_starred_default_type 1103
191 #define expressions_type 1104
192 #define expression_type 1105
193 #define yield_expr_type 1106
194 #define star_expressions_type 1107
195 #define star_expression_type 1108
196 #define star_named_expressions_type 1109
197 #define star_named_expression_type 1110
198 #define assignment_expression_type 1111
199 #define named_expression_type 1112
200 #define disjunction_type 1113
201 #define conjunction_type 1114
202 #define inversion_type 1115
203 #define comparison_type 1116
204 #define compare_op_bitwise_or_pair_type 1117
205 #define eq_bitwise_or_type 1118
206 #define noteq_bitwise_or_type 1119
207 #define lte_bitwise_or_type 1120
208 #define lt_bitwise_or_type 1121
209 #define gte_bitwise_or_type 1122
210 #define gt_bitwise_or_type 1123
211 #define notin_bitwise_or_type 1124
212 #define in_bitwise_or_type 1125
213 #define isnot_bitwise_or_type 1126
214 #define is_bitwise_or_type 1127
215 #define bitwise_or_type 1128 // Left-recursive
216 #define bitwise_xor_type 1129 // Left-recursive
217 #define bitwise_and_type 1130 // Left-recursive
218 #define shift_expr_type 1131 // Left-recursive
219 #define sum_type 1132 // Left-recursive
220 #define term_type 1133 // Left-recursive
221 #define factor_type 1134
222 #define power_type 1135
223 #define await_primary_type 1136
224 #define primary_type 1137 // Left-recursive
225 #define slices_type 1138
226 #define slice_type 1139
227 #define atom_type 1140
228 #define group_type 1141
229 #define lambdef_type 1142
230 #define lambda_params_type 1143
231 #define lambda_parameters_type 1144
232 #define lambda_slash_no_default_type 1145
233 #define lambda_slash_with_default_type 1146
234 #define lambda_star_etc_type 1147
235 #define lambda_kwds_type 1148
236 #define lambda_param_no_default_type 1149
237 #define lambda_param_with_default_type 1150
238 #define lambda_param_maybe_default_type 1151
239 #define lambda_param_type 1152
240 #define fstring_middle_type 1153
241 #define fstring_replacement_field_type 1154
242 #define fstring_conversion_type 1155
243 #define fstring_full_format_spec_type 1156
244 #define fstring_format_spec_type 1157
245 #define fstring_type 1158
246 #define string_type 1159
247 #define strings_type 1160
248 #define list_type 1161
249 #define tuple_type 1162
250 #define set_type 1163
251 #define dict_type 1164
252 #define double_starred_kvpairs_type 1165
253 #define double_starred_kvpair_type 1166
254 #define kvpair_type 1167
255 #define for_if_clauses_type 1168
256 #define for_if_clause_type 1169
257 #define listcomp_type 1170
258 #define setcomp_type 1171
259 #define genexp_type 1172
260 #define dictcomp_type 1173
261 #define arguments_type 1174
262 #define args_type 1175
263 #define kwargs_type 1176
264 #define starred_expression_type 1177
265 #define kwarg_or_starred_type 1178
266 #define kwarg_or_double_starred_type 1179
267 #define star_targets_type 1180
268 #define star_targets_list_seq_type 1181
269 #define star_targets_tuple_seq_type 1182
270 #define star_target_type 1183
271 #define target_with_star_atom_type 1184
272 #define star_atom_type 1185
273 #define single_target_type 1186
274 #define single_subscript_attribute_target_type 1187
275 #define t_primary_type 1188 // Left-recursive
276 #define t_lookahead_type 1189
277 #define del_targets_type 1190
278 #define del_target_type 1191
279 #define del_t_atom_type 1192
280 #define type_expressions_type 1193
281 #define func_type_comment_type 1194
282 #define invalid_arguments_type 1195
283 #define invalid_kwarg_type 1196
284 #define expression_without_invalid_type 1197
285 #define invalid_legacy_expression_type 1198
286 #define invalid_expression_type 1199
287 #define invalid_named_expression_type 1200
288 #define invalid_assignment_type 1201
289 #define invalid_ann_assign_target_type 1202
290 #define invalid_del_stmt_type 1203
291 #define invalid_block_type 1204
292 #define invalid_comprehension_type 1205
293 #define invalid_dict_comprehension_type 1206
294 #define invalid_parameters_type 1207
295 #define invalid_default_type 1208
296 #define invalid_star_etc_type 1209
297 #define invalid_kwds_type 1210
298 #define invalid_parameters_helper_type 1211
299 #define invalid_lambda_parameters_type 1212
300 #define invalid_lambda_parameters_helper_type 1213
301 #define invalid_lambda_star_etc_type 1214
302 #define invalid_lambda_kwds_type 1215
303 #define invalid_double_type_comments_type 1216
304 #define invalid_with_item_type 1217
305 #define invalid_for_target_type 1218
306 #define invalid_group_type 1219
307 #define invalid_import_type 1220
308 #define invalid_import_from_targets_type 1221
309 #define invalid_with_stmt_type 1222
310 #define invalid_with_stmt_indent_type 1223
311 #define invalid_try_stmt_type 1224
312 #define invalid_except_stmt_type 1225
313 #define invalid_finally_stmt_type 1226
314 #define invalid_except_stmt_indent_type 1227
315 #define invalid_except_star_stmt_indent_type 1228
316 #define invalid_match_stmt_type 1229
317 #define invalid_case_block_type 1230
318 #define invalid_as_pattern_type 1231
319 #define invalid_class_pattern_type 1232
320 #define invalid_class_argument_pattern_type 1233
321 #define invalid_if_stmt_type 1234
322 #define invalid_elif_stmt_type 1235
323 #define invalid_else_stmt_type 1236
324 #define invalid_while_stmt_type 1237
325 #define invalid_for_stmt_type 1238
326 #define invalid_def_raw_type 1239
327 #define invalid_class_def_raw_type 1240
328 #define invalid_double_starred_kvpairs_type 1241
329 #define invalid_kvpair_type 1242
330 #define invalid_starred_expression_type 1243
331 #define invalid_replacement_field_type 1244
332 #define invalid_conversion_character_type 1245
333 #define invalid_arithmetic_type 1246
334 #define invalid_factor_type 1247
335 #define invalid_type_params_type 1248
336 #define _loop0_1_type 1249
337 #define _loop0_2_type 1250
338 #define _loop1_3_type 1251
339 #define _loop0_5_type 1252
340 #define _gather_4_type 1253
341 #define _tmp_6_type 1254
342 #define _tmp_7_type 1255
343 #define _tmp_8_type 1256
344 #define _tmp_9_type 1257
345 #define _tmp_10_type 1258
346 #define _tmp_11_type 1259
347 #define _tmp_12_type 1260
348 #define _tmp_13_type 1261
349 #define _loop1_14_type 1262
350 #define _tmp_15_type 1263
351 #define _tmp_16_type 1264
352 #define _tmp_17_type 1265
353 #define _loop0_19_type 1266
354 #define _gather_18_type 1267
355 #define _loop0_21_type 1268
356 #define _gather_20_type 1269
357 #define _tmp_22_type 1270
358 #define _tmp_23_type 1271
359 #define _loop0_24_type 1272
360 #define _loop1_25_type 1273
361 #define _loop0_27_type 1274
362 #define _gather_26_type 1275
363 #define _tmp_28_type 1276
364 #define _loop0_30_type 1277
365 #define _gather_29_type 1278
366 #define _tmp_31_type 1279
367 #define _loop1_32_type 1280
368 #define _tmp_33_type 1281
369 #define _tmp_34_type 1282
370 #define _tmp_35_type 1283
371 #define _loop0_36_type 1284
372 #define _loop0_37_type 1285
373 #define _loop0_38_type 1286
374 #define _loop1_39_type 1287
375 #define _loop0_40_type 1288
376 #define _loop1_41_type 1289
377 #define _loop1_42_type 1290
378 #define _loop1_43_type 1291
379 #define _loop0_44_type 1292
380 #define _loop1_45_type 1293
381 #define _loop0_46_type 1294
382 #define _loop1_47_type 1295
383 #define _loop0_48_type 1296
384 #define _loop0_49_type 1297
385 #define _loop1_50_type 1298
386 #define _loop0_52_type 1299
387 #define _gather_51_type 1300
388 #define _loop0_54_type 1301
389 #define _gather_53_type 1302
390 #define _loop0_56_type 1303
391 #define _gather_55_type 1304
392 #define _loop0_58_type 1305
393 #define _gather_57_type 1306
394 #define _tmp_59_type 1307
395 #define _loop1_60_type 1308
396 #define _loop1_61_type 1309
397 #define _tmp_62_type 1310
398 #define _tmp_63_type 1311
399 #define _loop1_64_type 1312
400 #define _loop0_66_type 1313
401 #define _gather_65_type 1314
402 #define _tmp_67_type 1315
403 #define _tmp_68_type 1316
404 #define _tmp_69_type 1317
405 #define _tmp_70_type 1318
406 #define _loop0_72_type 1319
407 #define _gather_71_type 1320
408 #define _loop0_74_type 1321
409 #define _gather_73_type 1322
410 #define _tmp_75_type 1323
411 #define _loop0_77_type 1324
412 #define _gather_76_type 1325
413 #define _loop0_79_type 1326
414 #define _gather_78_type 1327
415 #define _loop0_81_type 1328
416 #define _gather_80_type 1329
417 #define _loop1_82_type 1330
418 #define _loop1_83_type 1331
419 #define _loop0_85_type 1332
420 #define _gather_84_type 1333
421 #define _loop1_86_type 1334
422 #define _loop1_87_type 1335
423 #define _loop1_88_type 1336
424 #define _tmp_89_type 1337
425 #define _loop0_91_type 1338
426 #define _gather_90_type 1339
427 #define _tmp_92_type 1340
428 #define _tmp_93_type 1341
429 #define _tmp_94_type 1342
430 #define _tmp_95_type 1343
431 #define _tmp_96_type 1344
432 #define _tmp_97_type 1345
433 #define _loop0_98_type 1346
434 #define _loop0_99_type 1347
435 #define _loop0_100_type 1348
436 #define _loop1_101_type 1349
437 #define _loop0_102_type 1350
438 #define _loop1_103_type 1351
439 #define _loop1_104_type 1352
440 #define _loop1_105_type 1353
441 #define _loop0_106_type 1354
442 #define _loop1_107_type 1355
443 #define _loop0_108_type 1356
444 #define _loop1_109_type 1357
445 #define _loop0_110_type 1358
446 #define _loop1_111_type 1359
447 #define _loop0_112_type 1360
448 #define _loop0_113_type 1361
449 #define _loop1_114_type 1362
450 #define _tmp_115_type 1363
451 #define _loop0_117_type 1364
452 #define _gather_116_type 1365
453 #define _loop1_118_type 1366
454 #define _loop0_119_type 1367
455 #define _loop0_120_type 1368
456 #define _tmp_121_type 1369
457 #define _tmp_122_type 1370
458 #define _loop0_124_type 1371
459 #define _gather_123_type 1372
460 #define _tmp_125_type 1373
461 #define _loop0_127_type 1374
462 #define _gather_126_type 1375
463 #define _loop0_129_type 1376
464 #define _gather_128_type 1377
465 #define _loop0_131_type 1378
466 #define _gather_130_type 1379
467 #define _loop0_133_type 1380
468 #define _gather_132_type 1381
469 #define _loop0_134_type 1382
470 #define _loop0_136_type 1383
471 #define _gather_135_type 1384
472 #define _loop1_137_type 1385
473 #define _tmp_138_type 1386
474 #define _loop0_140_type 1387
475 #define _gather_139_type 1388
476 #define _loop0_142_type 1389
477 #define _gather_141_type 1390
478 #define _loop0_144_type 1391
479 #define _gather_143_type 1392
480 #define _loop0_146_type 1393
481 #define _gather_145_type 1394
482 #define _loop0_148_type 1395
483 #define _gather_147_type 1396
484 #define _tmp_149_type 1397
485 #define _tmp_150_type 1398
486 #define _loop0_152_type 1399
487 #define _gather_151_type 1400
488 #define _tmp_153_type 1401
489 #define _tmp_154_type 1402
490 #define _tmp_155_type 1403
491 #define _tmp_156_type 1404
492 #define _tmp_157_type 1405
493 #define _tmp_158_type 1406
494 #define _tmp_159_type 1407
495 #define _tmp_160_type 1408
496 #define _tmp_161_type 1409
497 #define _tmp_162_type 1410
498 #define _loop0_163_type 1411
499 #define _loop0_164_type 1412
500 #define _loop0_165_type 1413
501 #define _tmp_166_type 1414
502 #define _tmp_167_type 1415
503 #define _tmp_168_type 1416
504 #define _tmp_169_type 1417
505 #define _loop0_170_type 1418
506 #define _loop0_171_type 1419
507 #define _loop0_172_type 1420
508 #define _loop1_173_type 1421
509 #define _tmp_174_type 1422
510 #define _loop0_175_type 1423
511 #define _tmp_176_type 1424
512 #define _loop0_177_type 1425
513 #define _loop1_178_type 1426
514 #define _tmp_179_type 1427
515 #define _tmp_180_type 1428
516 #define _tmp_181_type 1429
517 #define _loop0_182_type 1430
518 #define _tmp_183_type 1431
519 #define _tmp_184_type 1432
520 #define _loop1_185_type 1433
521 #define _tmp_186_type 1434
522 #define _loop0_187_type 1435
523 #define _loop0_188_type 1436
524 #define _loop0_189_type 1437
525 #define _loop0_191_type 1438
526 #define _gather_190_type 1439
527 #define _tmp_192_type 1440
528 #define _loop0_193_type 1441
529 #define _tmp_194_type 1442
530 #define _loop0_195_type 1443
531 #define _loop1_196_type 1444
532 #define _loop1_197_type 1445
533 #define _tmp_198_type 1446
534 #define _tmp_199_type 1447
535 #define _loop0_200_type 1448
536 #define _tmp_201_type 1449
537 #define _tmp_202_type 1450
538 #define _tmp_203_type 1451
539 #define _loop0_205_type 1452
540 #define _gather_204_type 1453
541 #define _loop0_207_type 1454
542 #define _gather_206_type 1455
543 #define _loop0_209_type 1456
544 #define _gather_208_type 1457
545 #define _loop0_211_type 1458
546 #define _gather_210_type 1459
547 #define _loop0_213_type 1460
548 #define _gather_212_type 1461
549 #define _tmp_214_type 1462
550 #define _loop0_215_type 1463
551 #define _loop1_216_type 1464
552 #define _tmp_217_type 1465
553 #define _loop0_218_type 1466
554 #define _loop1_219_type 1467
555 #define _tmp_220_type 1468
556 #define _tmp_221_type 1469
557 #define _tmp_222_type 1470
558 #define _tmp_223_type 1471
559 #define _tmp_224_type 1472
560 #define _tmp_225_type 1473
561 #define _tmp_226_type 1474
562 #define _tmp_227_type 1475
563 #define _tmp_228_type 1476
564 #define _tmp_229_type 1477
565 #define _tmp_230_type 1478
566 #define _loop0_232_type 1479
567 #define _gather_231_type 1480
568 #define _tmp_233_type 1481
569 #define _tmp_234_type 1482
570 #define _tmp_235_type 1483
571 #define _tmp_236_type 1484
572 #define _tmp_237_type 1485
573 #define _tmp_238_type 1486
574 #define _tmp_239_type 1487
575 #define _loop0_240_type 1488
576 #define _tmp_241_type 1489
577 #define _tmp_242_type 1490
578 #define _tmp_243_type 1491
579 #define _tmp_244_type 1492
580 #define _tmp_245_type 1493
581 #define _tmp_246_type 1494
582 #define _tmp_247_type 1495
583 #define _tmp_248_type 1496
584 #define _tmp_249_type 1497
585 #define _tmp_250_type 1498
586 #define _tmp_251_type 1499
587 #define _tmp_252_type 1500
588 #define _tmp_253_type 1501
589 #define _tmp_254_type 1502
590 #define _tmp_255_type 1503
591 #define _tmp_256_type 1504
592 #define _loop0_257_type 1505
593 #define _tmp_258_type 1506
594 #define _tmp_259_type 1507
595 #define _tmp_260_type 1508
596 #define _tmp_261_type 1509
597 #define _tmp_262_type 1510
598 #define _tmp_263_type 1511
599 #define _tmp_264_type 1512
600 #define _tmp_265_type 1513
601 #define _tmp_266_type 1514
602 #define _tmp_267_type 1515
603 #define _tmp_268_type 1516
604 #define _tmp_269_type 1517
605 #define _tmp_270_type 1518
606 #define _tmp_271_type 1519
607 #define _tmp_272_type 1520
608 #define _tmp_273_type 1521
609 #define _loop0_275_type 1522
610 #define _gather_274_type 1523
611 #define _tmp_276_type 1524
612 #define _tmp_277_type 1525
613 #define _tmp_278_type 1526
614 #define _tmp_279_type 1527
615 #define _tmp_280_type 1528
616 #define _tmp_281_type 1529
617
618 static mod_ty file_rule(Parser *p);
619 static mod_ty interactive_rule(Parser *p);
620 static mod_ty eval_rule(Parser *p);
621 static mod_ty func_type_rule(Parser *p);
622 static asdl_stmt_seq* statements_rule(Parser *p);
623 static asdl_stmt_seq* statement_rule(Parser *p);
624 static asdl_stmt_seq* statement_newline_rule(Parser *p);
625 static asdl_stmt_seq* simple_stmts_rule(Parser *p);
626 static stmt_ty simple_stmt_rule(Parser *p);
627 static stmt_ty compound_stmt_rule(Parser *p);
628 static stmt_ty assignment_rule(Parser *p);
629 static expr_ty annotated_rhs_rule(Parser *p);
630 static AugOperator* augassign_rule(Parser *p);
631 static stmt_ty return_stmt_rule(Parser *p);
632 static stmt_ty raise_stmt_rule(Parser *p);
633 static stmt_ty global_stmt_rule(Parser *p);
634 static stmt_ty nonlocal_stmt_rule(Parser *p);
635 static stmt_ty del_stmt_rule(Parser *p);
636 static stmt_ty yield_stmt_rule(Parser *p);
637 static stmt_ty assert_stmt_rule(Parser *p);
638 static stmt_ty import_stmt_rule(Parser *p);
639 static stmt_ty import_name_rule(Parser *p);
640 static stmt_ty import_from_rule(Parser *p);
641 static asdl_alias_seq* import_from_targets_rule(Parser *p);
642 static asdl_alias_seq* import_from_as_names_rule(Parser *p);
643 static alias_ty import_from_as_name_rule(Parser *p);
644 static asdl_alias_seq* dotted_as_names_rule(Parser *p);
645 static alias_ty dotted_as_name_rule(Parser *p);
646 static expr_ty dotted_name_rule(Parser *p);
647 static asdl_stmt_seq* block_rule(Parser *p);
648 static asdl_expr_seq* decorators_rule(Parser *p);
649 static stmt_ty class_def_rule(Parser *p);
650 static stmt_ty class_def_raw_rule(Parser *p);
651 static stmt_ty function_def_rule(Parser *p);
652 static stmt_ty function_def_raw_rule(Parser *p);
653 static arguments_ty params_rule(Parser *p);
654 static arguments_ty parameters_rule(Parser *p);
655 static asdl_arg_seq* slash_no_default_rule(Parser *p);
656 static SlashWithDefault* slash_with_default_rule(Parser *p);
657 static StarEtc* star_etc_rule(Parser *p);
658 static arg_ty kwds_rule(Parser *p);
659 static arg_ty param_no_default_rule(Parser *p);
660 static arg_ty param_no_default_star_annotation_rule(Parser *p);
661 static NameDefaultPair* param_with_default_rule(Parser *p);
662 static NameDefaultPair* param_maybe_default_rule(Parser *p);
663 static arg_ty param_rule(Parser *p);
664 static arg_ty param_star_annotation_rule(Parser *p);
665 static expr_ty annotation_rule(Parser *p);
666 static expr_ty star_annotation_rule(Parser *p);
667 static expr_ty default_rule(Parser *p);
668 static stmt_ty if_stmt_rule(Parser *p);
669 static stmt_ty elif_stmt_rule(Parser *p);
670 static asdl_stmt_seq* else_block_rule(Parser *p);
671 static stmt_ty while_stmt_rule(Parser *p);
672 static stmt_ty for_stmt_rule(Parser *p);
673 static stmt_ty with_stmt_rule(Parser *p);
674 static withitem_ty with_item_rule(Parser *p);
675 static stmt_ty try_stmt_rule(Parser *p);
676 static excepthandler_ty except_block_rule(Parser *p);
677 static excepthandler_ty except_star_block_rule(Parser *p);
678 static asdl_stmt_seq* finally_block_rule(Parser *p);
679 static stmt_ty match_stmt_rule(Parser *p);
680 static expr_ty subject_expr_rule(Parser *p);
681 static match_case_ty case_block_rule(Parser *p);
682 static expr_ty guard_rule(Parser *p);
683 static pattern_ty patterns_rule(Parser *p);
684 static pattern_ty pattern_rule(Parser *p);
685 static pattern_ty as_pattern_rule(Parser *p);
686 static pattern_ty or_pattern_rule(Parser *p);
687 static pattern_ty closed_pattern_rule(Parser *p);
688 static pattern_ty literal_pattern_rule(Parser *p);
689 static expr_ty literal_expr_rule(Parser *p);
690 static expr_ty complex_number_rule(Parser *p);
691 static expr_ty signed_number_rule(Parser *p);
692 static expr_ty signed_real_number_rule(Parser *p);
693 static expr_ty real_number_rule(Parser *p);
694 static expr_ty imaginary_number_rule(Parser *p);
695 static pattern_ty capture_pattern_rule(Parser *p);
696 static expr_ty pattern_capture_target_rule(Parser *p);
697 static pattern_ty wildcard_pattern_rule(Parser *p);
698 static pattern_ty value_pattern_rule(Parser *p);
699 static expr_ty attr_rule(Parser *p);
700 static expr_ty name_or_attr_rule(Parser *p);
701 static pattern_ty group_pattern_rule(Parser *p);
702 static pattern_ty sequence_pattern_rule(Parser *p);
703 static asdl_seq* open_sequence_pattern_rule(Parser *p);
704 static asdl_seq* maybe_sequence_pattern_rule(Parser *p);
705 static pattern_ty maybe_star_pattern_rule(Parser *p);
706 static pattern_ty star_pattern_rule(Parser *p);
707 static pattern_ty mapping_pattern_rule(Parser *p);
708 static asdl_seq* items_pattern_rule(Parser *p);
709 static KeyPatternPair* key_value_pattern_rule(Parser *p);
710 static expr_ty double_star_pattern_rule(Parser *p);
711 static pattern_ty class_pattern_rule(Parser *p);
712 static asdl_pattern_seq* positional_patterns_rule(Parser *p);
713 static asdl_seq* keyword_patterns_rule(Parser *p);
714 static KeyPatternPair* keyword_pattern_rule(Parser *p);
715 static stmt_ty type_alias_rule(Parser *p);
716 static asdl_type_param_seq* type_params_rule(Parser *p);
717 static asdl_type_param_seq* type_param_seq_rule(Parser *p);
718 static type_param_ty type_param_rule(Parser *p);
719 static expr_ty type_param_bound_rule(Parser *p);
720 static expr_ty type_param_default_rule(Parser *p);
721 static expr_ty type_param_starred_default_rule(Parser *p);
722 static expr_ty expressions_rule(Parser *p);
723 static expr_ty expression_rule(Parser *p);
724 static expr_ty yield_expr_rule(Parser *p);
725 static expr_ty star_expressions_rule(Parser *p);
726 static expr_ty star_expression_rule(Parser *p);
727 static asdl_expr_seq* star_named_expressions_rule(Parser *p);
728 static expr_ty star_named_expression_rule(Parser *p);
729 static expr_ty assignment_expression_rule(Parser *p);
730 static expr_ty named_expression_rule(Parser *p);
731 static expr_ty disjunction_rule(Parser *p);
732 static expr_ty conjunction_rule(Parser *p);
733 static expr_ty inversion_rule(Parser *p);
734 static expr_ty comparison_rule(Parser *p);
735 static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p);
736 static CmpopExprPair* eq_bitwise_or_rule(Parser *p);
737 static CmpopExprPair* noteq_bitwise_or_rule(Parser *p);
738 static CmpopExprPair* lte_bitwise_or_rule(Parser *p);
739 static CmpopExprPair* lt_bitwise_or_rule(Parser *p);
740 static CmpopExprPair* gte_bitwise_or_rule(Parser *p);
741 static CmpopExprPair* gt_bitwise_or_rule(Parser *p);
742 static CmpopExprPair* notin_bitwise_or_rule(Parser *p);
743 static CmpopExprPair* in_bitwise_or_rule(Parser *p);
744 static CmpopExprPair* isnot_bitwise_or_rule(Parser *p);
745 static CmpopExprPair* is_bitwise_or_rule(Parser *p);
746 static expr_ty bitwise_or_rule(Parser *p);
747 static expr_ty bitwise_xor_rule(Parser *p);
748 static expr_ty bitwise_and_rule(Parser *p);
749 static expr_ty shift_expr_rule(Parser *p);
750 static expr_ty sum_rule(Parser *p);
751 static expr_ty term_rule(Parser *p);
752 static expr_ty factor_rule(Parser *p);
753 static expr_ty power_rule(Parser *p);
754 static expr_ty await_primary_rule(Parser *p);
755 static expr_ty primary_rule(Parser *p);
756 static expr_ty slices_rule(Parser *p);
757 static expr_ty slice_rule(Parser *p);
758 static expr_ty atom_rule(Parser *p);
759 static expr_ty group_rule(Parser *p);
760 static expr_ty lambdef_rule(Parser *p);
761 static arguments_ty lambda_params_rule(Parser *p);
762 static arguments_ty lambda_parameters_rule(Parser *p);
763 static asdl_arg_seq* lambda_slash_no_default_rule(Parser *p);
764 static SlashWithDefault* lambda_slash_with_default_rule(Parser *p);
765 static StarEtc* lambda_star_etc_rule(Parser *p);
766 static arg_ty lambda_kwds_rule(Parser *p);
767 static arg_ty lambda_param_no_default_rule(Parser *p);
768 static NameDefaultPair* lambda_param_with_default_rule(Parser *p);
769 static NameDefaultPair* lambda_param_maybe_default_rule(Parser *p);
770 static arg_ty lambda_param_rule(Parser *p);
771 static expr_ty fstring_middle_rule(Parser *p);
772 static expr_ty fstring_replacement_field_rule(Parser *p);
773 static ResultTokenWithMetadata* fstring_conversion_rule(Parser *p);
774 static ResultTokenWithMetadata* fstring_full_format_spec_rule(Parser *p);
775 static expr_ty fstring_format_spec_rule(Parser *p);
776 static expr_ty fstring_rule(Parser *p);
777 static expr_ty string_rule(Parser *p);
778 static expr_ty strings_rule(Parser *p);
779 static expr_ty list_rule(Parser *p);
780 static expr_ty tuple_rule(Parser *p);
781 static expr_ty set_rule(Parser *p);
782 static expr_ty dict_rule(Parser *p);
783 static asdl_seq* double_starred_kvpairs_rule(Parser *p);
784 static KeyValuePair* double_starred_kvpair_rule(Parser *p);
785 static KeyValuePair* kvpair_rule(Parser *p);
786 static asdl_comprehension_seq* for_if_clauses_rule(Parser *p);
787 static comprehension_ty for_if_clause_rule(Parser *p);
788 static expr_ty listcomp_rule(Parser *p);
789 static expr_ty setcomp_rule(Parser *p);
790 static expr_ty genexp_rule(Parser *p);
791 static expr_ty dictcomp_rule(Parser *p);
792 static expr_ty arguments_rule(Parser *p);
793 static expr_ty args_rule(Parser *p);
794 static asdl_seq* kwargs_rule(Parser *p);
795 static expr_ty starred_expression_rule(Parser *p);
796 static KeywordOrStarred* kwarg_or_starred_rule(Parser *p);
797 static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p);
798 static expr_ty star_targets_rule(Parser *p);
799 static asdl_expr_seq* star_targets_list_seq_rule(Parser *p);
800 static asdl_expr_seq* star_targets_tuple_seq_rule(Parser *p);
801 static expr_ty star_target_rule(Parser *p);
802 static expr_ty target_with_star_atom_rule(Parser *p);
803 static expr_ty star_atom_rule(Parser *p);
804 static expr_ty single_target_rule(Parser *p);
805 static expr_ty single_subscript_attribute_target_rule(Parser *p);
806 static expr_ty t_primary_rule(Parser *p);
807 static void *t_lookahead_rule(Parser *p);
808 static asdl_expr_seq* del_targets_rule(Parser *p);
809 static expr_ty del_target_rule(Parser *p);
810 static expr_ty del_t_atom_rule(Parser *p);
811 static asdl_expr_seq* type_expressions_rule(Parser *p);
812 static Token* func_type_comment_rule(Parser *p);
813 static void *invalid_arguments_rule(Parser *p);
814 static void *invalid_kwarg_rule(Parser *p);
815 static expr_ty expression_without_invalid_rule(Parser *p);
816 static void *invalid_legacy_expression_rule(Parser *p);
817 static void *invalid_expression_rule(Parser *p);
818 static void *invalid_named_expression_rule(Parser *p);
819 static void *invalid_assignment_rule(Parser *p);
820 static expr_ty invalid_ann_assign_target_rule(Parser *p);
821 static void *invalid_del_stmt_rule(Parser *p);
822 static void *invalid_block_rule(Parser *p);
823 static void *invalid_comprehension_rule(Parser *p);
824 static void *invalid_dict_comprehension_rule(Parser *p);
825 static void *invalid_parameters_rule(Parser *p);
826 static void *invalid_default_rule(Parser *p);
827 static void *invalid_star_etc_rule(Parser *p);
828 static void *invalid_kwds_rule(Parser *p);
829 static void *invalid_parameters_helper_rule(Parser *p);
830 static void *invalid_lambda_parameters_rule(Parser *p);
831 static void *invalid_lambda_parameters_helper_rule(Parser *p);
832 static void *invalid_lambda_star_etc_rule(Parser *p);
833 static void *invalid_lambda_kwds_rule(Parser *p);
834 static void *invalid_double_type_comments_rule(Parser *p);
835 static void *invalid_with_item_rule(Parser *p);
836 static void *invalid_for_target_rule(Parser *p);
837 static void *invalid_group_rule(Parser *p);
838 static void *invalid_import_rule(Parser *p);
839 static void *invalid_import_from_targets_rule(Parser *p);
840 static void *invalid_with_stmt_rule(Parser *p);
841 static void *invalid_with_stmt_indent_rule(Parser *p);
842 static void *invalid_try_stmt_rule(Parser *p);
843 static void *invalid_except_stmt_rule(Parser *p);
844 static void *invalid_finally_stmt_rule(Parser *p);
845 static void *invalid_except_stmt_indent_rule(Parser *p);
846 static void *invalid_except_star_stmt_indent_rule(Parser *p);
847 static void *invalid_match_stmt_rule(Parser *p);
848 static void *invalid_case_block_rule(Parser *p);
849 static void *invalid_as_pattern_rule(Parser *p);
850 static void *invalid_class_pattern_rule(Parser *p);
851 static asdl_pattern_seq* invalid_class_argument_pattern_rule(Parser *p);
852 static void *invalid_if_stmt_rule(Parser *p);
853 static void *invalid_elif_stmt_rule(Parser *p);
854 static void *invalid_else_stmt_rule(Parser *p);
855 static void *invalid_while_stmt_rule(Parser *p);
856 static void *invalid_for_stmt_rule(Parser *p);
857 static void *invalid_def_raw_rule(Parser *p);
858 static void *invalid_class_def_raw_rule(Parser *p);
859 static void *invalid_double_starred_kvpairs_rule(Parser *p);
860 static void *invalid_kvpair_rule(Parser *p);
861 static void *invalid_starred_expression_rule(Parser *p);
862 static void *invalid_replacement_field_rule(Parser *p);
863 static void *invalid_conversion_character_rule(Parser *p);
864 static void *invalid_arithmetic_rule(Parser *p);
865 static void *invalid_factor_rule(Parser *p);
866 static void *invalid_type_params_rule(Parser *p);
867 static asdl_seq *_loop0_1_rule(Parser *p);
868 static asdl_seq *_loop0_2_rule(Parser *p);
869 static asdl_seq *_loop1_3_rule(Parser *p);
870 static asdl_seq *_loop0_5_rule(Parser *p);
871 static asdl_seq *_gather_4_rule(Parser *p);
872 static void *_tmp_6_rule(Parser *p);
873 static void *_tmp_7_rule(Parser *p);
874 static void *_tmp_8_rule(Parser *p);
875 static void *_tmp_9_rule(Parser *p);
876 static void *_tmp_10_rule(Parser *p);
877 static void *_tmp_11_rule(Parser *p);
878 static void *_tmp_12_rule(Parser *p);
879 static void *_tmp_13_rule(Parser *p);
880 static asdl_seq *_loop1_14_rule(Parser *p);
881 static void *_tmp_15_rule(Parser *p);
882 static void *_tmp_16_rule(Parser *p);
883 static void *_tmp_17_rule(Parser *p);
884 static asdl_seq *_loop0_19_rule(Parser *p);
885 static asdl_seq *_gather_18_rule(Parser *p);
886 static asdl_seq *_loop0_21_rule(Parser *p);
887 static asdl_seq *_gather_20_rule(Parser *p);
888 static void *_tmp_22_rule(Parser *p);
889 static void *_tmp_23_rule(Parser *p);
890 static asdl_seq *_loop0_24_rule(Parser *p);
891 static asdl_seq *_loop1_25_rule(Parser *p);
892 static asdl_seq *_loop0_27_rule(Parser *p);
893 static asdl_seq *_gather_26_rule(Parser *p);
894 static void *_tmp_28_rule(Parser *p);
895 static asdl_seq *_loop0_30_rule(Parser *p);
896 static asdl_seq *_gather_29_rule(Parser *p);
897 static void *_tmp_31_rule(Parser *p);
898 static asdl_seq *_loop1_32_rule(Parser *p);
899 static void *_tmp_33_rule(Parser *p);
900 static void *_tmp_34_rule(Parser *p);
901 static void *_tmp_35_rule(Parser *p);
902 static asdl_seq *_loop0_36_rule(Parser *p);
903 static asdl_seq *_loop0_37_rule(Parser *p);
904 static asdl_seq *_loop0_38_rule(Parser *p);
905 static asdl_seq *_loop1_39_rule(Parser *p);
906 static asdl_seq *_loop0_40_rule(Parser *p);
907 static asdl_seq *_loop1_41_rule(Parser *p);
908 static asdl_seq *_loop1_42_rule(Parser *p);
909 static asdl_seq *_loop1_43_rule(Parser *p);
910 static asdl_seq *_loop0_44_rule(Parser *p);
911 static asdl_seq *_loop1_45_rule(Parser *p);
912 static asdl_seq *_loop0_46_rule(Parser *p);
913 static asdl_seq *_loop1_47_rule(Parser *p);
914 static asdl_seq *_loop0_48_rule(Parser *p);
915 static asdl_seq *_loop0_49_rule(Parser *p);
916 static asdl_seq *_loop1_50_rule(Parser *p);
917 static asdl_seq *_loop0_52_rule(Parser *p);
918 static asdl_seq *_gather_51_rule(Parser *p);
919 static asdl_seq *_loop0_54_rule(Parser *p);
920 static asdl_seq *_gather_53_rule(Parser *p);
921 static asdl_seq *_loop0_56_rule(Parser *p);
922 static asdl_seq *_gather_55_rule(Parser *p);
923 static asdl_seq *_loop0_58_rule(Parser *p);
924 static asdl_seq *_gather_57_rule(Parser *p);
925 static void *_tmp_59_rule(Parser *p);
926 static asdl_seq *_loop1_60_rule(Parser *p);
927 static asdl_seq *_loop1_61_rule(Parser *p);
928 static void *_tmp_62_rule(Parser *p);
929 static void *_tmp_63_rule(Parser *p);
930 static asdl_seq *_loop1_64_rule(Parser *p);
931 static asdl_seq *_loop0_66_rule(Parser *p);
932 static asdl_seq *_gather_65_rule(Parser *p);
933 static void *_tmp_67_rule(Parser *p);
934 static void *_tmp_68_rule(Parser *p);
935 static void *_tmp_69_rule(Parser *p);
936 static void *_tmp_70_rule(Parser *p);
937 static asdl_seq *_loop0_72_rule(Parser *p);
938 static asdl_seq *_gather_71_rule(Parser *p);
939 static asdl_seq *_loop0_74_rule(Parser *p);
940 static asdl_seq *_gather_73_rule(Parser *p);
941 static void *_tmp_75_rule(Parser *p);
942 static asdl_seq *_loop0_77_rule(Parser *p);
943 static asdl_seq *_gather_76_rule(Parser *p);
944 static asdl_seq *_loop0_79_rule(Parser *p);
945 static asdl_seq *_gather_78_rule(Parser *p);
946 static asdl_seq *_loop0_81_rule(Parser *p);
947 static asdl_seq *_gather_80_rule(Parser *p);
948 static asdl_seq *_loop1_82_rule(Parser *p);
949 static asdl_seq *_loop1_83_rule(Parser *p);
950 static asdl_seq *_loop0_85_rule(Parser *p);
951 static asdl_seq *_gather_84_rule(Parser *p);
952 static asdl_seq *_loop1_86_rule(Parser *p);
953 static asdl_seq *_loop1_87_rule(Parser *p);
954 static asdl_seq *_loop1_88_rule(Parser *p);
955 static void *_tmp_89_rule(Parser *p);
956 static asdl_seq *_loop0_91_rule(Parser *p);
957 static asdl_seq *_gather_90_rule(Parser *p);
958 static void *_tmp_92_rule(Parser *p);
959 static void *_tmp_93_rule(Parser *p);
960 static void *_tmp_94_rule(Parser *p);
961 static void *_tmp_95_rule(Parser *p);
962 static void *_tmp_96_rule(Parser *p);
963 static void *_tmp_97_rule(Parser *p);
964 static asdl_seq *_loop0_98_rule(Parser *p);
965 static asdl_seq *_loop0_99_rule(Parser *p);
966 static asdl_seq *_loop0_100_rule(Parser *p);
967 static asdl_seq *_loop1_101_rule(Parser *p);
968 static asdl_seq *_loop0_102_rule(Parser *p);
969 static asdl_seq *_loop1_103_rule(Parser *p);
970 static asdl_seq *_loop1_104_rule(Parser *p);
971 static asdl_seq *_loop1_105_rule(Parser *p);
972 static asdl_seq *_loop0_106_rule(Parser *p);
973 static asdl_seq *_loop1_107_rule(Parser *p);
974 static asdl_seq *_loop0_108_rule(Parser *p);
975 static asdl_seq *_loop1_109_rule(Parser *p);
976 static asdl_seq *_loop0_110_rule(Parser *p);
977 static asdl_seq *_loop1_111_rule(Parser *p);
978 static asdl_seq *_loop0_112_rule(Parser *p);
979 static asdl_seq *_loop0_113_rule(Parser *p);
980 static asdl_seq *_loop1_114_rule(Parser *p);
981 static void *_tmp_115_rule(Parser *p);
982 static asdl_seq *_loop0_117_rule(Parser *p);
983 static asdl_seq *_gather_116_rule(Parser *p);
984 static asdl_seq *_loop1_118_rule(Parser *p);
985 static asdl_seq *_loop0_119_rule(Parser *p);
986 static asdl_seq *_loop0_120_rule(Parser *p);
987 static void *_tmp_121_rule(Parser *p);
988 static void *_tmp_122_rule(Parser *p);
989 static asdl_seq *_loop0_124_rule(Parser *p);
990 static asdl_seq *_gather_123_rule(Parser *p);
991 static void *_tmp_125_rule(Parser *p);
992 static asdl_seq *_loop0_127_rule(Parser *p);
993 static asdl_seq *_gather_126_rule(Parser *p);
994 static asdl_seq *_loop0_129_rule(Parser *p);
995 static asdl_seq *_gather_128_rule(Parser *p);
996 static asdl_seq *_loop0_131_rule(Parser *p);
997 static asdl_seq *_gather_130_rule(Parser *p);
998 static asdl_seq *_loop0_133_rule(Parser *p);
999 static asdl_seq *_gather_132_rule(Parser *p);
1000 static asdl_seq *_loop0_134_rule(Parser *p);
1001 static asdl_seq *_loop0_136_rule(Parser *p);
1002 static asdl_seq *_gather_135_rule(Parser *p);
1003 static asdl_seq *_loop1_137_rule(Parser *p);
1004 static void *_tmp_138_rule(Parser *p);
1005 static asdl_seq *_loop0_140_rule(Parser *p);
1006 static asdl_seq *_gather_139_rule(Parser *p);
1007 static asdl_seq *_loop0_142_rule(Parser *p);
1008 static asdl_seq *_gather_141_rule(Parser *p);
1009 static asdl_seq *_loop0_144_rule(Parser *p);
1010 static asdl_seq *_gather_143_rule(Parser *p);
1011 static asdl_seq *_loop0_146_rule(Parser *p);
1012 static asdl_seq *_gather_145_rule(Parser *p);
1013 static asdl_seq *_loop0_148_rule(Parser *p);
1014 static asdl_seq *_gather_147_rule(Parser *p);
1015 static void *_tmp_149_rule(Parser *p);
1016 static void *_tmp_150_rule(Parser *p);
1017 static asdl_seq *_loop0_152_rule(Parser *p);
1018 static asdl_seq *_gather_151_rule(Parser *p);
1019 static void *_tmp_153_rule(Parser *p);
1020 static void *_tmp_154_rule(Parser *p);
1021 static void *_tmp_155_rule(Parser *p);
1022 static void *_tmp_156_rule(Parser *p);
1023 static void *_tmp_157_rule(Parser *p);
1024 static void *_tmp_158_rule(Parser *p);
1025 static void *_tmp_159_rule(Parser *p);
1026 static void *_tmp_160_rule(Parser *p);
1027 static void *_tmp_161_rule(Parser *p);
1028 static void *_tmp_162_rule(Parser *p);
1029 static asdl_seq *_loop0_163_rule(Parser *p);
1030 static asdl_seq *_loop0_164_rule(Parser *p);
1031 static asdl_seq *_loop0_165_rule(Parser *p);
1032 static void *_tmp_166_rule(Parser *p);
1033 static void *_tmp_167_rule(Parser *p);
1034 static void *_tmp_168_rule(Parser *p);
1035 static void *_tmp_169_rule(Parser *p);
1036 static asdl_seq *_loop0_170_rule(Parser *p);
1037 static asdl_seq *_loop0_171_rule(Parser *p);
1038 static asdl_seq *_loop0_172_rule(Parser *p);
1039 static asdl_seq *_loop1_173_rule(Parser *p);
1040 static void *_tmp_174_rule(Parser *p);
1041 static asdl_seq *_loop0_175_rule(Parser *p);
1042 static void *_tmp_176_rule(Parser *p);
1043 static asdl_seq *_loop0_177_rule(Parser *p);
1044 static asdl_seq *_loop1_178_rule(Parser *p);
1045 static void *_tmp_179_rule(Parser *p);
1046 static void *_tmp_180_rule(Parser *p);
1047 static void *_tmp_181_rule(Parser *p);
1048 static asdl_seq *_loop0_182_rule(Parser *p);
1049 static void *_tmp_183_rule(Parser *p);
1050 static void *_tmp_184_rule(Parser *p);
1051 static asdl_seq *_loop1_185_rule(Parser *p);
1052 static void *_tmp_186_rule(Parser *p);
1053 static asdl_seq *_loop0_187_rule(Parser *p);
1054 static asdl_seq *_loop0_188_rule(Parser *p);
1055 static asdl_seq *_loop0_189_rule(Parser *p);
1056 static asdl_seq *_loop0_191_rule(Parser *p);
1057 static asdl_seq *_gather_190_rule(Parser *p);
1058 static void *_tmp_192_rule(Parser *p);
1059 static asdl_seq *_loop0_193_rule(Parser *p);
1060 static void *_tmp_194_rule(Parser *p);
1061 static asdl_seq *_loop0_195_rule(Parser *p);
1062 static asdl_seq *_loop1_196_rule(Parser *p);
1063 static asdl_seq *_loop1_197_rule(Parser *p);
1064 static void *_tmp_198_rule(Parser *p);
1065 static void *_tmp_199_rule(Parser *p);
1066 static asdl_seq *_loop0_200_rule(Parser *p);
1067 static void *_tmp_201_rule(Parser *p);
1068 static void *_tmp_202_rule(Parser *p);
1069 static void *_tmp_203_rule(Parser *p);
1070 static asdl_seq *_loop0_205_rule(Parser *p);
1071 static asdl_seq *_gather_204_rule(Parser *p);
1072 static asdl_seq *_loop0_207_rule(Parser *p);
1073 static asdl_seq *_gather_206_rule(Parser *p);
1074 static asdl_seq *_loop0_209_rule(Parser *p);
1075 static asdl_seq *_gather_208_rule(Parser *p);
1076 static asdl_seq *_loop0_211_rule(Parser *p);
1077 static asdl_seq *_gather_210_rule(Parser *p);
1078 static asdl_seq *_loop0_213_rule(Parser *p);
1079 static asdl_seq *_gather_212_rule(Parser *p);
1080 static void *_tmp_214_rule(Parser *p);
1081 static asdl_seq *_loop0_215_rule(Parser *p);
1082 static asdl_seq *_loop1_216_rule(Parser *p);
1083 static void *_tmp_217_rule(Parser *p);
1084 static asdl_seq *_loop0_218_rule(Parser *p);
1085 static asdl_seq *_loop1_219_rule(Parser *p);
1086 static void *_tmp_220_rule(Parser *p);
1087 static void *_tmp_221_rule(Parser *p);
1088 static void *_tmp_222_rule(Parser *p);
1089 static void *_tmp_223_rule(Parser *p);
1090 static void *_tmp_224_rule(Parser *p);
1091 static void *_tmp_225_rule(Parser *p);
1092 static void *_tmp_226_rule(Parser *p);
1093 static void *_tmp_227_rule(Parser *p);
1094 static void *_tmp_228_rule(Parser *p);
1095 static void *_tmp_229_rule(Parser *p);
1096 static void *_tmp_230_rule(Parser *p);
1097 static asdl_seq *_loop0_232_rule(Parser *p);
1098 static asdl_seq *_gather_231_rule(Parser *p);
1099 static void *_tmp_233_rule(Parser *p);
1100 static void *_tmp_234_rule(Parser *p);
1101 static void *_tmp_235_rule(Parser *p);
1102 static void *_tmp_236_rule(Parser *p);
1103 static void *_tmp_237_rule(Parser *p);
1104 static void *_tmp_238_rule(Parser *p);
1105 static void *_tmp_239_rule(Parser *p);
1106 static asdl_seq *_loop0_240_rule(Parser *p);
1107 static void *_tmp_241_rule(Parser *p);
1108 static void *_tmp_242_rule(Parser *p);
1109 static void *_tmp_243_rule(Parser *p);
1110 static void *_tmp_244_rule(Parser *p);
1111 static void *_tmp_245_rule(Parser *p);
1112 static void *_tmp_246_rule(Parser *p);
1113 static void *_tmp_247_rule(Parser *p);
1114 static void *_tmp_248_rule(Parser *p);
1115 static void *_tmp_249_rule(Parser *p);
1116 static void *_tmp_250_rule(Parser *p);
1117 static void *_tmp_251_rule(Parser *p);
1118 static void *_tmp_252_rule(Parser *p);
1119 static void *_tmp_253_rule(Parser *p);
1120 static void *_tmp_254_rule(Parser *p);
1121 static void *_tmp_255_rule(Parser *p);
1122 static void *_tmp_256_rule(Parser *p);
1123 static asdl_seq *_loop0_257_rule(Parser *p);
1124 static void *_tmp_258_rule(Parser *p);
1125 static void *_tmp_259_rule(Parser *p);
1126 static void *_tmp_260_rule(Parser *p);
1127 static void *_tmp_261_rule(Parser *p);
1128 static void *_tmp_262_rule(Parser *p);
1129 static void *_tmp_263_rule(Parser *p);
1130 static void *_tmp_264_rule(Parser *p);
1131 static void *_tmp_265_rule(Parser *p);
1132 static void *_tmp_266_rule(Parser *p);
1133 static void *_tmp_267_rule(Parser *p);
1134 static void *_tmp_268_rule(Parser *p);
1135 static void *_tmp_269_rule(Parser *p);
1136 static void *_tmp_270_rule(Parser *p);
1137 static void *_tmp_271_rule(Parser *p);
1138 static void *_tmp_272_rule(Parser *p);
1139 static void *_tmp_273_rule(Parser *p);
1140 static asdl_seq *_loop0_275_rule(Parser *p);
1141 static asdl_seq *_gather_274_rule(Parser *p);
1142 static void *_tmp_276_rule(Parser *p);
1143 static void *_tmp_277_rule(Parser *p);
1144 static void *_tmp_278_rule(Parser *p);
1145 static void *_tmp_279_rule(Parser *p);
1146 static void *_tmp_280_rule(Parser *p);
1147 static void *_tmp_281_rule(Parser *p);
1148
1149
1150 // file: statements? $
1151 static mod_ty
1152 file_rule(Parser *p)
1153 {
1154 if (p->level++ == MAXSTACK) {
1155 _Pypegen_stack_overflow(p);
1156 }
1157 if (p->error_indicator) {
1158 p->level--;
1159 return NULL;
1160 }
1161 mod_ty _res = NULL;
1162 int _mark = p->mark;
1163 { // statements? $
1164 if (p->error_indicator) {
1165 p->level--;
1166 return NULL;
1167 }
1168 D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $"));
1169 void *a;
1170 Token * endmarker_var;
1171 if (
1172 (a = statements_rule(p), !p->error_indicator) // statements?
1173 &&
1174 (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1175 )
1176 {
1177 D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements? $"));
1178 _res = _PyPegen_make_module ( p , a );
1179 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1180 p->error_indicator = 1;
1181 p->level--;
1182 return NULL;
1183 }
1184 goto done;
1185 }
1186 p->mark = _mark;
1187 D(fprintf(stderr, "%*c%s file[%d-%d]: %s failed!\n", p->level, ' ',
1188 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statements? $"));
1189 }
1190 _res = NULL;
1191 done:
1192 p->level--;
1193 return _res;
1194 }
1195
1196 // interactive: statement_newline
1197 static mod_ty
1198 interactive_rule(Parser *p)
1199 {
1200 if (p->level++ == MAXSTACK) {
1201 _Pypegen_stack_overflow(p);
1202 }
1203 if (p->error_indicator) {
1204 p->level--;
1205 return NULL;
1206 }
1207 mod_ty _res = NULL;
1208 int _mark = p->mark;
1209 { // statement_newline
1210 if (p->error_indicator) {
1211 p->level--;
1212 return NULL;
1213 }
1214 D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newline"));
1215 asdl_stmt_seq* a;
1216 if (
1217 (a = statement_newline_rule(p)) // statement_newline
1218 )
1219 {
1220 D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement_newline"));
1221 _res = _PyAST_Interactive ( a , p -> arena );
1222 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1223 p->error_indicator = 1;
1224 p->level--;
1225 return NULL;
1226 }
1227 goto done;
1228 }
1229 p->mark = _mark;
1230 D(fprintf(stderr, "%*c%s interactive[%d-%d]: %s failed!\n", p->level, ' ',
1231 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement_newline"));
1232 }
1233 _res = NULL;
1234 done:
1235 p->level--;
1236 return _res;
1237 }
1238
1239 // eval: expressions NEWLINE* $
1240 static mod_ty
1241 eval_rule(Parser *p)
1242 {
1243 if (p->level++ == MAXSTACK) {
1244 _Pypegen_stack_overflow(p);
1245 }
1246 if (p->error_indicator) {
1247 p->level--;
1248 return NULL;
1249 }
1250 mod_ty _res = NULL;
1251 int _mark = p->mark;
1252 { // expressions NEWLINE* $
1253 if (p->error_indicator) {
1254 p->level--;
1255 return NULL;
1256 }
1257 D(fprintf(stderr, "%*c> eval[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));
1258 asdl_seq * _loop0_1_var;
1259 expr_ty a;
1260 Token * endmarker_var;
1261 if (
1262 (a = expressions_rule(p)) // expressions
1263 &&
1264 (_loop0_1_var = _loop0_1_rule(p)) // NEWLINE*
1265 &&
1266 (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1267 )
1268 {
1269 D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));
1270 _res = _PyAST_Expression ( a , p -> arena );
1271 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1272 p->error_indicator = 1;
1273 p->level--;
1274 return NULL;
1275 }
1276 goto done;
1277 }
1278 p->mark = _mark;
1279 D(fprintf(stderr, "%*c%s eval[%d-%d]: %s failed!\n", p->level, ' ',
1280 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions NEWLINE* $"));
1281 }
1282 _res = NULL;
1283 done:
1284 p->level--;
1285 return _res;
1286 }
1287
1288 // func_type: '(' type_expressions? ')' '->' expression NEWLINE* $
1289 static mod_ty
1290 func_type_rule(Parser *p)
1291 {
1292 if (p->level++ == MAXSTACK) {
1293 _Pypegen_stack_overflow(p);
1294 }
1295 if (p->error_indicator) {
1296 p->level--;
1297 return NULL;
1298 }
1299 mod_ty _res = NULL;
1300 int _mark = p->mark;
1301 { // '(' type_expressions? ')' '->' expression NEWLINE* $
1302 if (p->error_indicator) {
1303 p->level--;
1304 return NULL;
1305 }
1306 D(fprintf(stderr, "%*c> func_type[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $"));
1307 Token * _literal;
1308 Token * _literal_1;
1309 Token * _literal_2;
1310 asdl_seq * _loop0_2_var;
1311 void *a;
1312 expr_ty b;
1313 Token * endmarker_var;
1314 if (
1315 (_literal = _PyPegen_expect_token(p, 7)) // token='('
1316 &&
1317 (a = type_expressions_rule(p), !p->error_indicator) // type_expressions?
1318 &&
1319 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
1320 &&
1321 (_literal_2 = _PyPegen_expect_token(p, 51)) // token='->'
1322 &&
1323 (b = expression_rule(p)) // expression
1324 &&
1325 (_loop0_2_var = _loop0_2_rule(p)) // NEWLINE*
1326 &&
1327 (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1328 )
1329 {
1330 D(fprintf(stderr, "%*c+ func_type[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $"));
1331 _res = _PyAST_FunctionType ( a , b , p -> arena );
1332 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1333 p->error_indicator = 1;
1334 p->level--;
1335 return NULL;
1336 }
1337 goto done;
1338 }
1339 p->mark = _mark;
1340 D(fprintf(stderr, "%*c%s func_type[%d-%d]: %s failed!\n", p->level, ' ',
1341 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $"));
1342 }
1343 _res = NULL;
1344 done:
1345 p->level--;
1346 return _res;
1347 }
1348
1349 // statements: statement+
1350 static asdl_stmt_seq*
1351 statements_rule(Parser *p)
1352 {
1353 if (p->level++ == MAXSTACK) {
1354 _Pypegen_stack_overflow(p);
1355 }
1356 if (p->error_indicator) {
1357 p->level--;
1358 return NULL;
1359 }
1360 asdl_stmt_seq* _res = NULL;
1361 int _mark = p->mark;
1362 { // statement+
1363 if (p->error_indicator) {
1364 p->level--;
1365 return NULL;
1366 }
1367 D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+"));
1368 asdl_seq * a;
1369 if (
1370 (a = _loop1_3_rule(p)) // statement+
1371 )
1372 {
1373 D(fprintf(stderr, "%*c+ statements[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement+"));
1374 _res = ( asdl_stmt_seq* ) _PyPegen_seq_flatten ( p , a );
1375 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1376 p->error_indicator = 1;
1377 p->level--;
1378 return NULL;
1379 }
1380 goto done;
1381 }
1382 p->mark = _mark;
1383 D(fprintf(stderr, "%*c%s statements[%d-%d]: %s failed!\n", p->level, ' ',
1384 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement+"));
1385 }
1386 _res = NULL;
1387 done:
1388 p->level--;
1389 return _res;
1390 }
1391
1392 // statement: compound_stmt | simple_stmts
1393 static asdl_stmt_seq*
1394 statement_rule(Parser *p)
1395 {
1396 if (p->level++ == MAXSTACK) {
1397 _Pypegen_stack_overflow(p);
1398 }
1399 if (p->error_indicator) {
1400 p->level--;
1401 return NULL;
1402 }
1403 asdl_stmt_seq* _res = NULL;
1404 int _mark = p->mark;
1405 { // compound_stmt
1406 if (p->error_indicator) {
1407 p->level--;
1408 return NULL;
1409 }
1410 D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt"));
1411 stmt_ty a;
1412 if (
1413 (a = compound_stmt_rule(p)) // compound_stmt
1414 )
1415 {
1416 D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt"));
1417 _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a );
1418 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1419 p->error_indicator = 1;
1420 p->level--;
1421 return NULL;
1422 }
1423 goto done;
1424 }
1425 p->mark = _mark;
1426 D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ',
1427 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt"));
1428 }
1429 { // simple_stmts
1430 if (p->error_indicator) {
1431 p->level--;
1432 return NULL;
1433 }
1434 D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1435 asdl_stmt_seq* a;
1436 if (
1437 (a = (asdl_stmt_seq*)simple_stmts_rule(p)) // simple_stmts
1438 )
1439 {
1440 D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1441 _res = a;
1442 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1443 p->error_indicator = 1;
1444 p->level--;
1445 return NULL;
1446 }
1447 goto done;
1448 }
1449 p->mark = _mark;
1450 D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ',
1451 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts"));
1452 }
1453 _res = NULL;
1454 done:
1455 p->level--;
1456 return _res;
1457 }
1458
1459 // statement_newline: compound_stmt NEWLINE | simple_stmts | NEWLINE | $
1460 static asdl_stmt_seq*
1461 statement_newline_rule(Parser *p)
1462 {
1463 if (p->level++ == MAXSTACK) {
1464 _Pypegen_stack_overflow(p);
1465 }
1466 if (p->error_indicator) {
1467 p->level--;
1468 return NULL;
1469 }
1470 asdl_stmt_seq* _res = NULL;
1471 int _mark = p->mark;
1472 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
1473 p->error_indicator = 1;
1474 p->level--;
1475 return NULL;
1476 }
1477 int _start_lineno = p->tokens[_mark]->lineno;
1478 UNUSED(_start_lineno); // Only used by EXTRA macro
1479 int _start_col_offset = p->tokens[_mark]->col_offset;
1480 UNUSED(_start_col_offset); // Only used by EXTRA macro
1481 { // compound_stmt NEWLINE
1482 if (p->error_indicator) {
1483 p->level--;
1484 return NULL;
1485 }
1486 D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE"));
1487 stmt_ty a;
1488 Token * newline_var;
1489 if (
1490 (a = compound_stmt_rule(p)) // compound_stmt
1491 &&
1492 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1493 )
1494 {
1495 D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE"));
1496 _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a );
1497 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1498 p->error_indicator = 1;
1499 p->level--;
1500 return NULL;
1501 }
1502 goto done;
1503 }
1504 p->mark = _mark;
1505 D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
1506 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt NEWLINE"));
1507 }
1508 { // simple_stmts
1509 if (p->error_indicator) {
1510 p->level--;
1511 return NULL;
1512 }
1513 D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1514 asdl_stmt_seq* simple_stmts_var;
1515 if (
1516 (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts
1517 )
1518 {
1519 D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
1520 _res = simple_stmts_var;
1521 goto done;
1522 }
1523 p->mark = _mark;
1524 D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
1525 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts"));
1526 }
1527 { // NEWLINE
1528 if (p->error_indicator) {
1529 p->level--;
1530 return NULL;
1531 }
1532 D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
1533 Token * newline_var;
1534 if (
1535 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1536 )
1537 {
1538 D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
1539 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1540 if (_token == NULL) {
1541 p->level--;
1542 return NULL;
1543 }
1544 int _end_lineno = _token->end_lineno;
1545 UNUSED(_end_lineno); // Only used by EXTRA macro
1546 int _end_col_offset = _token->end_col_offset;
1547 UNUSED(_end_col_offset); // Only used by EXTRA macro
1548 _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , CHECK ( stmt_ty , _PyAST_Pass ( EXTRA ) ) );
1549 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1550 p->error_indicator = 1;
1551 p->level--;
1552 return NULL;
1553 }
1554 goto done;
1555 }
1556 p->mark = _mark;
1557 D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
1558 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
1559 }
1560 { // $
1561 if (p->error_indicator) {
1562 p->level--;
1563 return NULL;
1564 }
1565 D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "$"));
1566 Token * endmarker_var;
1567 if (
1568 (endmarker_var = _PyPegen_expect_token(p, ENDMARKER)) // token='ENDMARKER'
1569 )
1570 {
1571 D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "$"));
1572 _res = _PyPegen_interactive_exit ( p );
1573 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1574 p->error_indicator = 1;
1575 p->level--;
1576 return NULL;
1577 }
1578 goto done;
1579 }
1580 p->mark = _mark;
1581 D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
1582 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "$"));
1583 }
1584 _res = NULL;
1585 done:
1586 p->level--;
1587 return _res;
1588 }
1589
1590 // simple_stmts: simple_stmt !';' NEWLINE | ';'.simple_stmt+ ';'? NEWLINE
1591 static asdl_stmt_seq*
1592 simple_stmts_rule(Parser *p)
1593 {
1594 if (p->level++ == MAXSTACK) {
1595 _Pypegen_stack_overflow(p);
1596 }
1597 if (p->error_indicator) {
1598 p->level--;
1599 return NULL;
1600 }
1601 asdl_stmt_seq* _res = NULL;
1602 int _mark = p->mark;
1603 { // simple_stmt !';' NEWLINE
1604 if (p->error_indicator) {
1605 p->level--;
1606 return NULL;
1607 }
1608 D(fprintf(stderr, "%*c> simple_stmts[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt !';' NEWLINE"));
1609 stmt_ty a;
1610 Token * newline_var;
1611 if (
1612 (a = simple_stmt_rule(p)) // simple_stmt
1613 &&
1614 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13) // token=';'
1615 &&
1616 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1617 )
1618 {
1619 D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt !';' NEWLINE"));
1620 _res = ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a );
1621 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1622 p->error_indicator = 1;
1623 p->level--;
1624 return NULL;
1625 }
1626 goto done;
1627 }
1628 p->mark = _mark;
1629 D(fprintf(stderr, "%*c%s simple_stmts[%d-%d]: %s failed!\n", p->level, ' ',
1630 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt !';' NEWLINE"));
1631 }
1632 { // ';'.simple_stmt+ ';'? NEWLINE
1633 if (p->error_indicator) {
1634 p->level--;
1635 return NULL;
1636 }
1637 D(fprintf(stderr, "%*c> simple_stmts[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE"));
1638 void *_opt_var;
1639 UNUSED(_opt_var); // Silence compiler warnings
1640 asdl_stmt_seq* a;
1641 Token * newline_var;
1642 if (
1643 (a = (asdl_stmt_seq*)_gather_4_rule(p)) // ';'.simple_stmt+
1644 &&
1645 (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator) // ';'?
1646 &&
1647 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
1648 )
1649 {
1650 D(fprintf(stderr, "%*c+ simple_stmts[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE"));
1651 _res = a;
1652 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1653 p->error_indicator = 1;
1654 p->level--;
1655 return NULL;
1656 }
1657 goto done;
1658 }
1659 p->mark = _mark;
1660 D(fprintf(stderr, "%*c%s simple_stmts[%d-%d]: %s failed!\n", p->level, ' ',
1661 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'.simple_stmt+ ';'? NEWLINE"));
1662 }
1663 _res = NULL;
1664 done:
1665 p->level--;
1666 return _res;
1667 }
1668
1669 // simple_stmt:
1670 // | assignment
1671 // | &"type" type_alias
1672 // | star_expressions
1673 // | &'return' return_stmt
1674 // | &('import' | 'from') import_stmt
1675 // | &'raise' raise_stmt
1676 // | 'pass'
1677 // | &'del' del_stmt
1678 // | &'yield' yield_stmt
1679 // | &'assert' assert_stmt
1680 // | 'break'
1681 // | 'continue'
1682 // | &'global' global_stmt
1683 // | &'nonlocal' nonlocal_stmt
1684 static stmt_ty
1685 simple_stmt_rule(Parser *p)
1686 {
1687 if (p->level++ == MAXSTACK) {
1688 _Pypegen_stack_overflow(p);
1689 }
1690 if (p->error_indicator) {
1691 p->level--;
1692 return NULL;
1693 }
1694 stmt_ty _res = NULL;
1695 if (_PyPegen_is_memoized(p, simple_stmt_type, &_res)) {
1696 p->level--;
1697 return _res;
1698 }
1699 int _mark = p->mark;
1700 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
1701 p->error_indicator = 1;
1702 p->level--;
1703 return NULL;
1704 }
1705 int _start_lineno = p->tokens[_mark]->lineno;
1706 UNUSED(_start_lineno); // Only used by EXTRA macro
1707 int _start_col_offset = p->tokens[_mark]->col_offset;
1708 UNUSED(_start_col_offset); // Only used by EXTRA macro
1709 { // assignment
1710 if (p->error_indicator) {
1711 p->level--;
1712 return NULL;
1713 }
1714 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment"));
1715 stmt_ty assignment_var;
1716 if (
1717 (assignment_var = assignment_rule(p)) // assignment
1718 )
1719 {
1720 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment"));
1721 _res = assignment_var;
1722 goto done;
1723 }
1724 p->mark = _mark;
1725 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1726 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment"));
1727 }
1728 { // &"type" type_alias
1729 if (p->error_indicator) {
1730 p->level--;
1731 return NULL;
1732 }
1733 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&\"type\" type_alias"));
1734 stmt_ty type_alias_var;
1735 if (
1736 _PyPegen_lookahead_with_string(1, _PyPegen_expect_soft_keyword, p, "type")
1737 &&
1738 (type_alias_var = type_alias_rule(p)) // type_alias
1739 )
1740 {
1741 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&\"type\" type_alias"));
1742 _res = type_alias_var;
1743 goto done;
1744 }
1745 p->mark = _mark;
1746 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1747 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&\"type\" type_alias"));
1748 }
1749 { // star_expressions
1750 if (p->error_indicator) {
1751 p->level--;
1752 return NULL;
1753 }
1754 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
1755 expr_ty e;
1756 if (
1757 (e = star_expressions_rule(p)) // star_expressions
1758 )
1759 {
1760 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
1761 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1762 if (_token == NULL) {
1763 p->level--;
1764 return NULL;
1765 }
1766 int _end_lineno = _token->end_lineno;
1767 UNUSED(_end_lineno); // Only used by EXTRA macro
1768 int _end_col_offset = _token->end_col_offset;
1769 UNUSED(_end_col_offset); // Only used by EXTRA macro
1770 _res = _PyAST_Expr ( e , EXTRA );
1771 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1772 p->error_indicator = 1;
1773 p->level--;
1774 return NULL;
1775 }
1776 goto done;
1777 }
1778 p->mark = _mark;
1779 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1780 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
1781 }
1782 { // &'return' return_stmt
1783 if (p->error_indicator) {
1784 p->level--;
1785 return NULL;
1786 }
1787 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt"));
1788 stmt_ty return_stmt_var;
1789 if (
1790 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 522) // token='return'
1791 &&
1792 (return_stmt_var = return_stmt_rule(p)) // return_stmt
1793 )
1794 {
1795 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt"));
1796 _res = return_stmt_var;
1797 goto done;
1798 }
1799 p->mark = _mark;
1800 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1801 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'return' return_stmt"));
1802 }
1803 { // &('import' | 'from') import_stmt
1804 if (p->error_indicator) {
1805 p->level--;
1806 return NULL;
1807 }
1808 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt"));
1809 stmt_ty import_stmt_var;
1810 if (
1811 _PyPegen_lookahead(1, _tmp_6_rule, p)
1812 &&
1813 (import_stmt_var = import_stmt_rule(p)) // import_stmt
1814 )
1815 {
1816 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt"));
1817 _res = import_stmt_var;
1818 goto done;
1819 }
1820 p->mark = _mark;
1821 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1822 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('import' | 'from') import_stmt"));
1823 }
1824 { // &'raise' raise_stmt
1825 if (p->error_indicator) {
1826 p->level--;
1827 return NULL;
1828 }
1829 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt"));
1830 stmt_ty raise_stmt_var;
1831 if (
1832 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 525) // token='raise'
1833 &&
1834 (raise_stmt_var = raise_stmt_rule(p)) // raise_stmt
1835 )
1836 {
1837 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt"));
1838 _res = raise_stmt_var;
1839 goto done;
1840 }
1841 p->mark = _mark;
1842 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1843 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'raise' raise_stmt"));
1844 }
1845 { // 'pass'
1846 if (p->error_indicator) {
1847 p->level--;
1848 return NULL;
1849 }
1850 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'"));
1851 Token * _keyword;
1852 if (
1853 (_keyword = _PyPegen_expect_token(p, 504)) // token='pass'
1854 )
1855 {
1856 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pass'"));
1857 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1858 if (_token == NULL) {
1859 p->level--;
1860 return NULL;
1861 }
1862 int _end_lineno = _token->end_lineno;
1863 UNUSED(_end_lineno); // Only used by EXTRA macro
1864 int _end_col_offset = _token->end_col_offset;
1865 UNUSED(_end_col_offset); // Only used by EXTRA macro
1866 _res = _PyAST_Pass ( EXTRA );
1867 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1868 p->error_indicator = 1;
1869 p->level--;
1870 return NULL;
1871 }
1872 goto done;
1873 }
1874 p->mark = _mark;
1875 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1876 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'pass'"));
1877 }
1878 { // &'del' del_stmt
1879 if (p->error_indicator) {
1880 p->level--;
1881 return NULL;
1882 }
1883 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt"));
1884 stmt_ty del_stmt_var;
1885 if (
1886 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 616) // token='del'
1887 &&
1888 (del_stmt_var = del_stmt_rule(p)) // del_stmt
1889 )
1890 {
1891 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt"));
1892 _res = del_stmt_var;
1893 goto done;
1894 }
1895 p->mark = _mark;
1896 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1897 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'del' del_stmt"));
1898 }
1899 { // &'yield' yield_stmt
1900 if (p->error_indicator) {
1901 p->level--;
1902 return NULL;
1903 }
1904 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt"));
1905 stmt_ty yield_stmt_var;
1906 if (
1907 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 580) // token='yield'
1908 &&
1909 (yield_stmt_var = yield_stmt_rule(p)) // yield_stmt
1910 )
1911 {
1912 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt"));
1913 _res = yield_stmt_var;
1914 goto done;
1915 }
1916 p->mark = _mark;
1917 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1918 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'yield' yield_stmt"));
1919 }
1920 { // &'assert' assert_stmt
1921 if (p->error_indicator) {
1922 p->level--;
1923 return NULL;
1924 }
1925 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt"));
1926 stmt_ty assert_stmt_var;
1927 if (
1928 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 529) // token='assert'
1929 &&
1930 (assert_stmt_var = assert_stmt_rule(p)) // assert_stmt
1931 )
1932 {
1933 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt"));
1934 _res = assert_stmt_var;
1935 goto done;
1936 }
1937 p->mark = _mark;
1938 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1939 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'assert' assert_stmt"));
1940 }
1941 { // 'break'
1942 if (p->error_indicator) {
1943 p->level--;
1944 return NULL;
1945 }
1946 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'"));
1947 Token * _keyword;
1948 if (
1949 (_keyword = _PyPegen_expect_token(p, 508)) // token='break'
1950 )
1951 {
1952 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'break'"));
1953 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1954 if (_token == NULL) {
1955 p->level--;
1956 return NULL;
1957 }
1958 int _end_lineno = _token->end_lineno;
1959 UNUSED(_end_lineno); // Only used by EXTRA macro
1960 int _end_col_offset = _token->end_col_offset;
1961 UNUSED(_end_col_offset); // Only used by EXTRA macro
1962 _res = _PyAST_Break ( EXTRA );
1963 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1964 p->error_indicator = 1;
1965 p->level--;
1966 return NULL;
1967 }
1968 goto done;
1969 }
1970 p->mark = _mark;
1971 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
1972 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'break'"));
1973 }
1974 { // 'continue'
1975 if (p->error_indicator) {
1976 p->level--;
1977 return NULL;
1978 }
1979 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'"));
1980 Token * _keyword;
1981 if (
1982 (_keyword = _PyPegen_expect_token(p, 509)) // token='continue'
1983 )
1984 {
1985 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'continue'"));
1986 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
1987 if (_token == NULL) {
1988 p->level--;
1989 return NULL;
1990 }
1991 int _end_lineno = _token->end_lineno;
1992 UNUSED(_end_lineno); // Only used by EXTRA macro
1993 int _end_col_offset = _token->end_col_offset;
1994 UNUSED(_end_col_offset); // Only used by EXTRA macro
1995 _res = _PyAST_Continue ( EXTRA );
1996 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
1997 p->error_indicator = 1;
1998 p->level--;
1999 return NULL;
2000 }
2001 goto done;
2002 }
2003 p->mark = _mark;
2004 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2005 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'continue'"));
2006 }
2007 { // &'global' global_stmt
2008 if (p->error_indicator) {
2009 p->level--;
2010 return NULL;
2011 }
2012 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt"));
2013 stmt_ty global_stmt_var;
2014 if (
2015 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 526) // token='global'
2016 &&
2017 (global_stmt_var = global_stmt_rule(p)) // global_stmt
2018 )
2019 {
2020 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt"));
2021 _res = global_stmt_var;
2022 goto done;
2023 }
2024 p->mark = _mark;
2025 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2026 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'global' global_stmt"));
2027 }
2028 { // &'nonlocal' nonlocal_stmt
2029 if (p->error_indicator) {
2030 p->level--;
2031 return NULL;
2032 }
2033 D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
2034 stmt_ty nonlocal_stmt_var;
2035 if (
2036 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 527) // token='nonlocal'
2037 &&
2038 (nonlocal_stmt_var = nonlocal_stmt_rule(p)) // nonlocal_stmt
2039 )
2040 {
2041 D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
2042 _res = nonlocal_stmt_var;
2043 goto done;
2044 }
2045 p->mark = _mark;
2046 D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2047 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
2048 }
2049 _res = NULL;
2050 done:
2051 _PyPegen_insert_memo(p, _mark, simple_stmt_type, _res);
2052 p->level--;
2053 return _res;
2054 }
2055
2056 // compound_stmt:
2057 // | &('def' | '@' | 'async') function_def
2058 // | &'if' if_stmt
2059 // | &('class' | '@') class_def
2060 // | &('with' | 'async') with_stmt
2061 // | &('for' | 'async') for_stmt
2062 // | &'try' try_stmt
2063 // | &'while' while_stmt
2064 // | match_stmt
2065 static stmt_ty
2066 compound_stmt_rule(Parser *p)
2067 {
2068 if (p->level++ == MAXSTACK) {
2069 _Pypegen_stack_overflow(p);
2070 }
2071 if (p->error_indicator) {
2072 p->level--;
2073 return NULL;
2074 }
2075 stmt_ty _res = NULL;
2076 int _mark = p->mark;
2077 { // &('def' | '@' | 'async') function_def
2078 if (p->error_indicator) {
2079 p->level--;
2080 return NULL;
2081 }
2082 D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | 'async') function_def"));
2083 stmt_ty function_def_var;
2084 if (
2085 _PyPegen_lookahead(1, _tmp_7_rule, p)
2086 &&
2087 (function_def_var = function_def_rule(p)) // function_def
2088 )
2089 {
2090 D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | 'async') function_def"));
2091 _res = function_def_var;
2092 goto done;
2093 }
2094 p->mark = _mark;
2095 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2096 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('def' | '@' | 'async') function_def"));
2097 }
2098 { // &'if' if_stmt
2099 if (p->error_indicator) {
2100 p->level--;
2101 return NULL;
2102 }
2103 D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt"));
2104 stmt_ty if_stmt_var;
2105 if (
2106 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 660) // token='if'
2107 &&
2108 (if_stmt_var = if_stmt_rule(p)) // if_stmt
2109 )
2110 {
2111 D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt"));
2112 _res = if_stmt_var;
2113 goto done;
2114 }
2115 p->mark = _mark;
2116 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2117 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'if' if_stmt"));
2118 }
2119 { // &('class' | '@') class_def
2120 if (p->error_indicator) {
2121 p->level--;
2122 return NULL;
2123 }
2124 D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def"));
2125 stmt_ty class_def_var;
2126 if (
2127 _PyPegen_lookahead(1, _tmp_8_rule, p)
2128 &&
2129 (class_def_var = class_def_rule(p)) // class_def
2130 )
2131 {
2132 D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def"));
2133 _res = class_def_var;
2134 goto done;
2135 }
2136 p->mark = _mark;
2137 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2138 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('class' | '@') class_def"));
2139 }
2140 { // &('with' | 'async') with_stmt
2141 if (p->error_indicator) {
2142 p->level--;
2143 return NULL;
2144 }
2145 D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('with' | 'async') with_stmt"));
2146 stmt_ty with_stmt_var;
2147 if (
2148 _PyPegen_lookahead(1, _tmp_9_rule, p)
2149 &&
2150 (with_stmt_var = with_stmt_rule(p)) // with_stmt
2151 )
2152 {
2153 D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('with' | 'async') with_stmt"));
2154 _res = with_stmt_var;
2155 goto done;
2156 }
2157 p->mark = _mark;
2158 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2159 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('with' | 'async') with_stmt"));
2160 }
2161 { // &('for' | 'async') for_stmt
2162 if (p->error_indicator) {
2163 p->level--;
2164 return NULL;
2165 }
2166 D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('for' | 'async') for_stmt"));
2167 stmt_ty for_stmt_var;
2168 if (
2169 _PyPegen_lookahead(1, _tmp_10_rule, p)
2170 &&
2171 (for_stmt_var = for_stmt_rule(p)) // for_stmt
2172 )
2173 {
2174 D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('for' | 'async') for_stmt"));
2175 _res = for_stmt_var;
2176 goto done;
2177 }
2178 p->mark = _mark;
2179 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2180 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('for' | 'async') for_stmt"));
2181 }
2182 { // &'try' try_stmt
2183 if (p->error_indicator) {
2184 p->level--;
2185 return NULL;
2186 }
2187 D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt"));
2188 stmt_ty try_stmt_var;
2189 if (
2190 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 642) // token='try'
2191 &&
2192 (try_stmt_var = try_stmt_rule(p)) // try_stmt
2193 )
2194 {
2195 D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt"));
2196 _res = try_stmt_var;
2197 goto done;
2198 }
2199 p->mark = _mark;
2200 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2201 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'try' try_stmt"));
2202 }
2203 { // &'while' while_stmt
2204 if (p->error_indicator) {
2205 p->level--;
2206 return NULL;
2207 }
2208 D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt"));
2209 stmt_ty while_stmt_var;
2210 if (
2211 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 665) // token='while'
2212 &&
2213 (while_stmt_var = while_stmt_rule(p)) // while_stmt
2214 )
2215 {
2216 D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt"));
2217 _res = while_stmt_var;
2218 goto done;
2219 }
2220 p->mark = _mark;
2221 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2222 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'while' while_stmt"));
2223 }
2224 { // match_stmt
2225 if (p->error_indicator) {
2226 p->level--;
2227 return NULL;
2228 }
2229 D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "match_stmt"));
2230 stmt_ty match_stmt_var;
2231 if (
2232 (match_stmt_var = match_stmt_rule(p)) // match_stmt
2233 )
2234 {
2235 D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "match_stmt"));
2236 _res = match_stmt_var;
2237 goto done;
2238 }
2239 p->mark = _mark;
2240 D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2241 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "match_stmt"));
2242 }
2243 _res = NULL;
2244 done:
2245 p->level--;
2246 return _res;
2247 }
2248
2249 // assignment:
2250 // | NAME ':' expression ['=' annotated_rhs]
2251 // | ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]
2252 // | ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?
2253 // | single_target augassign ~ (yield_expr | star_expressions)
2254 // | invalid_assignment
2255 static stmt_ty
2256 assignment_rule(Parser *p)
2257 {
2258 if (p->level++ == MAXSTACK) {
2259 _Pypegen_stack_overflow(p);
2260 }
2261 if (p->error_indicator) {
2262 p->level--;
2263 return NULL;
2264 }
2265 stmt_ty _res = NULL;
2266 int _mark = p->mark;
2267 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
2268 p->error_indicator = 1;
2269 p->level--;
2270 return NULL;
2271 }
2272 int _start_lineno = p->tokens[_mark]->lineno;
2273 UNUSED(_start_lineno); // Only used by EXTRA macro
2274 int _start_col_offset = p->tokens[_mark]->col_offset;
2275 UNUSED(_start_col_offset); // Only used by EXTRA macro
2276 { // NAME ':' expression ['=' annotated_rhs]
2277 if (p->error_indicator) {
2278 p->level--;
2279 return NULL;
2280 }
2281 D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
2282 Token * _literal;
2283 expr_ty a;
2284 expr_ty b;
2285 void *c;
2286 if (
2287 (a = _PyPegen_name_token(p)) // NAME
2288 &&
2289 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
2290 &&
2291 (b = expression_rule(p)) // expression
2292 &&
2293 (c = _tmp_11_rule(p), !p->error_indicator) // ['=' annotated_rhs]
2294 )
2295 {
2296 D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
2297 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2298 if (_token == NULL) {
2299 p->level--;
2300 return NULL;
2301 }
2302 int _end_lineno = _token->end_lineno;
2303 UNUSED(_end_lineno); // Only used by EXTRA macro
2304 int _end_col_offset = _token->end_col_offset;
2305 UNUSED(_end_col_offset); // Only used by EXTRA macro
2306 _res = 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 ) );
2307 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2308 p->error_indicator = 1;
2309 p->level--;
2310 return NULL;
2311 }
2312 goto done;
2313 }
2314 p->mark = _mark;
2315 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
2316 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
2317 }
2318 { // ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]
2319 if (p->error_indicator) {
2320 p->level--;
2321 return NULL;
2322 }
2323 D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]"));
2324 Token * _literal;
2325 void *a;
2326 expr_ty b;
2327 void *c;
2328 if (
2329 (a = _tmp_12_rule(p)) // '(' single_target ')' | single_subscript_attribute_target
2330 &&
2331 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
2332 &&
2333 (b = expression_rule(p)) // expression
2334 &&
2335 (c = _tmp_13_rule(p), !p->error_indicator) // ['=' annotated_rhs]
2336 )
2337 {
2338 D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]"));
2339 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2340 if (_token == NULL) {
2341 p->level--;
2342 return NULL;
2343 }
2344 int _end_lineno = _token->end_lineno;
2345 UNUSED(_end_lineno); // Only used by EXTRA macro
2346 int _end_col_offset = _token->end_col_offset;
2347 UNUSED(_end_col_offset); // Only used by EXTRA macro
2348 _res = CHECK_VERSION ( stmt_ty , 6 , "Variable annotations syntax is" , _PyAST_AnnAssign ( a , b , c , 0 , EXTRA ) );
2349 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2350 p->error_indicator = 1;
2351 p->level--;
2352 return NULL;
2353 }
2354 goto done;
2355 }
2356 p->mark = _mark;
2357 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
2358 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]"));
2359 }
2360 { // ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?
2361 if (p->error_indicator) {
2362 p->level--;
2363 return NULL;
2364 }
2365 D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
2366 asdl_expr_seq* a;
2367 void *b;
2368 void *tc;
2369 if (
2370 (a = (asdl_expr_seq*)_loop1_14_rule(p)) // ((star_targets '='))+
2371 &&
2372 (b = _tmp_15_rule(p)) // yield_expr | star_expressions
2373 &&
2374 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='='
2375 &&
2376 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
2377 )
2378 {
2379 D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
2380 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2381 if (_token == NULL) {
2382 p->level--;
2383 return NULL;
2384 }
2385 int _end_lineno = _token->end_lineno;
2386 UNUSED(_end_lineno); // Only used by EXTRA macro
2387 int _end_col_offset = _token->end_col_offset;
2388 UNUSED(_end_col_offset); // Only used by EXTRA macro
2389 _res = _PyAST_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
2390 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2391 p->error_indicator = 1;
2392 p->level--;
2393 return NULL;
2394 }
2395 goto done;
2396 }
2397 p->mark = _mark;
2398 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
2399 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
2400 }
2401 { // single_target augassign ~ (yield_expr | star_expressions)
2402 if (p->error_indicator) {
2403 p->level--;
2404 return NULL;
2405 }
2406 D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
2407 int _cut_var = 0;
2408 expr_ty a;
2409 AugOperator* b;
2410 void *c;
2411 if (
2412 (a = single_target_rule(p)) // single_target
2413 &&
2414 (b = augassign_rule(p)) // augassign
2415 &&
2416 (_cut_var = 1)
2417 &&
2418 (c = _tmp_16_rule(p)) // yield_expr | star_expressions
2419 )
2420 {
2421 D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
2422 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2423 if (_token == NULL) {
2424 p->level--;
2425 return NULL;
2426 }
2427 int _end_lineno = _token->end_lineno;
2428 UNUSED(_end_lineno); // Only used by EXTRA macro
2429 int _end_col_offset = _token->end_col_offset;
2430 UNUSED(_end_col_offset); // Only used by EXTRA macro
2431 _res = _PyAST_AugAssign ( a , b -> kind , c , EXTRA );
2432 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2433 p->error_indicator = 1;
2434 p->level--;
2435 return NULL;
2436 }
2437 goto done;
2438 }
2439 p->mark = _mark;
2440 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
2441 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
2442 if (_cut_var) {
2443 p->level--;
2444 return NULL;
2445 }
2446 }
2447 if (p->call_invalid_rules) { // invalid_assignment
2448 if (p->error_indicator) {
2449 p->level--;
2450 return NULL;
2451 }
2452 D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_assignment"));
2453 void *invalid_assignment_var;
2454 if (
2455 (invalid_assignment_var = invalid_assignment_rule(p)) // invalid_assignment
2456 )
2457 {
2458 D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_assignment"));
2459 _res = invalid_assignment_var;
2460 goto done;
2461 }
2462 p->mark = _mark;
2463 D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
2464 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_assignment"));
2465 }
2466 _res = NULL;
2467 done:
2468 p->level--;
2469 return _res;
2470 }
2471
2472 // annotated_rhs: yield_expr | star_expressions
2473 static expr_ty
2474 annotated_rhs_rule(Parser *p)
2475 {
2476 if (p->level++ == MAXSTACK) {
2477 _Pypegen_stack_overflow(p);
2478 }
2479 if (p->error_indicator) {
2480 p->level--;
2481 return NULL;
2482 }
2483 expr_ty _res = NULL;
2484 int _mark = p->mark;
2485 { // yield_expr
2486 if (p->error_indicator) {
2487 p->level--;
2488 return NULL;
2489 }
2490 D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
2491 expr_ty yield_expr_var;
2492 if (
2493 (yield_expr_var = yield_expr_rule(p)) // yield_expr
2494 )
2495 {
2496 D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
2497 _res = yield_expr_var;
2498 goto done;
2499 }
2500 p->mark = _mark;
2501 D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ',
2502 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
2503 }
2504 { // star_expressions
2505 if (p->error_indicator) {
2506 p->level--;
2507 return NULL;
2508 }
2509 D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
2510 expr_ty star_expressions_var;
2511 if (
2512 (star_expressions_var = star_expressions_rule(p)) // star_expressions
2513 )
2514 {
2515 D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
2516 _res = star_expressions_var;
2517 goto done;
2518 }
2519 p->mark = _mark;
2520 D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ',
2521 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
2522 }
2523 _res = NULL;
2524 done:
2525 p->level--;
2526 return _res;
2527 }
2528
2529 // augassign:
2530 // | '+='
2531 // | '-='
2532 // | '*='
2533 // | '@='
2534 // | '/='
2535 // | '%='
2536 // | '&='
2537 // | '|='
2538 // | '^='
2539 // | '<<='
2540 // | '>>='
2541 // | '**='
2542 // | '//='
2543 static AugOperator*
2544 augassign_rule(Parser *p)
2545 {
2546 if (p->level++ == MAXSTACK) {
2547 _Pypegen_stack_overflow(p);
2548 }
2549 if (p->error_indicator) {
2550 p->level--;
2551 return NULL;
2552 }
2553 AugOperator* _res = NULL;
2554 int _mark = p->mark;
2555 { // '+='
2556 if (p->error_indicator) {
2557 p->level--;
2558 return NULL;
2559 }
2560 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='"));
2561 Token * _literal;
2562 if (
2563 (_literal = _PyPegen_expect_token(p, 36)) // token='+='
2564 )
2565 {
2566 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+='"));
2567 _res = _PyPegen_augoperator ( p , Add );
2568 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2569 p->error_indicator = 1;
2570 p->level--;
2571 return NULL;
2572 }
2573 goto done;
2574 }
2575 p->mark = _mark;
2576 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2577 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='"));
2578 }
2579 { // '-='
2580 if (p->error_indicator) {
2581 p->level--;
2582 return NULL;
2583 }
2584 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='"));
2585 Token * _literal;
2586 if (
2587 (_literal = _PyPegen_expect_token(p, 37)) // token='-='
2588 )
2589 {
2590 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-='"));
2591 _res = _PyPegen_augoperator ( p , Sub );
2592 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2593 p->error_indicator = 1;
2594 p->level--;
2595 return NULL;
2596 }
2597 goto done;
2598 }
2599 p->mark = _mark;
2600 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2601 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='"));
2602 }
2603 { // '*='
2604 if (p->error_indicator) {
2605 p->level--;
2606 return NULL;
2607 }
2608 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='"));
2609 Token * _literal;
2610 if (
2611 (_literal = _PyPegen_expect_token(p, 38)) // token='*='
2612 )
2613 {
2614 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*='"));
2615 _res = _PyPegen_augoperator ( p , Mult );
2616 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2617 p->error_indicator = 1;
2618 p->level--;
2619 return NULL;
2620 }
2621 goto done;
2622 }
2623 p->mark = _mark;
2624 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2625 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='"));
2626 }
2627 { // '@='
2628 if (p->error_indicator) {
2629 p->level--;
2630 return NULL;
2631 }
2632 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='"));
2633 Token * _literal;
2634 if (
2635 (_literal = _PyPegen_expect_token(p, 50)) // token='@='
2636 )
2637 {
2638 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@='"));
2639 _res = CHECK_VERSION ( AugOperator* , 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) );
2640 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2641 p->error_indicator = 1;
2642 p->level--;
2643 return NULL;
2644 }
2645 goto done;
2646 }
2647 p->mark = _mark;
2648 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2649 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='"));
2650 }
2651 { // '/='
2652 if (p->error_indicator) {
2653 p->level--;
2654 return NULL;
2655 }
2656 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='"));
2657 Token * _literal;
2658 if (
2659 (_literal = _PyPegen_expect_token(p, 39)) // token='/='
2660 )
2661 {
2662 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/='"));
2663 _res = _PyPegen_augoperator ( p , Div );
2664 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2665 p->error_indicator = 1;
2666 p->level--;
2667 return NULL;
2668 }
2669 goto done;
2670 }
2671 p->mark = _mark;
2672 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2673 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='"));
2674 }
2675 { // '%='
2676 if (p->error_indicator) {
2677 p->level--;
2678 return NULL;
2679 }
2680 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='"));
2681 Token * _literal;
2682 if (
2683 (_literal = _PyPegen_expect_token(p, 40)) // token='%='
2684 )
2685 {
2686 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%='"));
2687 _res = _PyPegen_augoperator ( p , Mod );
2688 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2689 p->error_indicator = 1;
2690 p->level--;
2691 return NULL;
2692 }
2693 goto done;
2694 }
2695 p->mark = _mark;
2696 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2697 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='"));
2698 }
2699 { // '&='
2700 if (p->error_indicator) {
2701 p->level--;
2702 return NULL;
2703 }
2704 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='"));
2705 Token * _literal;
2706 if (
2707 (_literal = _PyPegen_expect_token(p, 41)) // token='&='
2708 )
2709 {
2710 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'&='"));
2711 _res = _PyPegen_augoperator ( p , BitAnd );
2712 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2713 p->error_indicator = 1;
2714 p->level--;
2715 return NULL;
2716 }
2717 goto done;
2718 }
2719 p->mark = _mark;
2720 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2721 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='"));
2722 }
2723 { // '|='
2724 if (p->error_indicator) {
2725 p->level--;
2726 return NULL;
2727 }
2728 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='"));
2729 Token * _literal;
2730 if (
2731 (_literal = _PyPegen_expect_token(p, 42)) // token='|='
2732 )
2733 {
2734 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|='"));
2735 _res = _PyPegen_augoperator ( p , BitOr );
2736 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2737 p->error_indicator = 1;
2738 p->level--;
2739 return NULL;
2740 }
2741 goto done;
2742 }
2743 p->mark = _mark;
2744 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2745 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='"));
2746 }
2747 { // '^='
2748 if (p->error_indicator) {
2749 p->level--;
2750 return NULL;
2751 }
2752 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='"));
2753 Token * _literal;
2754 if (
2755 (_literal = _PyPegen_expect_token(p, 43)) // token='^='
2756 )
2757 {
2758 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'^='"));
2759 _res = _PyPegen_augoperator ( p , BitXor );
2760 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2761 p->error_indicator = 1;
2762 p->level--;
2763 return NULL;
2764 }
2765 goto done;
2766 }
2767 p->mark = _mark;
2768 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2769 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='"));
2770 }
2771 { // '<<='
2772 if (p->error_indicator) {
2773 p->level--;
2774 return NULL;
2775 }
2776 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='"));
2777 Token * _literal;
2778 if (
2779 (_literal = _PyPegen_expect_token(p, 44)) // token='<<='
2780 )
2781 {
2782 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<<='"));
2783 _res = _PyPegen_augoperator ( p , LShift );
2784 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2785 p->error_indicator = 1;
2786 p->level--;
2787 return NULL;
2788 }
2789 goto done;
2790 }
2791 p->mark = _mark;
2792 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2793 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='"));
2794 }
2795 { // '>>='
2796 if (p->error_indicator) {
2797 p->level--;
2798 return NULL;
2799 }
2800 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='"));
2801 Token * _literal;
2802 if (
2803 (_literal = _PyPegen_expect_token(p, 45)) // token='>>='
2804 )
2805 {
2806 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>>='"));
2807 _res = _PyPegen_augoperator ( p , RShift );
2808 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2809 p->error_indicator = 1;
2810 p->level--;
2811 return NULL;
2812 }
2813 goto done;
2814 }
2815 p->mark = _mark;
2816 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2817 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='"));
2818 }
2819 { // '**='
2820 if (p->error_indicator) {
2821 p->level--;
2822 return NULL;
2823 }
2824 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='"));
2825 Token * _literal;
2826 if (
2827 (_literal = _PyPegen_expect_token(p, 46)) // token='**='
2828 )
2829 {
2830 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**='"));
2831 _res = _PyPegen_augoperator ( p , Pow );
2832 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2833 p->error_indicator = 1;
2834 p->level--;
2835 return NULL;
2836 }
2837 goto done;
2838 }
2839 p->mark = _mark;
2840 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2841 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='"));
2842 }
2843 { // '//='
2844 if (p->error_indicator) {
2845 p->level--;
2846 return NULL;
2847 }
2848 D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='"));
2849 Token * _literal;
2850 if (
2851 (_literal = _PyPegen_expect_token(p, 48)) // token='//='
2852 )
2853 {
2854 D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//='"));
2855 _res = _PyPegen_augoperator ( p , FloorDiv );
2856 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2857 p->error_indicator = 1;
2858 p->level--;
2859 return NULL;
2860 }
2861 goto done;
2862 }
2863 p->mark = _mark;
2864 D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
2865 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='"));
2866 }
2867 _res = NULL;
2868 done:
2869 p->level--;
2870 return _res;
2871 }
2872
2873 // return_stmt: 'return' star_expressions?
2874 static stmt_ty
2875 return_stmt_rule(Parser *p)
2876 {
2877 if (p->level++ == MAXSTACK) {
2878 _Pypegen_stack_overflow(p);
2879 }
2880 if (p->error_indicator) {
2881 p->level--;
2882 return NULL;
2883 }
2884 stmt_ty _res = NULL;
2885 int _mark = p->mark;
2886 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
2887 p->error_indicator = 1;
2888 p->level--;
2889 return NULL;
2890 }
2891 int _start_lineno = p->tokens[_mark]->lineno;
2892 UNUSED(_start_lineno); // Only used by EXTRA macro
2893 int _start_col_offset = p->tokens[_mark]->col_offset;
2894 UNUSED(_start_col_offset); // Only used by EXTRA macro
2895 { // 'return' star_expressions?
2896 if (p->error_indicator) {
2897 p->level--;
2898 return NULL;
2899 }
2900 D(fprintf(stderr, "%*c> return_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?"));
2901 Token * _keyword;
2902 void *a;
2903 if (
2904 (_keyword = _PyPegen_expect_token(p, 522)) // token='return'
2905 &&
2906 (a = star_expressions_rule(p), !p->error_indicator) // star_expressions?
2907 )
2908 {
2909 D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?"));
2910 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2911 if (_token == NULL) {
2912 p->level--;
2913 return NULL;
2914 }
2915 int _end_lineno = _token->end_lineno;
2916 UNUSED(_end_lineno); // Only used by EXTRA macro
2917 int _end_col_offset = _token->end_col_offset;
2918 UNUSED(_end_col_offset); // Only used by EXTRA macro
2919 _res = _PyAST_Return ( a , EXTRA );
2920 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2921 p->error_indicator = 1;
2922 p->level--;
2923 return NULL;
2924 }
2925 goto done;
2926 }
2927 p->mark = _mark;
2928 D(fprintf(stderr, "%*c%s return_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2929 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'return' star_expressions?"));
2930 }
2931 _res = NULL;
2932 done:
2933 p->level--;
2934 return _res;
2935 }
2936
2937 // raise_stmt: 'raise' expression ['from' expression] | 'raise'
2938 static stmt_ty
2939 raise_stmt_rule(Parser *p)
2940 {
2941 if (p->level++ == MAXSTACK) {
2942 _Pypegen_stack_overflow(p);
2943 }
2944 if (p->error_indicator) {
2945 p->level--;
2946 return NULL;
2947 }
2948 stmt_ty _res = NULL;
2949 int _mark = p->mark;
2950 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
2951 p->error_indicator = 1;
2952 p->level--;
2953 return NULL;
2954 }
2955 int _start_lineno = p->tokens[_mark]->lineno;
2956 UNUSED(_start_lineno); // Only used by EXTRA macro
2957 int _start_col_offset = p->tokens[_mark]->col_offset;
2958 UNUSED(_start_col_offset); // Only used by EXTRA macro
2959 { // 'raise' expression ['from' expression]
2960 if (p->error_indicator) {
2961 p->level--;
2962 return NULL;
2963 }
2964 D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]"));
2965 Token * _keyword;
2966 expr_ty a;
2967 void *b;
2968 if (
2969 (_keyword = _PyPegen_expect_token(p, 525)) // token='raise'
2970 &&
2971 (a = expression_rule(p)) // expression
2972 &&
2973 (b = _tmp_17_rule(p), !p->error_indicator) // ['from' expression]
2974 )
2975 {
2976 D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]"));
2977 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
2978 if (_token == NULL) {
2979 p->level--;
2980 return NULL;
2981 }
2982 int _end_lineno = _token->end_lineno;
2983 UNUSED(_end_lineno); // Only used by EXTRA macro
2984 int _end_col_offset = _token->end_col_offset;
2985 UNUSED(_end_col_offset); // Only used by EXTRA macro
2986 _res = _PyAST_Raise ( a , b , EXTRA );
2987 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
2988 p->error_indicator = 1;
2989 p->level--;
2990 return NULL;
2991 }
2992 goto done;
2993 }
2994 p->mark = _mark;
2995 D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ',
2996 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise' expression ['from' expression]"));
2997 }
2998 { // 'raise'
2999 if (p->error_indicator) {
3000 p->level--;
3001 return NULL;
3002 }
3003 D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'"));
3004 Token * _keyword;
3005 if (
3006 (_keyword = _PyPegen_expect_token(p, 525)) // token='raise'
3007 )
3008 {
3009 D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise'"));
3010 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3011 if (_token == NULL) {
3012 p->level--;
3013 return NULL;
3014 }
3015 int _end_lineno = _token->end_lineno;
3016 UNUSED(_end_lineno); // Only used by EXTRA macro
3017 int _end_col_offset = _token->end_col_offset;
3018 UNUSED(_end_col_offset); // Only used by EXTRA macro
3019 _res = _PyAST_Raise ( NULL , NULL , EXTRA );
3020 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3021 p->error_indicator = 1;
3022 p->level--;
3023 return NULL;
3024 }
3025 goto done;
3026 }
3027 p->mark = _mark;
3028 D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3029 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise'"));
3030 }
3031 _res = NULL;
3032 done:
3033 p->level--;
3034 return _res;
3035 }
3036
3037 // global_stmt: 'global' ','.NAME+
3038 static stmt_ty
3039 global_stmt_rule(Parser *p)
3040 {
3041 if (p->level++ == MAXSTACK) {
3042 _Pypegen_stack_overflow(p);
3043 }
3044 if (p->error_indicator) {
3045 p->level--;
3046 return NULL;
3047 }
3048 stmt_ty _res = NULL;
3049 int _mark = p->mark;
3050 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3051 p->error_indicator = 1;
3052 p->level--;
3053 return NULL;
3054 }
3055 int _start_lineno = p->tokens[_mark]->lineno;
3056 UNUSED(_start_lineno); // Only used by EXTRA macro
3057 int _start_col_offset = p->tokens[_mark]->col_offset;
3058 UNUSED(_start_col_offset); // Only used by EXTRA macro
3059 { // 'global' ','.NAME+
3060 if (p->error_indicator) {
3061 p->level--;
3062 return NULL;
3063 }
3064 D(fprintf(stderr, "%*c> global_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+"));
3065 Token * _keyword;
3066 asdl_expr_seq* a;
3067 if (
3068 (_keyword = _PyPegen_expect_token(p, 526)) // token='global'
3069 &&
3070 (a = (asdl_expr_seq*)_gather_18_rule(p)) // ','.NAME+
3071 )
3072 {
3073 D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+"));
3074 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3075 if (_token == NULL) {
3076 p->level--;
3077 return NULL;
3078 }
3079 int _end_lineno = _token->end_lineno;
3080 UNUSED(_end_lineno); // Only used by EXTRA macro
3081 int _end_col_offset = _token->end_col_offset;
3082 UNUSED(_end_col_offset); // Only used by EXTRA macro
3083 _res = _PyAST_Global ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
3084 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3085 p->error_indicator = 1;
3086 p->level--;
3087 return NULL;
3088 }
3089 goto done;
3090 }
3091 p->mark = _mark;
3092 D(fprintf(stderr, "%*c%s global_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3093 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'global' ','.NAME+"));
3094 }
3095 _res = NULL;
3096 done:
3097 p->level--;
3098 return _res;
3099 }
3100
3101 // nonlocal_stmt: 'nonlocal' ','.NAME+
3102 static stmt_ty
3103 nonlocal_stmt_rule(Parser *p)
3104 {
3105 if (p->level++ == MAXSTACK) {
3106 _Pypegen_stack_overflow(p);
3107 }
3108 if (p->error_indicator) {
3109 p->level--;
3110 return NULL;
3111 }
3112 stmt_ty _res = NULL;
3113 int _mark = p->mark;
3114 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3115 p->error_indicator = 1;
3116 p->level--;
3117 return NULL;
3118 }
3119 int _start_lineno = p->tokens[_mark]->lineno;
3120 UNUSED(_start_lineno); // Only used by EXTRA macro
3121 int _start_col_offset = p->tokens[_mark]->col_offset;
3122 UNUSED(_start_col_offset); // Only used by EXTRA macro
3123 { // 'nonlocal' ','.NAME+
3124 if (p->error_indicator) {
3125 p->level--;
3126 return NULL;
3127 }
3128 D(fprintf(stderr, "%*c> nonlocal_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+"));
3129 Token * _keyword;
3130 asdl_expr_seq* a;
3131 if (
3132 (_keyword = _PyPegen_expect_token(p, 527)) // token='nonlocal'
3133 &&
3134 (a = (asdl_expr_seq*)_gather_20_rule(p)) // ','.NAME+
3135 )
3136 {
3137 D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+"));
3138 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3139 if (_token == NULL) {
3140 p->level--;
3141 return NULL;
3142 }
3143 int _end_lineno = _token->end_lineno;
3144 UNUSED(_end_lineno); // Only used by EXTRA macro
3145 int _end_col_offset = _token->end_col_offset;
3146 UNUSED(_end_col_offset); // Only used by EXTRA macro
3147 _res = _PyAST_Nonlocal ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
3148 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3149 p->error_indicator = 1;
3150 p->level--;
3151 return NULL;
3152 }
3153 goto done;
3154 }
3155 p->mark = _mark;
3156 D(fprintf(stderr, "%*c%s nonlocal_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3157 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'nonlocal' ','.NAME+"));
3158 }
3159 _res = NULL;
3160 done:
3161 p->level--;
3162 return _res;
3163 }
3164
3165 // del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt
3166 static stmt_ty
3167 del_stmt_rule(Parser *p)
3168 {
3169 if (p->level++ == MAXSTACK) {
3170 _Pypegen_stack_overflow(p);
3171 }
3172 if (p->error_indicator) {
3173 p->level--;
3174 return NULL;
3175 }
3176 stmt_ty _res = NULL;
3177 int _mark = p->mark;
3178 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3179 p->error_indicator = 1;
3180 p->level--;
3181 return NULL;
3182 }
3183 int _start_lineno = p->tokens[_mark]->lineno;
3184 UNUSED(_start_lineno); // Only used by EXTRA macro
3185 int _start_col_offset = p->tokens[_mark]->col_offset;
3186 UNUSED(_start_col_offset); // Only used by EXTRA macro
3187 { // 'del' del_targets &(';' | NEWLINE)
3188 if (p->error_indicator) {
3189 p->level--;
3190 return NULL;
3191 }
3192 D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
3193 Token * _keyword;
3194 asdl_expr_seq* a;
3195 if (
3196 (_keyword = _PyPegen_expect_token(p, 616)) // token='del'
3197 &&
3198 (a = del_targets_rule(p)) // del_targets
3199 &&
3200 _PyPegen_lookahead(1, _tmp_22_rule, p)
3201 )
3202 {
3203 D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
3204 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3205 if (_token == NULL) {
3206 p->level--;
3207 return NULL;
3208 }
3209 int _end_lineno = _token->end_lineno;
3210 UNUSED(_end_lineno); // Only used by EXTRA macro
3211 int _end_col_offset = _token->end_col_offset;
3212 UNUSED(_end_col_offset); // Only used by EXTRA macro
3213 _res = _PyAST_Delete ( a , EXTRA );
3214 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3215 p->error_indicator = 1;
3216 p->level--;
3217 return NULL;
3218 }
3219 goto done;
3220 }
3221 p->mark = _mark;
3222 D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3223 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
3224 }
3225 if (p->call_invalid_rules) { // invalid_del_stmt
3226 if (p->error_indicator) {
3227 p->level--;
3228 return NULL;
3229 }
3230 D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt"));
3231 void *invalid_del_stmt_var;
3232 if (
3233 (invalid_del_stmt_var = invalid_del_stmt_rule(p)) // invalid_del_stmt
3234 )
3235 {
3236 D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt"));
3237 _res = invalid_del_stmt_var;
3238 goto done;
3239 }
3240 p->mark = _mark;
3241 D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3242 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_del_stmt"));
3243 }
3244 _res = NULL;
3245 done:
3246 p->level--;
3247 return _res;
3248 }
3249
3250 // yield_stmt: yield_expr
3251 static stmt_ty
3252 yield_stmt_rule(Parser *p)
3253 {
3254 if (p->level++ == MAXSTACK) {
3255 _Pypegen_stack_overflow(p);
3256 }
3257 if (p->error_indicator) {
3258 p->level--;
3259 return NULL;
3260 }
3261 stmt_ty _res = NULL;
3262 int _mark = p->mark;
3263 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3264 p->error_indicator = 1;
3265 p->level--;
3266 return NULL;
3267 }
3268 int _start_lineno = p->tokens[_mark]->lineno;
3269 UNUSED(_start_lineno); // Only used by EXTRA macro
3270 int _start_col_offset = p->tokens[_mark]->col_offset;
3271 UNUSED(_start_col_offset); // Only used by EXTRA macro
3272 { // yield_expr
3273 if (p->error_indicator) {
3274 p->level--;
3275 return NULL;
3276 }
3277 D(fprintf(stderr, "%*c> yield_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
3278 expr_ty y;
3279 if (
3280 (y = yield_expr_rule(p)) // yield_expr
3281 )
3282 {
3283 D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
3284 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3285 if (_token == NULL) {
3286 p->level--;
3287 return NULL;
3288 }
3289 int _end_lineno = _token->end_lineno;
3290 UNUSED(_end_lineno); // Only used by EXTRA macro
3291 int _end_col_offset = _token->end_col_offset;
3292 UNUSED(_end_col_offset); // Only used by EXTRA macro
3293 _res = _PyAST_Expr ( y , EXTRA );
3294 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3295 p->error_indicator = 1;
3296 p->level--;
3297 return NULL;
3298 }
3299 goto done;
3300 }
3301 p->mark = _mark;
3302 D(fprintf(stderr, "%*c%s yield_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3303 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
3304 }
3305 _res = NULL;
3306 done:
3307 p->level--;
3308 return _res;
3309 }
3310
3311 // assert_stmt: 'assert' expression [',' expression]
3312 static stmt_ty
3313 assert_stmt_rule(Parser *p)
3314 {
3315 if (p->level++ == MAXSTACK) {
3316 _Pypegen_stack_overflow(p);
3317 }
3318 if (p->error_indicator) {
3319 p->level--;
3320 return NULL;
3321 }
3322 stmt_ty _res = NULL;
3323 int _mark = p->mark;
3324 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3325 p->error_indicator = 1;
3326 p->level--;
3327 return NULL;
3328 }
3329 int _start_lineno = p->tokens[_mark]->lineno;
3330 UNUSED(_start_lineno); // Only used by EXTRA macro
3331 int _start_col_offset = p->tokens[_mark]->col_offset;
3332 UNUSED(_start_col_offset); // Only used by EXTRA macro
3333 { // 'assert' expression [',' expression]
3334 if (p->error_indicator) {
3335 p->level--;
3336 return NULL;
3337 }
3338 D(fprintf(stderr, "%*c> assert_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]"));
3339 Token * _keyword;
3340 expr_ty a;
3341 void *b;
3342 if (
3343 (_keyword = _PyPegen_expect_token(p, 529)) // token='assert'
3344 &&
3345 (a = expression_rule(p)) // expression
3346 &&
3347 (b = _tmp_23_rule(p), !p->error_indicator) // [',' expression]
3348 )
3349 {
3350 D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]"));
3351 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3352 if (_token == NULL) {
3353 p->level--;
3354 return NULL;
3355 }
3356 int _end_lineno = _token->end_lineno;
3357 UNUSED(_end_lineno); // Only used by EXTRA macro
3358 int _end_col_offset = _token->end_col_offset;
3359 UNUSED(_end_col_offset); // Only used by EXTRA macro
3360 _res = _PyAST_Assert ( a , b , EXTRA );
3361 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3362 p->error_indicator = 1;
3363 p->level--;
3364 return NULL;
3365 }
3366 goto done;
3367 }
3368 p->mark = _mark;
3369 D(fprintf(stderr, "%*c%s assert_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3370 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'assert' expression [',' expression]"));
3371 }
3372 _res = NULL;
3373 done:
3374 p->level--;
3375 return _res;
3376 }
3377
3378 // import_stmt: invalid_import | import_name | import_from
3379 static stmt_ty
3380 import_stmt_rule(Parser *p)
3381 {
3382 if (p->level++ == MAXSTACK) {
3383 _Pypegen_stack_overflow(p);
3384 }
3385 if (p->error_indicator) {
3386 p->level--;
3387 return NULL;
3388 }
3389 stmt_ty _res = NULL;
3390 int _mark = p->mark;
3391 if (p->call_invalid_rules) { // invalid_import
3392 if (p->error_indicator) {
3393 p->level--;
3394 return NULL;
3395 }
3396 D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_import"));
3397 void *invalid_import_var;
3398 if (
3399 (invalid_import_var = invalid_import_rule(p)) // invalid_import
3400 )
3401 {
3402 D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_import"));
3403 _res = invalid_import_var;
3404 goto done;
3405 }
3406 p->mark = _mark;
3407 D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3408 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import"));
3409 }
3410 { // import_name
3411 if (p->error_indicator) {
3412 p->level--;
3413 return NULL;
3414 }
3415 D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_name"));
3416 stmt_ty import_name_var;
3417 if (
3418 (import_name_var = import_name_rule(p)) // import_name
3419 )
3420 {
3421 D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_name"));
3422 _res = import_name_var;
3423 goto done;
3424 }
3425 p->mark = _mark;
3426 D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3427 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_name"));
3428 }
3429 { // import_from
3430 if (p->error_indicator) {
3431 p->level--;
3432 return NULL;
3433 }
3434 D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from"));
3435 stmt_ty import_from_var;
3436 if (
3437 (import_from_var = import_from_rule(p)) // import_from
3438 )
3439 {
3440 D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from"));
3441 _res = import_from_var;
3442 goto done;
3443 }
3444 p->mark = _mark;
3445 D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',
3446 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from"));
3447 }
3448 _res = NULL;
3449 done:
3450 p->level--;
3451 return _res;
3452 }
3453
3454 // import_name: 'import' dotted_as_names
3455 static stmt_ty
3456 import_name_rule(Parser *p)
3457 {
3458 if (p->level++ == MAXSTACK) {
3459 _Pypegen_stack_overflow(p);
3460 }
3461 if (p->error_indicator) {
3462 p->level--;
3463 return NULL;
3464 }
3465 stmt_ty _res = NULL;
3466 int _mark = p->mark;
3467 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3468 p->error_indicator = 1;
3469 p->level--;
3470 return NULL;
3471 }
3472 int _start_lineno = p->tokens[_mark]->lineno;
3473 UNUSED(_start_lineno); // Only used by EXTRA macro
3474 int _start_col_offset = p->tokens[_mark]->col_offset;
3475 UNUSED(_start_col_offset); // Only used by EXTRA macro
3476 { // 'import' dotted_as_names
3477 if (p->error_indicator) {
3478 p->level--;
3479 return NULL;
3480 }
3481 D(fprintf(stderr, "%*c> import_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names"));
3482 Token * _keyword;
3483 asdl_alias_seq* a;
3484 if (
3485 (_keyword = _PyPegen_expect_token(p, 622)) // token='import'
3486 &&
3487 (a = dotted_as_names_rule(p)) // dotted_as_names
3488 )
3489 {
3490 D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names"));
3491 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3492 if (_token == NULL) {
3493 p->level--;
3494 return NULL;
3495 }
3496 int _end_lineno = _token->end_lineno;
3497 UNUSED(_end_lineno); // Only used by EXTRA macro
3498 int _end_col_offset = _token->end_col_offset;
3499 UNUSED(_end_col_offset); // Only used by EXTRA macro
3500 _res = _PyAST_Import ( a , EXTRA );
3501 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3502 p->error_indicator = 1;
3503 p->level--;
3504 return NULL;
3505 }
3506 goto done;
3507 }
3508 p->mark = _mark;
3509 D(fprintf(stderr, "%*c%s import_name[%d-%d]: %s failed!\n", p->level, ' ',
3510 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import' dotted_as_names"));
3511 }
3512 _res = NULL;
3513 done:
3514 p->level--;
3515 return _res;
3516 }
3517
3518 // import_from:
3519 // | 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
3520 // | 'from' (('.' | '...'))+ 'import' import_from_targets
3521 static stmt_ty
3522 import_from_rule(Parser *p)
3523 {
3524 if (p->level++ == MAXSTACK) {
3525 _Pypegen_stack_overflow(p);
3526 }
3527 if (p->error_indicator) {
3528 p->level--;
3529 return NULL;
3530 }
3531 stmt_ty _res = NULL;
3532 int _mark = p->mark;
3533 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3534 p->error_indicator = 1;
3535 p->level--;
3536 return NULL;
3537 }
3538 int _start_lineno = p->tokens[_mark]->lineno;
3539 UNUSED(_start_lineno); // Only used by EXTRA macro
3540 int _start_col_offset = p->tokens[_mark]->col_offset;
3541 UNUSED(_start_col_offset); // Only used by EXTRA macro
3542 { // 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
3543 if (p->error_indicator) {
3544 p->level--;
3545 return NULL;
3546 }
3547 D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
3548 Token * _keyword;
3549 Token * _keyword_1;
3550 asdl_seq * a;
3551 expr_ty b;
3552 asdl_alias_seq* c;
3553 if (
3554 (_keyword = _PyPegen_expect_token(p, 621)) // token='from'
3555 &&
3556 (a = _loop0_24_rule(p)) // (('.' | '...'))*
3557 &&
3558 (b = dotted_name_rule(p)) // dotted_name
3559 &&
3560 (_keyword_1 = _PyPegen_expect_token(p, 622)) // token='import'
3561 &&
3562 (c = import_from_targets_rule(p)) // import_from_targets
3563 )
3564 {
3565 D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
3566 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3567 if (_token == NULL) {
3568 p->level--;
3569 return NULL;
3570 }
3571 int _end_lineno = _token->end_lineno;
3572 UNUSED(_end_lineno); // Only used by EXTRA macro
3573 int _end_col_offset = _token->end_col_offset;
3574 UNUSED(_end_col_offset); // Only used by EXTRA macro
3575 _res = _PyPegen_checked_future_import ( p , b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA );
3576 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3577 p->error_indicator = 1;
3578 p->level--;
3579 return NULL;
3580 }
3581 goto done;
3582 }
3583 p->mark = _mark;
3584 D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ',
3585 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
3586 }
3587 { // 'from' (('.' | '...'))+ 'import' import_from_targets
3588 if (p->error_indicator) {
3589 p->level--;
3590 return NULL;
3591 }
3592 D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
3593 Token * _keyword;
3594 Token * _keyword_1;
3595 asdl_seq * a;
3596 asdl_alias_seq* b;
3597 if (
3598 (_keyword = _PyPegen_expect_token(p, 621)) // token='from'
3599 &&
3600 (a = _loop1_25_rule(p)) // (('.' | '...'))+
3601 &&
3602 (_keyword_1 = _PyPegen_expect_token(p, 622)) // token='import'
3603 &&
3604 (b = import_from_targets_rule(p)) // import_from_targets
3605 )
3606 {
3607 D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
3608 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3609 if (_token == NULL) {
3610 p->level--;
3611 return NULL;
3612 }
3613 int _end_lineno = _token->end_lineno;
3614 UNUSED(_end_lineno); // Only used by EXTRA macro
3615 int _end_col_offset = _token->end_col_offset;
3616 UNUSED(_end_col_offset); // Only used by EXTRA macro
3617 _res = _PyAST_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA );
3618 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3619 p->error_indicator = 1;
3620 p->level--;
3621 return NULL;
3622 }
3623 goto done;
3624 }
3625 p->mark = _mark;
3626 D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ',
3627 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
3628 }
3629 _res = NULL;
3630 done:
3631 p->level--;
3632 return _res;
3633 }
3634
3635 // import_from_targets:
3636 // | '(' import_from_as_names ','? ')'
3637 // | import_from_as_names !','
3638 // | '*'
3639 // | invalid_import_from_targets
3640 static asdl_alias_seq*
3641 import_from_targets_rule(Parser *p)
3642 {
3643 if (p->level++ == MAXSTACK) {
3644 _Pypegen_stack_overflow(p);
3645 }
3646 if (p->error_indicator) {
3647 p->level--;
3648 return NULL;
3649 }
3650 asdl_alias_seq* _res = NULL;
3651 int _mark = p->mark;
3652 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3653 p->error_indicator = 1;
3654 p->level--;
3655 return NULL;
3656 }
3657 int _start_lineno = p->tokens[_mark]->lineno;
3658 UNUSED(_start_lineno); // Only used by EXTRA macro
3659 int _start_col_offset = p->tokens[_mark]->col_offset;
3660 UNUSED(_start_col_offset); // Only used by EXTRA macro
3661 { // '(' import_from_as_names ','? ')'
3662 if (p->error_indicator) {
3663 p->level--;
3664 return NULL;
3665 }
3666 D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'"));
3667 Token * _literal;
3668 Token * _literal_1;
3669 void *_opt_var;
3670 UNUSED(_opt_var); // Silence compiler warnings
3671 asdl_alias_seq* a;
3672 if (
3673 (_literal = _PyPegen_expect_token(p, 7)) // token='('
3674 &&
3675 (a = import_from_as_names_rule(p)) // import_from_as_names
3676 &&
3677 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
3678 &&
3679 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
3680 )
3681 {
3682 D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'"));
3683 _res = a;
3684 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3685 p->error_indicator = 1;
3686 p->level--;
3687 return NULL;
3688 }
3689 goto done;
3690 }
3691 p->mark = _mark;
3692 D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
3693 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' import_from_as_names ','? ')'"));
3694 }
3695 { // import_from_as_names !','
3696 if (p->error_indicator) {
3697 p->level--;
3698 return NULL;
3699 }
3700 D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','"));
3701 asdl_alias_seq* import_from_as_names_var;
3702 if (
3703 (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names
3704 &&
3705 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
3706 )
3707 {
3708 D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','"));
3709 _res = import_from_as_names_var;
3710 goto done;
3711 }
3712 p->mark = _mark;
3713 D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
3714 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names !','"));
3715 }
3716 { // '*'
3717 if (p->error_indicator) {
3718 p->level--;
3719 return NULL;
3720 }
3721 D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
3722 Token * _literal;
3723 if (
3724 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
3725 )
3726 {
3727 D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'"));
3728 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3729 if (_token == NULL) {
3730 p->level--;
3731 return NULL;
3732 }
3733 int _end_lineno = _token->end_lineno;
3734 UNUSED(_end_lineno); // Only used by EXTRA macro
3735 int _end_col_offset = _token->end_col_offset;
3736 UNUSED(_end_col_offset); // Only used by EXTRA macro
3737 _res = ( asdl_alias_seq* ) _PyPegen_singleton_seq ( p , CHECK ( alias_ty , _PyPegen_alias_for_star ( p , EXTRA ) ) );
3738 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3739 p->error_indicator = 1;
3740 p->level--;
3741 return NULL;
3742 }
3743 goto done;
3744 }
3745 p->mark = _mark;
3746 D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
3747 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));
3748 }
3749 if (p->call_invalid_rules) { // invalid_import_from_targets
3750 if (p->error_indicator) {
3751 p->level--;
3752 return NULL;
3753 }
3754 D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets"));
3755 void *invalid_import_from_targets_var;
3756 if (
3757 (invalid_import_from_targets_var = invalid_import_from_targets_rule(p)) // invalid_import_from_targets
3758 )
3759 {
3760 D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets"));
3761 _res = invalid_import_from_targets_var;
3762 goto done;
3763 }
3764 p->mark = _mark;
3765 D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
3766 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import_from_targets"));
3767 }
3768 _res = NULL;
3769 done:
3770 p->level--;
3771 return _res;
3772 }
3773
3774 // import_from_as_names: ','.import_from_as_name+
3775 static asdl_alias_seq*
3776 import_from_as_names_rule(Parser *p)
3777 {
3778 if (p->level++ == MAXSTACK) {
3779 _Pypegen_stack_overflow(p);
3780 }
3781 if (p->error_indicator) {
3782 p->level--;
3783 return NULL;
3784 }
3785 asdl_alias_seq* _res = NULL;
3786 int _mark = p->mark;
3787 { // ','.import_from_as_name+
3788 if (p->error_indicator) {
3789 p->level--;
3790 return NULL;
3791 }
3792 D(fprintf(stderr, "%*c> import_from_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+"));
3793 asdl_alias_seq* a;
3794 if (
3795 (a = (asdl_alias_seq*)_gather_26_rule(p)) // ','.import_from_as_name+
3796 )
3797 {
3798 D(fprintf(stderr, "%*c+ import_from_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+"));
3799 _res = a;
3800 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3801 p->error_indicator = 1;
3802 p->level--;
3803 return NULL;
3804 }
3805 goto done;
3806 }
3807 p->mark = _mark;
3808 D(fprintf(stderr, "%*c%s import_from_as_names[%d-%d]: %s failed!\n", p->level, ' ',
3809 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.import_from_as_name+"));
3810 }
3811 _res = NULL;
3812 done:
3813 p->level--;
3814 return _res;
3815 }
3816
3817 // import_from_as_name: NAME ['as' NAME]
3818 static alias_ty
3819 import_from_as_name_rule(Parser *p)
3820 {
3821 if (p->level++ == MAXSTACK) {
3822 _Pypegen_stack_overflow(p);
3823 }
3824 if (p->error_indicator) {
3825 p->level--;
3826 return NULL;
3827 }
3828 alias_ty _res = NULL;
3829 int _mark = p->mark;
3830 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3831 p->error_indicator = 1;
3832 p->level--;
3833 return NULL;
3834 }
3835 int _start_lineno = p->tokens[_mark]->lineno;
3836 UNUSED(_start_lineno); // Only used by EXTRA macro
3837 int _start_col_offset = p->tokens[_mark]->col_offset;
3838 UNUSED(_start_col_offset); // Only used by EXTRA macro
3839 { // NAME ['as' NAME]
3840 if (p->error_indicator) {
3841 p->level--;
3842 return NULL;
3843 }
3844 D(fprintf(stderr, "%*c> import_from_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]"));
3845 expr_ty a;
3846 void *b;
3847 if (
3848 (a = _PyPegen_name_token(p)) // NAME
3849 &&
3850 (b = _tmp_28_rule(p), !p->error_indicator) // ['as' NAME]
3851 )
3852 {
3853 D(fprintf(stderr, "%*c+ import_from_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]"));
3854 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3855 if (_token == NULL) {
3856 p->level--;
3857 return NULL;
3858 }
3859 int _end_lineno = _token->end_lineno;
3860 UNUSED(_end_lineno); // Only used by EXTRA macro
3861 int _end_col_offset = _token->end_col_offset;
3862 UNUSED(_end_col_offset); // Only used by EXTRA macro
3863 _res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXTRA );
3864 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3865 p->error_indicator = 1;
3866 p->level--;
3867 return NULL;
3868 }
3869 goto done;
3870 }
3871 p->mark = _mark;
3872 D(fprintf(stderr, "%*c%s import_from_as_name[%d-%d]: %s failed!\n", p->level, ' ',
3873 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ['as' NAME]"));
3874 }
3875 _res = NULL;
3876 done:
3877 p->level--;
3878 return _res;
3879 }
3880
3881 // dotted_as_names: ','.dotted_as_name+
3882 static asdl_alias_seq*
3883 dotted_as_names_rule(Parser *p)
3884 {
3885 if (p->level++ == MAXSTACK) {
3886 _Pypegen_stack_overflow(p);
3887 }
3888 if (p->error_indicator) {
3889 p->level--;
3890 return NULL;
3891 }
3892 asdl_alias_seq* _res = NULL;
3893 int _mark = p->mark;
3894 { // ','.dotted_as_name+
3895 if (p->error_indicator) {
3896 p->level--;
3897 return NULL;
3898 }
3899 D(fprintf(stderr, "%*c> dotted_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+"));
3900 asdl_alias_seq* a;
3901 if (
3902 (a = (asdl_alias_seq*)_gather_29_rule(p)) // ','.dotted_as_name+
3903 )
3904 {
3905 D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+"));
3906 _res = a;
3907 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3908 p->error_indicator = 1;
3909 p->level--;
3910 return NULL;
3911 }
3912 goto done;
3913 }
3914 p->mark = _mark;
3915 D(fprintf(stderr, "%*c%s dotted_as_names[%d-%d]: %s failed!\n", p->level, ' ',
3916 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.dotted_as_name+"));
3917 }
3918 _res = NULL;
3919 done:
3920 p->level--;
3921 return _res;
3922 }
3923
3924 // dotted_as_name: dotted_name ['as' NAME]
3925 static alias_ty
3926 dotted_as_name_rule(Parser *p)
3927 {
3928 if (p->level++ == MAXSTACK) {
3929 _Pypegen_stack_overflow(p);
3930 }
3931 if (p->error_indicator) {
3932 p->level--;
3933 return NULL;
3934 }
3935 alias_ty _res = NULL;
3936 int _mark = p->mark;
3937 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
3938 p->error_indicator = 1;
3939 p->level--;
3940 return NULL;
3941 }
3942 int _start_lineno = p->tokens[_mark]->lineno;
3943 UNUSED(_start_lineno); // Only used by EXTRA macro
3944 int _start_col_offset = p->tokens[_mark]->col_offset;
3945 UNUSED(_start_col_offset); // Only used by EXTRA macro
3946 { // dotted_name ['as' NAME]
3947 if (p->error_indicator) {
3948 p->level--;
3949 return NULL;
3950 }
3951 D(fprintf(stderr, "%*c> dotted_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]"));
3952 expr_ty a;
3953 void *b;
3954 if (
3955 (a = dotted_name_rule(p)) // dotted_name
3956 &&
3957 (b = _tmp_31_rule(p), !p->error_indicator) // ['as' NAME]
3958 )
3959 {
3960 D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]"));
3961 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
3962 if (_token == NULL) {
3963 p->level--;
3964 return NULL;
3965 }
3966 int _end_lineno = _token->end_lineno;
3967 UNUSED(_end_lineno); // Only used by EXTRA macro
3968 int _end_col_offset = _token->end_col_offset;
3969 UNUSED(_end_col_offset); // Only used by EXTRA macro
3970 _res = _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXTRA );
3971 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
3972 p->error_indicator = 1;
3973 p->level--;
3974 return NULL;
3975 }
3976 goto done;
3977 }
3978 p->mark = _mark;
3979 D(fprintf(stderr, "%*c%s dotted_as_name[%d-%d]: %s failed!\n", p->level, ' ',
3980 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name ['as' NAME]"));
3981 }
3982 _res = NULL;
3983 done:
3984 p->level--;
3985 return _res;
3986 }
3987
3988 // Left-recursive
3989 // dotted_name: dotted_name '.' NAME | NAME
3990 static expr_ty dotted_name_raw(Parser *);
3991 static expr_ty
3992 dotted_name_rule(Parser *p)
3993 {
3994 if (p->level++ == MAXSTACK) {
3995 _Pypegen_stack_overflow(p);
3996 }
3997 expr_ty _res = NULL;
3998 if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) {
3999 p->level--;
4000 return _res;
4001 }
4002 int _mark = p->mark;
4003 int _resmark = p->mark;
4004 while (1) {
4005 int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res);
4006 if (tmpvar_0) {
4007 p->level--;
4008 return _res;
4009 }
4010 p->mark = _mark;
4011 void *_raw = dotted_name_raw(p);
4012 if (p->error_indicator) {
4013 p->level--;
4014 return NULL;
4015 }
4016 if (_raw == NULL || p->mark <= _resmark)
4017 break;
4018 _resmark = p->mark;
4019 _res = _raw;
4020 }
4021 p->mark = _resmark;
4022 p->level--;
4023 return _res;
4024 }
4025 static expr_ty
4026 dotted_name_raw(Parser *p)
4027 {
4028 if (p->level++ == MAXSTACK) {
4029 _Pypegen_stack_overflow(p);
4030 }
4031 if (p->error_indicator) {
4032 p->level--;
4033 return NULL;
4034 }
4035 expr_ty _res = NULL;
4036 int _mark = p->mark;
4037 { // dotted_name '.' NAME
4038 if (p->error_indicator) {
4039 p->level--;
4040 return NULL;
4041 }
4042 D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME"));
4043 Token * _literal;
4044 expr_ty a;
4045 expr_ty b;
4046 if (
4047 (a = dotted_name_rule(p)) // dotted_name
4048 &&
4049 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
4050 &&
4051 (b = _PyPegen_name_token(p)) // NAME
4052 )
4053 {
4054 D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME"));
4055 _res = _PyPegen_join_names_with_dot ( p , a , b );
4056 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4057 p->error_indicator = 1;
4058 p->level--;
4059 return NULL;
4060 }
4061 goto done;
4062 }
4063 p->mark = _mark;
4064 D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ',
4065 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name '.' NAME"));
4066 }
4067 { // NAME
4068 if (p->error_indicator) {
4069 p->level--;
4070 return NULL;
4071 }
4072 D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
4073 expr_ty name_var;
4074 if (
4075 (name_var = _PyPegen_name_token(p)) // NAME
4076 )
4077 {
4078 D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
4079 _res = name_var;
4080 goto done;
4081 }
4082 p->mark = _mark;
4083 D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ',
4084 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
4085 }
4086 _res = NULL;
4087 done:
4088 p->level--;
4089 return _res;
4090 }
4091
4092 // block: NEWLINE INDENT statements DEDENT | simple_stmts | invalid_block
4093 static asdl_stmt_seq*
4094 block_rule(Parser *p)
4095 {
4096 if (p->level++ == MAXSTACK) {
4097 _Pypegen_stack_overflow(p);
4098 }
4099 if (p->error_indicator) {
4100 p->level--;
4101 return NULL;
4102 }
4103 asdl_stmt_seq* _res = NULL;
4104 if (_PyPegen_is_memoized(p, block_type, &_res)) {
4105 p->level--;
4106 return _res;
4107 }
4108 int _mark = p->mark;
4109 { // NEWLINE INDENT statements DEDENT
4110 if (p->error_indicator) {
4111 p->level--;
4112 return NULL;
4113 }
4114 D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
4115 asdl_stmt_seq* a;
4116 Token * dedent_var;
4117 Token * indent_var;
4118 Token * newline_var;
4119 if (
4120 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
4121 &&
4122 (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT'
4123 &&
4124 (a = statements_rule(p)) // statements
4125 &&
4126 (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT'
4127 )
4128 {
4129 D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
4130 _res = a;
4131 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4132 p->error_indicator = 1;
4133 p->level--;
4134 return NULL;
4135 }
4136 goto done;
4137 }
4138 p->mark = _mark;
4139 D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
4140 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
4141 }
4142 { // simple_stmts
4143 if (p->error_indicator) {
4144 p->level--;
4145 return NULL;
4146 }
4147 D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
4148 asdl_stmt_seq* simple_stmts_var;
4149 if (
4150 (simple_stmts_var = simple_stmts_rule(p)) // simple_stmts
4151 )
4152 {
4153 D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmts"));
4154 _res = simple_stmts_var;
4155 goto done;
4156 }
4157 p->mark = _mark;
4158 D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
4159 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts"));
4160 }
4161 if (p->call_invalid_rules) { // invalid_block
4162 if (p->error_indicator) {
4163 p->level--;
4164 return NULL;
4165 }
4166 D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_block"));
4167 void *invalid_block_var;
4168 if (
4169 (invalid_block_var = invalid_block_rule(p)) // invalid_block
4170 )
4171 {
4172 D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_block"));
4173 _res = invalid_block_var;
4174 goto done;
4175 }
4176 p->mark = _mark;
4177 D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
4178 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_block"));
4179 }
4180 _res = NULL;
4181 done:
4182 _PyPegen_insert_memo(p, _mark, block_type, _res);
4183 p->level--;
4184 return _res;
4185 }
4186
4187 // decorators: (('@' named_expression NEWLINE))+
4188 static asdl_expr_seq*
4189 decorators_rule(Parser *p)
4190 {
4191 if (p->level++ == MAXSTACK) {
4192 _Pypegen_stack_overflow(p);
4193 }
4194 if (p->error_indicator) {
4195 p->level--;
4196 return NULL;
4197 }
4198 asdl_expr_seq* _res = NULL;
4199 int _mark = p->mark;
4200 { // (('@' named_expression NEWLINE))+
4201 if (p->error_indicator) {
4202 p->level--;
4203 return NULL;
4204 }
4205 D(fprintf(stderr, "%*c> decorators[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+"));
4206 asdl_expr_seq* a;
4207 if (
4208 (a = (asdl_expr_seq*)_loop1_32_rule(p)) // (('@' named_expression NEWLINE))+
4209 )
4210 {
4211 D(fprintf(stderr, "%*c+ decorators[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+"));
4212 _res = a;
4213 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4214 p->error_indicator = 1;
4215 p->level--;
4216 return NULL;
4217 }
4218 goto done;
4219 }
4220 p->mark = _mark;
4221 D(fprintf(stderr, "%*c%s decorators[%d-%d]: %s failed!\n", p->level, ' ',
4222 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(('@' named_expression NEWLINE))+"));
4223 }
4224 _res = NULL;
4225 done:
4226 p->level--;
4227 return _res;
4228 }
4229
4230 // class_def: decorators class_def_raw | class_def_raw
4231 static stmt_ty
4232 class_def_rule(Parser *p)
4233 {
4234 if (p->level++ == MAXSTACK) {
4235 _Pypegen_stack_overflow(p);
4236 }
4237 if (p->error_indicator) {
4238 p->level--;
4239 return NULL;
4240 }
4241 stmt_ty _res = NULL;
4242 int _mark = p->mark;
4243 { // decorators class_def_raw
4244 if (p->error_indicator) {
4245 p->level--;
4246 return NULL;
4247 }
4248 D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw"));
4249 asdl_expr_seq* a;
4250 stmt_ty b;
4251 if (
4252 (a = decorators_rule(p)) // decorators
4253 &&
4254 (b = class_def_raw_rule(p)) // class_def_raw
4255 )
4256 {
4257 D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw"));
4258 _res = _PyPegen_class_def_decorators ( p , a , b );
4259 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4260 p->error_indicator = 1;
4261 p->level--;
4262 return NULL;
4263 }
4264 goto done;
4265 }
4266 p->mark = _mark;
4267 D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ',
4268 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators class_def_raw"));
4269 }
4270 { // class_def_raw
4271 if (p->error_indicator) {
4272 p->level--;
4273 return NULL;
4274 }
4275 D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_def_raw"));
4276 stmt_ty class_def_raw_var;
4277 if (
4278 (class_def_raw_var = class_def_raw_rule(p)) // class_def_raw
4279 )
4280 {
4281 D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_def_raw"));
4282 _res = class_def_raw_var;
4283 goto done;
4284 }
4285 p->mark = _mark;
4286 D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ',
4287 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_def_raw"));
4288 }
4289 _res = NULL;
4290 done:
4291 p->level--;
4292 return _res;
4293 }
4294
4295 // class_def_raw:
4296 // | invalid_class_def_raw
4297 // | 'class' NAME type_params? ['(' arguments? ')'] ':' block
4298 static stmt_ty
4299 class_def_raw_rule(Parser *p)
4300 {
4301 if (p->level++ == MAXSTACK) {
4302 _Pypegen_stack_overflow(p);
4303 }
4304 if (p->error_indicator) {
4305 p->level--;
4306 return NULL;
4307 }
4308 stmt_ty _res = NULL;
4309 int _mark = p->mark;
4310 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
4311 p->error_indicator = 1;
4312 p->level--;
4313 return NULL;
4314 }
4315 int _start_lineno = p->tokens[_mark]->lineno;
4316 UNUSED(_start_lineno); // Only used by EXTRA macro
4317 int _start_col_offset = p->tokens[_mark]->col_offset;
4318 UNUSED(_start_col_offset); // Only used by EXTRA macro
4319 if (p->call_invalid_rules) { // invalid_class_def_raw
4320 if (p->error_indicator) {
4321 p->level--;
4322 return NULL;
4323 }
4324 D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_class_def_raw"));
4325 void *invalid_class_def_raw_var;
4326 if (
4327 (invalid_class_def_raw_var = invalid_class_def_raw_rule(p)) // invalid_class_def_raw
4328 )
4329 {
4330 D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_class_def_raw"));
4331 _res = invalid_class_def_raw_var;
4332 goto done;
4333 }
4334 p->mark = _mark;
4335 D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
4336 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_class_def_raw"));
4337 }
4338 { // 'class' NAME type_params? ['(' arguments? ')'] ':' block
4339 if (p->error_indicator) {
4340 p->level--;
4341 return NULL;
4342 }
4343 D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] ':' block"));
4344 Token * _keyword;
4345 Token * _literal;
4346 expr_ty a;
4347 void *b;
4348 asdl_stmt_seq* c;
4349 void *t;
4350 if (
4351 (_keyword = _PyPegen_expect_token(p, 677)) // token='class'
4352 &&
4353 (a = _PyPegen_name_token(p)) // NAME
4354 &&
4355 (t = type_params_rule(p), !p->error_indicator) // type_params?
4356 &&
4357 (b = _tmp_33_rule(p), !p->error_indicator) // ['(' arguments? ')']
4358 &&
4359 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
4360 &&
4361 (c = block_rule(p)) // block
4362 )
4363 {
4364 D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] ':' block"));
4365 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4366 if (_token == NULL) {
4367 p->level--;
4368 return NULL;
4369 }
4370 int _end_lineno = _token->end_lineno;
4371 UNUSED(_end_lineno); // Only used by EXTRA macro
4372 int _end_col_offset = _token->end_col_offset;
4373 UNUSED(_end_col_offset); // Only used by EXTRA macro
4374 _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 , t , EXTRA );
4375 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4376 p->error_indicator = 1;
4377 p->level--;
4378 return NULL;
4379 }
4380 goto done;
4381 }
4382 p->mark = _mark;
4383 D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
4384 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] ':' block"));
4385 }
4386 _res = NULL;
4387 done:
4388 p->level--;
4389 return _res;
4390 }
4391
4392 // function_def: decorators function_def_raw | function_def_raw
4393 static stmt_ty
4394 function_def_rule(Parser *p)
4395 {
4396 if (p->level++ == MAXSTACK) {
4397 _Pypegen_stack_overflow(p);
4398 }
4399 if (p->error_indicator) {
4400 p->level--;
4401 return NULL;
4402 }
4403 stmt_ty _res = NULL;
4404 int _mark = p->mark;
4405 { // decorators function_def_raw
4406 if (p->error_indicator) {
4407 p->level--;
4408 return NULL;
4409 }
4410 D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw"));
4411 asdl_expr_seq* d;
4412 stmt_ty f;
4413 if (
4414 (d = decorators_rule(p)) // decorators
4415 &&
4416 (f = function_def_raw_rule(p)) // function_def_raw
4417 )
4418 {
4419 D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw"));
4420 _res = _PyPegen_function_def_decorators ( p , d , f );
4421 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4422 p->error_indicator = 1;
4423 p->level--;
4424 return NULL;
4425 }
4426 goto done;
4427 }
4428 p->mark = _mark;
4429 D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ',
4430 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators function_def_raw"));
4431 }
4432 { // function_def_raw
4433 if (p->error_indicator) {
4434 p->level--;
4435 return NULL;
4436 }
4437 D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "function_def_raw"));
4438 stmt_ty function_def_raw_var;
4439 if (
4440 (function_def_raw_var = function_def_raw_rule(p)) // function_def_raw
4441 )
4442 {
4443 D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "function_def_raw"));
4444 _res = function_def_raw_var;
4445 goto done;
4446 }
4447 p->mark = _mark;
4448 D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ',
4449 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "function_def_raw"));
4450 }
4451 _res = NULL;
4452 done:
4453 p->level--;
4454 return _res;
4455 }
4456
4457 // function_def_raw:
4458 // | invalid_def_raw
4459 // | 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block
4460 // | 'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block
4461 static stmt_ty
4462 function_def_raw_rule(Parser *p)
4463 {
4464 if (p->level++ == MAXSTACK) {
4465 _Pypegen_stack_overflow(p);
4466 }
4467 if (p->error_indicator) {
4468 p->level--;
4469 return NULL;
4470 }
4471 stmt_ty _res = NULL;
4472 int _mark = p->mark;
4473 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
4474 p->error_indicator = 1;
4475 p->level--;
4476 return NULL;
4477 }
4478 int _start_lineno = p->tokens[_mark]->lineno;
4479 UNUSED(_start_lineno); // Only used by EXTRA macro
4480 int _start_col_offset = p->tokens[_mark]->col_offset;
4481 UNUSED(_start_col_offset); // Only used by EXTRA macro
4482 if (p->call_invalid_rules) { // invalid_def_raw
4483 if (p->error_indicator) {
4484 p->level--;
4485 return NULL;
4486 }
4487 D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_def_raw"));
4488 void *invalid_def_raw_var;
4489 if (
4490 (invalid_def_raw_var = invalid_def_raw_rule(p)) // invalid_def_raw
4491 )
4492 {
4493 D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_def_raw"));
4494 _res = invalid_def_raw_var;
4495 goto done;
4496 }
4497 p->mark = _mark;
4498 D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
4499 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_def_raw"));
4500 }
4501 { // 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block
4502 if (p->error_indicator) {
4503 p->level--;
4504 return NULL;
4505 }
4506 D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block"));
4507 Token * _keyword;
4508 Token * _literal;
4509 Token * _literal_1;
4510 Token * _literal_2;
4511 void *a;
4512 asdl_stmt_seq* b;
4513 expr_ty n;
4514 void *params;
4515 void *t;
4516 void *tc;
4517 if (
4518 (_keyword = _PyPegen_expect_token(p, 675)) // token='def'
4519 &&
4520 (n = _PyPegen_name_token(p)) // NAME
4521 &&
4522 (t = type_params_rule(p), !p->error_indicator) // type_params?
4523 &&
4524 (_literal = _PyPegen_expect_token(p, 7)) // token='('
4525 &&
4526 (params = params_rule(p), !p->error_indicator) // params?
4527 &&
4528 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
4529 &&
4530 (a = _tmp_34_rule(p), !p->error_indicator) // ['->' expression]
4531 &&
4532 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
4533 &&
4534 (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment?
4535 &&
4536 (b = block_rule(p)) // block
4537 )
4538 {
4539 D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block"));
4540 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4541 if (_token == NULL) {
4542 p->level--;
4543 return NULL;
4544 }
4545 int _end_lineno = _token->end_lineno;
4546 UNUSED(_end_lineno); // Only used by EXTRA macro
4547 int _end_col_offset = _token->end_col_offset;
4548 UNUSED(_end_col_offset); // Only used by EXTRA macro
4549 _res = _PyAST_FunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , t , EXTRA );
4550 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4551 p->error_indicator = 1;
4552 p->level--;
4553 return NULL;
4554 }
4555 goto done;
4556 }
4557 p->mark = _mark;
4558 D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
4559 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block"));
4560 }
4561 { // 'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block
4562 if (p->error_indicator) {
4563 p->level--;
4564 return NULL;
4565 }
4566 D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block"));
4567 Token * _keyword;
4568 Token * _keyword_1;
4569 Token * _literal;
4570 Token * _literal_1;
4571 Token * _literal_2;
4572 void *a;
4573 asdl_stmt_seq* b;
4574 expr_ty n;
4575 void *params;
4576 void *t;
4577 void *tc;
4578 if (
4579 (_keyword = _PyPegen_expect_token(p, 674)) // token='async'
4580 &&
4581 (_keyword_1 = _PyPegen_expect_token(p, 675)) // token='def'
4582 &&
4583 (n = _PyPegen_name_token(p)) // NAME
4584 &&
4585 (t = type_params_rule(p), !p->error_indicator) // type_params?
4586 &&
4587 (_literal = _PyPegen_expect_token(p, 7)) // token='('
4588 &&
4589 (params = params_rule(p), !p->error_indicator) // params?
4590 &&
4591 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
4592 &&
4593 (a = _tmp_35_rule(p), !p->error_indicator) // ['->' expression]
4594 &&
4595 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
4596 &&
4597 (tc = func_type_comment_rule(p), !p->error_indicator) // func_type_comment?
4598 &&
4599 (b = block_rule(p)) // block
4600 )
4601 {
4602 D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block"));
4603 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
4604 if (_token == NULL) {
4605 p->level--;
4606 return NULL;
4607 }
4608 int _end_lineno = _token->end_lineno;
4609 UNUSED(_end_lineno); // Only used by EXTRA macro
4610 int _end_col_offset = _token->end_col_offset;
4611 UNUSED(_end_col_offset); // Only used by EXTRA macro
4612 _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 ) , t , EXTRA ) );
4613 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4614 p->error_indicator = 1;
4615 p->level--;
4616 return NULL;
4617 }
4618 goto done;
4619 }
4620 p->mark = _mark;
4621 D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
4622 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block"));
4623 }
4624 _res = NULL;
4625 done:
4626 p->level--;
4627 return _res;
4628 }
4629
4630 // params: invalid_parameters | parameters
4631 static arguments_ty
4632 params_rule(Parser *p)
4633 {
4634 if (p->level++ == MAXSTACK) {
4635 _Pypegen_stack_overflow(p);
4636 }
4637 if (p->error_indicator) {
4638 p->level--;
4639 return NULL;
4640 }
4641 arguments_ty _res = NULL;
4642 int _mark = p->mark;
4643 if (p->call_invalid_rules) { // invalid_parameters
4644 if (p->error_indicator) {
4645 p->level--;
4646 return NULL;
4647 }
4648 D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_parameters"));
4649 void *invalid_parameters_var;
4650 if (
4651 (invalid_parameters_var = invalid_parameters_rule(p)) // invalid_parameters
4652 )
4653 {
4654 D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_parameters"));
4655 _res = invalid_parameters_var;
4656 goto done;
4657 }
4658 p->mark = _mark;
4659 D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ',
4660 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_parameters"));
4661 }
4662 { // parameters
4663 if (p->error_indicator) {
4664 p->level--;
4665 return NULL;
4666 }
4667 D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "parameters"));
4668 arguments_ty parameters_var;
4669 if (
4670 (parameters_var = parameters_rule(p)) // parameters
4671 )
4672 {
4673 D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "parameters"));
4674 _res = parameters_var;
4675 goto done;
4676 }
4677 p->mark = _mark;
4678 D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ',
4679 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "parameters"));
4680 }
4681 _res = NULL;
4682 done:
4683 p->level--;
4684 return _res;
4685 }
4686
4687 // parameters:
4688 // | slash_no_default param_no_default* param_with_default* star_etc?
4689 // | slash_with_default param_with_default* star_etc?
4690 // | param_no_default+ param_with_default* star_etc?
4691 // | param_with_default+ star_etc?
4692 // | star_etc
4693 static arguments_ty
4694 parameters_rule(Parser *p)
4695 {
4696 if (p->level++ == MAXSTACK) {
4697 _Pypegen_stack_overflow(p);
4698 }
4699 if (p->error_indicator) {
4700 p->level--;
4701 return NULL;
4702 }
4703 arguments_ty _res = NULL;
4704 int _mark = p->mark;
4705 { // slash_no_default param_no_default* param_with_default* star_etc?
4706 if (p->error_indicator) {
4707 p->level--;
4708 return NULL;
4709 }
4710 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?"));
4711 asdl_arg_seq* a;
4712 asdl_arg_seq* b;
4713 asdl_seq * c;
4714 void *d;
4715 if (
4716 (a = slash_no_default_rule(p)) // slash_no_default
4717 &&
4718 (b = (asdl_arg_seq*)_loop0_36_rule(p)) // param_no_default*
4719 &&
4720 (c = _loop0_37_rule(p)) // param_with_default*
4721 &&
4722 (d = star_etc_rule(p), !p->error_indicator) // star_etc?
4723 )
4724 {
4725 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?"));
4726 _res = CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , a , NULL , b , c , d ) );
4727 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4728 p->error_indicator = 1;
4729 p->level--;
4730 return NULL;
4731 }
4732 goto done;
4733 }
4734 p->mark = _mark;
4735 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
4736 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?"));
4737 }
4738 { // slash_with_default param_with_default* star_etc?
4739 if (p->error_indicator) {
4740 p->level--;
4741 return NULL;
4742 }
4743 D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?"));
4744 SlashWithDefault* a;
4745 asdl_seq * b;
4746 void *c;
4747 if (
4748 (a = slash_with_default_rule(p)) // slash_with_default
4749 &&
4750 (b = _loop0_38_rule(p)) // param_with_default*
4751 &&
4752 (c = star_etc_rule(p), !p->error_indicator) // star_etc?
4753 )
4754 {
4755 D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?"));
4756 _res = CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ) );
4757 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4758 p->error_indicator = 1;
4759 p->level--;
4760 return NULL;
4761 }
4762 goto done;
4763 }
4764 p->mark = _mark;
4765 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
4766 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default param_with_default* star_etc?"));
4767 }
4768 { // param_no_default+ param_with_default* star_etc?
4769 if (p->error_indicator) {
4770 p->level--;
4771 return NULL;
4772 }
4773 D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?"));
4774 asdl_arg_seq* a;
4775 asdl_seq * b;
4776 void *c;
4777 if (
4778 (a = (asdl_arg_seq*)_loop1_39_rule(p)) // param_no_default+
4779 &&
4780 (b = _loop0_40_rule(p)) // param_with_default*
4781 &&
4782 (c = star_etc_rule(p), !p->error_indicator) // star_etc?
4783 )
4784 {
4785 D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?"));
4786 _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
4787 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4788 p->error_indicator = 1;
4789 p->level--;
4790 return NULL;
4791 }
4792 goto done;
4793 }
4794 p->mark = _mark;
4795 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
4796 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ param_with_default* star_etc?"));
4797 }
4798 { // param_with_default+ star_etc?
4799 if (p->error_indicator) {
4800 p->level--;
4801 return NULL;
4802 }
4803 D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?"));
4804 asdl_seq * a;
4805 void *b;
4806 if (
4807 (a = _loop1_41_rule(p)) // param_with_default+
4808 &&
4809 (b = star_etc_rule(p), !p->error_indicator) // star_etc?
4810 )
4811 {
4812 D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?"));
4813 _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
4814 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4815 p->error_indicator = 1;
4816 p->level--;
4817 return NULL;
4818 }
4819 goto done;
4820 }
4821 p->mark = _mark;
4822 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
4823 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+ star_etc?"));
4824 }
4825 { // star_etc
4826 if (p->error_indicator) {
4827 p->level--;
4828 return NULL;
4829 }
4830 D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc"));
4831 StarEtc* a;
4832 if (
4833 (a = star_etc_rule(p)) // star_etc
4834 )
4835 {
4836 D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_etc"));
4837 _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
4838 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4839 p->error_indicator = 1;
4840 p->level--;
4841 return NULL;
4842 }
4843 goto done;
4844 }
4845 p->mark = _mark;
4846 D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
4847 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_etc"));
4848 }
4849 _res = NULL;
4850 done:
4851 p->level--;
4852 return _res;
4853 }
4854
4855 // slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &')'
4856 static asdl_arg_seq*
4857 slash_no_default_rule(Parser *p)
4858 {
4859 if (p->level++ == MAXSTACK) {
4860 _Pypegen_stack_overflow(p);
4861 }
4862 if (p->error_indicator) {
4863 p->level--;
4864 return NULL;
4865 }
4866 asdl_arg_seq* _res = NULL;
4867 int _mark = p->mark;
4868 { // param_no_default+ '/' ','
4869 if (p->error_indicator) {
4870 p->level--;
4871 return NULL;
4872 }
4873 D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','"));
4874 Token * _literal;
4875 Token * _literal_1;
4876 asdl_arg_seq* a;
4877 if (
4878 (a = (asdl_arg_seq*)_loop1_42_rule(p)) // param_no_default+
4879 &&
4880 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4881 &&
4882 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
4883 )
4884 {
4885 D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','"));
4886 _res = a;
4887 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4888 p->error_indicator = 1;
4889 p->level--;
4890 return NULL;
4891 }
4892 goto done;
4893 }
4894 p->mark = _mark;
4895 D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',
4896 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' ','"));
4897 }
4898 { // param_no_default+ '/' &')'
4899 if (p->error_indicator) {
4900 p->level--;
4901 return NULL;
4902 }
4903 D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'"));
4904 Token * _literal;
4905 asdl_arg_seq* a;
4906 if (
4907 (a = (asdl_arg_seq*)_loop1_43_rule(p)) // param_no_default+
4908 &&
4909 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4910 &&
4911 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
4912 )
4913 {
4914 D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'"));
4915 _res = a;
4916 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4917 p->error_indicator = 1;
4918 p->level--;
4919 return NULL;
4920 }
4921 goto done;
4922 }
4923 p->mark = _mark;
4924 D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',
4925 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' &')'"));
4926 }
4927 _res = NULL;
4928 done:
4929 p->level--;
4930 return _res;
4931 }
4932
4933 // slash_with_default:
4934 // | param_no_default* param_with_default+ '/' ','
4935 // | param_no_default* param_with_default+ '/' &')'
4936 static SlashWithDefault*
4937 slash_with_default_rule(Parser *p)
4938 {
4939 if (p->level++ == MAXSTACK) {
4940 _Pypegen_stack_overflow(p);
4941 }
4942 if (p->error_indicator) {
4943 p->level--;
4944 return NULL;
4945 }
4946 SlashWithDefault* _res = NULL;
4947 int _mark = p->mark;
4948 { // param_no_default* param_with_default+ '/' ','
4949 if (p->error_indicator) {
4950 p->level--;
4951 return NULL;
4952 }
4953 D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','"));
4954 Token * _literal;
4955 Token * _literal_1;
4956 asdl_seq * a;
4957 asdl_seq * b;
4958 if (
4959 (a = _loop0_44_rule(p)) // param_no_default*
4960 &&
4961 (b = _loop1_45_rule(p)) // param_with_default+
4962 &&
4963 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4964 &&
4965 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
4966 )
4967 {
4968 D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','"));
4969 _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
4970 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
4971 p->error_indicator = 1;
4972 p->level--;
4973 return NULL;
4974 }
4975 goto done;
4976 }
4977 p->mark = _mark;
4978 D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',
4979 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' ','"));
4980 }
4981 { // param_no_default* param_with_default+ '/' &')'
4982 if (p->error_indicator) {
4983 p->level--;
4984 return NULL;
4985 }
4986 D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'"));
4987 Token * _literal;
4988 asdl_seq * a;
4989 asdl_seq * b;
4990 if (
4991 (a = _loop0_46_rule(p)) // param_no_default*
4992 &&
4993 (b = _loop1_47_rule(p)) // param_with_default+
4994 &&
4995 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
4996 &&
4997 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
4998 )
4999 {
5000 D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'"));
5001 _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
5002 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5003 p->error_indicator = 1;
5004 p->level--;
5005 return NULL;
5006 }
5007 goto done;
5008 }
5009 p->mark = _mark;
5010 D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',
5011 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' &')'"));
5012 }
5013 _res = NULL;
5014 done:
5015 p->level--;
5016 return _res;
5017 }
5018
5019 // star_etc:
5020 // | invalid_star_etc
5021 // | '*' param_no_default param_maybe_default* kwds?
5022 // | '*' param_no_default_star_annotation param_maybe_default* kwds?
5023 // | '*' ',' param_maybe_default+ kwds?
5024 // | kwds
5025 static StarEtc*
5026 star_etc_rule(Parser *p)
5027 {
5028 if (p->level++ == MAXSTACK) {
5029 _Pypegen_stack_overflow(p);
5030 }
5031 if (p->error_indicator) {
5032 p->level--;
5033 return NULL;
5034 }
5035 StarEtc* _res = NULL;
5036 int _mark = p->mark;
5037 if (p->call_invalid_rules) { // invalid_star_etc
5038 if (p->error_indicator) {
5039 p->level--;
5040 return NULL;
5041 }
5042 D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_star_etc"));
5043 void *invalid_star_etc_var;
5044 if (
5045 (invalid_star_etc_var = invalid_star_etc_rule(p)) // invalid_star_etc
5046 )
5047 {
5048 D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_star_etc"));
5049 _res = invalid_star_etc_var;
5050 goto done;
5051 }
5052 p->mark = _mark;
5053 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
5054 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_star_etc"));
5055 }
5056 { // '*' param_no_default param_maybe_default* kwds?
5057 if (p->error_indicator) {
5058 p->level--;
5059 return NULL;
5060 }
5061 D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?"));
5062 Token * _literal;
5063 arg_ty a;
5064 asdl_seq * b;
5065 void *c;
5066 if (
5067 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
5068 &&
5069 (a = param_no_default_rule(p)) // param_no_default
5070 &&
5071 (b = _loop0_48_rule(p)) // param_maybe_default*
5072 &&
5073 (c = kwds_rule(p), !p->error_indicator) // kwds?
5074 )
5075 {
5076 D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?"));
5077 _res = _PyPegen_star_etc ( p , a , b , c );
5078 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5079 p->error_indicator = 1;
5080 p->level--;
5081 return NULL;
5082 }
5083 goto done;
5084 }
5085 p->mark = _mark;
5086 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
5087 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?"));
5088 }
5089 { // '*' param_no_default_star_annotation param_maybe_default* kwds?
5090 if (p->error_indicator) {
5091 p->level--;
5092 return NULL;
5093 }
5094 D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_default_star_annotation param_maybe_default* kwds?"));
5095 Token * _literal;
5096 arg_ty a;
5097 asdl_seq * b;
5098 void *c;
5099 if (
5100 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
5101 &&
5102 (a = param_no_default_star_annotation_rule(p)) // param_no_default_star_annotation
5103 &&
5104 (b = _loop0_49_rule(p)) // param_maybe_default*
5105 &&
5106 (c = kwds_rule(p), !p->error_indicator) // kwds?
5107 )
5108 {
5109 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?"));
5110 _res = _PyPegen_star_etc ( p , a , b , c );
5111 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5112 p->error_indicator = 1;
5113 p->level--;
5114 return NULL;
5115 }
5116 goto done;
5117 }
5118 p->mark = _mark;
5119 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
5120 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default_star_annotation param_maybe_default* kwds?"));
5121 }
5122 { // '*' ',' param_maybe_default+ kwds?
5123 if (p->error_indicator) {
5124 p->level--;
5125 return NULL;
5126 }
5127 D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
5128 Token * _literal;
5129 Token * _literal_1;
5130 asdl_seq * b;
5131 void *c;
5132 if (
5133 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
5134 &&
5135 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
5136 &&
5137 (b = _loop1_50_rule(p)) // param_maybe_default+
5138 &&
5139 (c = kwds_rule(p), !p->error_indicator) // kwds?
5140 )
5141 {
5142 D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
5143 _res = _PyPegen_star_etc ( p , NULL , b , c );
5144 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5145 p->error_indicator = 1;
5146 p->level--;
5147 return NULL;
5148 }
5149 goto done;
5150 }
5151 p->mark = _mark;
5152 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
5153 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
5154 }
5155 { // kwds
5156 if (p->error_indicator) {
5157 p->level--;
5158 return NULL;
5159 }
5160 D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwds"));
5161 arg_ty a;
5162 if (
5163 (a = kwds_rule(p)) // kwds
5164 )
5165 {
5166 D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwds"));
5167 _res = _PyPegen_star_etc ( p , NULL , NULL , a );
5168 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5169 p->error_indicator = 1;
5170 p->level--;
5171 return NULL;
5172 }
5173 goto done;
5174 }
5175 p->mark = _mark;
5176 D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
5177 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwds"));
5178 }
5179 _res = NULL;
5180 done:
5181 p->level--;
5182 return _res;
5183 }
5184
5185 // kwds: invalid_kwds | '**' param_no_default
5186 static arg_ty
5187 kwds_rule(Parser *p)
5188 {
5189 if (p->level++ == MAXSTACK) {
5190 _Pypegen_stack_overflow(p);
5191 }
5192 if (p->error_indicator) {
5193 p->level--;
5194 return NULL;
5195 }
5196 arg_ty _res = NULL;
5197 int _mark = p->mark;
5198 if (p->call_invalid_rules) { // invalid_kwds
5199 if (p->error_indicator) {
5200 p->level--;
5201 return NULL;
5202 }
5203 D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwds"));
5204 void *invalid_kwds_var;
5205 if (
5206 (invalid_kwds_var = invalid_kwds_rule(p)) // invalid_kwds
5207 )
5208 {
5209 D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwds"));
5210 _res = invalid_kwds_var;
5211 goto done;
5212 }
5213 p->mark = _mark;
5214 D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ',
5215 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwds"));
5216 }
5217 { // '**' param_no_default
5218 if (p->error_indicator) {
5219 p->level--;
5220 return NULL;
5221 }
5222 D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"));
5223 Token * _literal;
5224 arg_ty a;
5225 if (
5226 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
5227 &&
5228 (a = param_no_default_rule(p)) // param_no_default
5229 )
5230 {
5231 D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"));
5232 _res = a;
5233 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5234 p->error_indicator = 1;
5235 p->level--;
5236 return NULL;
5237 }
5238 goto done;
5239 }
5240 p->mark = _mark;
5241 D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ',
5242 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param_no_default"));
5243 }
5244 _res = NULL;
5245 done:
5246 p->level--;
5247 return _res;
5248 }
5249
5250 // param_no_default: param ',' TYPE_COMMENT? | param TYPE_COMMENT? &')'
5251 static arg_ty
5252 param_no_default_rule(Parser *p)
5253 {
5254 if (p->level++ == MAXSTACK) {
5255 _Pypegen_stack_overflow(p);
5256 }
5257 if (p->error_indicator) {
5258 p->level--;
5259 return NULL;
5260 }
5261 arg_ty _res = NULL;
5262 int _mark = p->mark;
5263 { // param ',' TYPE_COMMENT?
5264 if (p->error_indicator) {
5265 p->level--;
5266 return NULL;
5267 }
5268 D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?"));
5269 Token * _literal;
5270 arg_ty a;
5271 void *tc;
5272 if (
5273 (a = param_rule(p)) // param
5274 &&
5275 (_literal = _PyPegen_expect_token(p, 12)) // token=','
5276 &&
5277 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5278 )
5279 {
5280 D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?"));
5281 _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5282 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5283 p->error_indicator = 1;
5284 p->level--;
5285 return NULL;
5286 }
5287 goto done;
5288 }
5289 p->mark = _mark;
5290 D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ',
5291 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param ',' TYPE_COMMENT?"));
5292 }
5293 { // param TYPE_COMMENT? &')'
5294 if (p->error_indicator) {
5295 p->level--;
5296 return NULL;
5297 }
5298 D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'"));
5299 arg_ty a;
5300 void *tc;
5301 if (
5302 (a = param_rule(p)) // param
5303 &&
5304 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5305 &&
5306 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
5307 )
5308 {
5309 D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'"));
5310 _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5311 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5312 p->error_indicator = 1;
5313 p->level--;
5314 return NULL;
5315 }
5316 goto done;
5317 }
5318 p->mark = _mark;
5319 D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ',
5320 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param TYPE_COMMENT? &')'"));
5321 }
5322 _res = NULL;
5323 done:
5324 p->level--;
5325 return _res;
5326 }
5327
5328 // param_no_default_star_annotation:
5329 // | param_star_annotation ',' TYPE_COMMENT?
5330 // | param_star_annotation TYPE_COMMENT? &')'
5331 static arg_ty
5332 param_no_default_star_annotation_rule(Parser *p)
5333 {
5334 if (p->level++ == MAXSTACK) {
5335 _Pypegen_stack_overflow(p);
5336 }
5337 if (p->error_indicator) {
5338 p->level--;
5339 return NULL;
5340 }
5341 arg_ty _res = NULL;
5342 int _mark = p->mark;
5343 { // param_star_annotation ',' TYPE_COMMENT?
5344 if (p->error_indicator) {
5345 p->level--;
5346 return NULL;
5347 }
5348 D(fprintf(stderr, "%*c> param_no_default_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_star_annotation ',' TYPE_COMMENT?"));
5349 Token * _literal;
5350 arg_ty a;
5351 void *tc;
5352 if (
5353 (a = param_star_annotation_rule(p)) // param_star_annotation
5354 &&
5355 (_literal = _PyPegen_expect_token(p, 12)) // token=','
5356 &&
5357 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5358 )
5359 {
5360 D(fprintf(stderr, "%*c+ param_no_default_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_star_annotation ',' TYPE_COMMENT?"));
5361 _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5362 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5363 p->error_indicator = 1;
5364 p->level--;
5365 return NULL;
5366 }
5367 goto done;
5368 }
5369 p->mark = _mark;
5370 D(fprintf(stderr, "%*c%s param_no_default_star_annotation[%d-%d]: %s failed!\n", p->level, ' ',
5371 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_star_annotation ',' TYPE_COMMENT?"));
5372 }
5373 { // param_star_annotation TYPE_COMMENT? &')'
5374 if (p->error_indicator) {
5375 p->level--;
5376 return NULL;
5377 }
5378 D(fprintf(stderr, "%*c> param_no_default_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_star_annotation TYPE_COMMENT? &')'"));
5379 arg_ty a;
5380 void *tc;
5381 if (
5382 (a = param_star_annotation_rule(p)) // param_star_annotation
5383 &&
5384 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5385 &&
5386 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
5387 )
5388 {
5389 D(fprintf(stderr, "%*c+ param_no_default_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_star_annotation TYPE_COMMENT? &')'"));
5390 _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
5391 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5392 p->error_indicator = 1;
5393 p->level--;
5394 return NULL;
5395 }
5396 goto done;
5397 }
5398 p->mark = _mark;
5399 D(fprintf(stderr, "%*c%s param_no_default_star_annotation[%d-%d]: %s failed!\n", p->level, ' ',
5400 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_star_annotation TYPE_COMMENT? &')'"));
5401 }
5402 _res = NULL;
5403 done:
5404 p->level--;
5405 return _res;
5406 }
5407
5408 // param_with_default: param default ',' TYPE_COMMENT? | param default TYPE_COMMENT? &')'
5409 static NameDefaultPair*
5410 param_with_default_rule(Parser *p)
5411 {
5412 if (p->level++ == MAXSTACK) {
5413 _Pypegen_stack_overflow(p);
5414 }
5415 if (p->error_indicator) {
5416 p->level--;
5417 return NULL;
5418 }
5419 NameDefaultPair* _res = NULL;
5420 int _mark = p->mark;
5421 { // param default ',' TYPE_COMMENT?
5422 if (p->error_indicator) {
5423 p->level--;
5424 return NULL;
5425 }
5426 D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?"));
5427 Token * _literal;
5428 arg_ty a;
5429 expr_ty c;
5430 void *tc;
5431 if (
5432 (a = param_rule(p)) // param
5433 &&
5434 (c = default_rule(p)) // default
5435 &&
5436 (_literal = _PyPegen_expect_token(p, 12)) // token=','
5437 &&
5438 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5439 )
5440 {
5441 D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?"));
5442 _res = _PyPegen_name_default_pair ( p , a , c , tc );
5443 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5444 p->error_indicator = 1;
5445 p->level--;
5446 return NULL;
5447 }
5448 goto done;
5449 }
5450 p->mark = _mark;
5451 D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ',
5452 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default ',' TYPE_COMMENT?"));
5453 }
5454 { // param default TYPE_COMMENT? &')'
5455 if (p->error_indicator) {
5456 p->level--;
5457 return NULL;
5458 }
5459 D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'"));
5460 arg_ty a;
5461 expr_ty c;
5462 void *tc;
5463 if (
5464 (a = param_rule(p)) // param
5465 &&
5466 (c = default_rule(p)) // default
5467 &&
5468 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5469 &&
5470 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
5471 )
5472 {
5473 D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'"));
5474 _res = _PyPegen_name_default_pair ( p , a , c , tc );
5475 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5476 p->error_indicator = 1;
5477 p->level--;
5478 return NULL;
5479 }
5480 goto done;
5481 }
5482 p->mark = _mark;
5483 D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ',
5484 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default TYPE_COMMENT? &')'"));
5485 }
5486 _res = NULL;
5487 done:
5488 p->level--;
5489 return _res;
5490 }
5491
5492 // param_maybe_default:
5493 // | param default? ',' TYPE_COMMENT?
5494 // | param default? TYPE_COMMENT? &')'
5495 static NameDefaultPair*
5496 param_maybe_default_rule(Parser *p)
5497 {
5498 if (p->level++ == MAXSTACK) {
5499 _Pypegen_stack_overflow(p);
5500 }
5501 if (p->error_indicator) {
5502 p->level--;
5503 return NULL;
5504 }
5505 NameDefaultPair* _res = NULL;
5506 int _mark = p->mark;
5507 { // param default? ',' TYPE_COMMENT?
5508 if (p->error_indicator) {
5509 p->level--;
5510 return NULL;
5511 }
5512 D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?"));
5513 Token * _literal;
5514 arg_ty a;
5515 void *c;
5516 void *tc;
5517 if (
5518 (a = param_rule(p)) // param
5519 &&
5520 (c = default_rule(p), !p->error_indicator) // default?
5521 &&
5522 (_literal = _PyPegen_expect_token(p, 12)) // token=','
5523 &&
5524 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5525 )
5526 {
5527 D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?"));
5528 _res = _PyPegen_name_default_pair ( p , a , c , tc );
5529 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5530 p->error_indicator = 1;
5531 p->level--;
5532 return NULL;
5533 }
5534 goto done;
5535 }
5536 p->mark = _mark;
5537 D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',
5538 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? ',' TYPE_COMMENT?"));
5539 }
5540 { // param default? TYPE_COMMENT? &')'
5541 if (p->error_indicator) {
5542 p->level--;
5543 return NULL;
5544 }
5545 D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'"));
5546 arg_ty a;
5547 void *c;
5548 void *tc;
5549 if (
5550 (a = param_rule(p)) // param
5551 &&
5552 (c = default_rule(p), !p->error_indicator) // default?
5553 &&
5554 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
5555 &&
5556 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
5557 )
5558 {
5559 D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'"));
5560 _res = _PyPegen_name_default_pair ( p , a , c , tc );
5561 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5562 p->error_indicator = 1;
5563 p->level--;
5564 return NULL;
5565 }
5566 goto done;
5567 }
5568 p->mark = _mark;
5569 D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',
5570 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? TYPE_COMMENT? &')'"));
5571 }
5572 _res = NULL;
5573 done:
5574 p->level--;
5575 return _res;
5576 }
5577
5578 // param: NAME annotation?
5579 static arg_ty
5580 param_rule(Parser *p)
5581 {
5582 if (p->level++ == MAXSTACK) {
5583 _Pypegen_stack_overflow(p);
5584 }
5585 if (p->error_indicator) {
5586 p->level--;
5587 return NULL;
5588 }
5589 arg_ty _res = NULL;
5590 int _mark = p->mark;
5591 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
5592 p->error_indicator = 1;
5593 p->level--;
5594 return NULL;
5595 }
5596 int _start_lineno = p->tokens[_mark]->lineno;
5597 UNUSED(_start_lineno); // Only used by EXTRA macro
5598 int _start_col_offset = p->tokens[_mark]->col_offset;
5599 UNUSED(_start_col_offset); // Only used by EXTRA macro
5600 { // NAME annotation?
5601 if (p->error_indicator) {
5602 p->level--;
5603 return NULL;
5604 }
5605 D(fprintf(stderr, "%*c> param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
5606 expr_ty a;
5607 void *b;
5608 if (
5609 (a = _PyPegen_name_token(p)) // NAME
5610 &&
5611 (b = annotation_rule(p), !p->error_indicator) // annotation?
5612 )
5613 {
5614 D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
5615 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5616 if (_token == NULL) {
5617 p->level--;
5618 return NULL;
5619 }
5620 int _end_lineno = _token->end_lineno;
5621 UNUSED(_end_lineno); // Only used by EXTRA macro
5622 int _end_col_offset = _token->end_col_offset;
5623 UNUSED(_end_col_offset); // Only used by EXTRA macro
5624 _res = _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA );
5625 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5626 p->error_indicator = 1;
5627 p->level--;
5628 return NULL;
5629 }
5630 goto done;
5631 }
5632 p->mark = _mark;
5633 D(fprintf(stderr, "%*c%s param[%d-%d]: %s failed!\n", p->level, ' ',
5634 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME annotation?"));
5635 }
5636 _res = NULL;
5637 done:
5638 p->level--;
5639 return _res;
5640 }
5641
5642 // param_star_annotation: NAME star_annotation
5643 static arg_ty
5644 param_star_annotation_rule(Parser *p)
5645 {
5646 if (p->level++ == MAXSTACK) {
5647 _Pypegen_stack_overflow(p);
5648 }
5649 if (p->error_indicator) {
5650 p->level--;
5651 return NULL;
5652 }
5653 arg_ty _res = NULL;
5654 int _mark = p->mark;
5655 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
5656 p->error_indicator = 1;
5657 p->level--;
5658 return NULL;
5659 }
5660 int _start_lineno = p->tokens[_mark]->lineno;
5661 UNUSED(_start_lineno); // Only used by EXTRA macro
5662 int _start_col_offset = p->tokens[_mark]->col_offset;
5663 UNUSED(_start_col_offset); // Only used by EXTRA macro
5664 { // NAME star_annotation
5665 if (p->error_indicator) {
5666 p->level--;
5667 return NULL;
5668 }
5669 D(fprintf(stderr, "%*c> param_star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME star_annotation"));
5670 expr_ty a;
5671 expr_ty b;
5672 if (
5673 (a = _PyPegen_name_token(p)) // NAME
5674 &&
5675 (b = star_annotation_rule(p)) // star_annotation
5676 )
5677 {
5678 D(fprintf(stderr, "%*c+ param_star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME star_annotation"));
5679 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5680 if (_token == NULL) {
5681 p->level--;
5682 return NULL;
5683 }
5684 int _end_lineno = _token->end_lineno;
5685 UNUSED(_end_lineno); // Only used by EXTRA macro
5686 int _end_col_offset = _token->end_col_offset;
5687 UNUSED(_end_col_offset); // Only used by EXTRA macro
5688 _res = _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA );
5689 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5690 p->error_indicator = 1;
5691 p->level--;
5692 return NULL;
5693 }
5694 goto done;
5695 }
5696 p->mark = _mark;
5697 D(fprintf(stderr, "%*c%s param_star_annotation[%d-%d]: %s failed!\n", p->level, ' ',
5698 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME star_annotation"));
5699 }
5700 _res = NULL;
5701 done:
5702 p->level--;
5703 return _res;
5704 }
5705
5706 // annotation: ':' expression
5707 static expr_ty
5708 annotation_rule(Parser *p)
5709 {
5710 if (p->level++ == MAXSTACK) {
5711 _Pypegen_stack_overflow(p);
5712 }
5713 if (p->error_indicator) {
5714 p->level--;
5715 return NULL;
5716 }
5717 expr_ty _res = NULL;
5718 int _mark = p->mark;
5719 { // ':' expression
5720 if (p->error_indicator) {
5721 p->level--;
5722 return NULL;
5723 }
5724 D(fprintf(stderr, "%*c> annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression"));
5725 Token * _literal;
5726 expr_ty a;
5727 if (
5728 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5729 &&
5730 (a = expression_rule(p)) // expression
5731 )
5732 {
5733 D(fprintf(stderr, "%*c+ annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression"));
5734 _res = a;
5735 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5736 p->error_indicator = 1;
5737 p->level--;
5738 return NULL;
5739 }
5740 goto done;
5741 }
5742 p->mark = _mark;
5743 D(fprintf(stderr, "%*c%s annotation[%d-%d]: %s failed!\n", p->level, ' ',
5744 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression"));
5745 }
5746 _res = NULL;
5747 done:
5748 p->level--;
5749 return _res;
5750 }
5751
5752 // star_annotation: ':' star_expression
5753 static expr_ty
5754 star_annotation_rule(Parser *p)
5755 {
5756 if (p->level++ == MAXSTACK) {
5757 _Pypegen_stack_overflow(p);
5758 }
5759 if (p->error_indicator) {
5760 p->level--;
5761 return NULL;
5762 }
5763 expr_ty _res = NULL;
5764 int _mark = p->mark;
5765 { // ':' star_expression
5766 if (p->error_indicator) {
5767 p->level--;
5768 return NULL;
5769 }
5770 D(fprintf(stderr, "%*c> star_annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' star_expression"));
5771 Token * _literal;
5772 expr_ty a;
5773 if (
5774 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5775 &&
5776 (a = star_expression_rule(p)) // star_expression
5777 )
5778 {
5779 D(fprintf(stderr, "%*c+ star_annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' star_expression"));
5780 _res = a;
5781 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5782 p->error_indicator = 1;
5783 p->level--;
5784 return NULL;
5785 }
5786 goto done;
5787 }
5788 p->mark = _mark;
5789 D(fprintf(stderr, "%*c%s star_annotation[%d-%d]: %s failed!\n", p->level, ' ',
5790 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' star_expression"));
5791 }
5792 _res = NULL;
5793 done:
5794 p->level--;
5795 return _res;
5796 }
5797
5798 // default: '=' expression | invalid_default
5799 static expr_ty
5800 default_rule(Parser *p)
5801 {
5802 if (p->level++ == MAXSTACK) {
5803 _Pypegen_stack_overflow(p);
5804 }
5805 if (p->error_indicator) {
5806 p->level--;
5807 return NULL;
5808 }
5809 expr_ty _res = NULL;
5810 int _mark = p->mark;
5811 { // '=' expression
5812 if (p->error_indicator) {
5813 p->level--;
5814 return NULL;
5815 }
5816 D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression"));
5817 Token * _literal;
5818 expr_ty a;
5819 if (
5820 (_literal = _PyPegen_expect_token(p, 22)) // token='='
5821 &&
5822 (a = expression_rule(p)) // expression
5823 )
5824 {
5825 D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expression"));
5826 _res = a;
5827 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5828 p->error_indicator = 1;
5829 p->level--;
5830 return NULL;
5831 }
5832 goto done;
5833 }
5834 p->mark = _mark;
5835 D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ',
5836 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' expression"));
5837 }
5838 if (p->call_invalid_rules) { // invalid_default
5839 if (p->error_indicator) {
5840 p->level--;
5841 return NULL;
5842 }
5843 D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_default"));
5844 void *invalid_default_var;
5845 if (
5846 (invalid_default_var = invalid_default_rule(p)) // invalid_default
5847 )
5848 {
5849 D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_default"));
5850 _res = invalid_default_var;
5851 goto done;
5852 }
5853 p->mark = _mark;
5854 D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ',
5855 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_default"));
5856 }
5857 _res = NULL;
5858 done:
5859 p->level--;
5860 return _res;
5861 }
5862
5863 // if_stmt:
5864 // | invalid_if_stmt
5865 // | 'if' named_expression ':' block elif_stmt
5866 // | 'if' named_expression ':' block else_block?
5867 static stmt_ty
5868 if_stmt_rule(Parser *p)
5869 {
5870 if (p->level++ == MAXSTACK) {
5871 _Pypegen_stack_overflow(p);
5872 }
5873 if (p->error_indicator) {
5874 p->level--;
5875 return NULL;
5876 }
5877 stmt_ty _res = NULL;
5878 int _mark = p->mark;
5879 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
5880 p->error_indicator = 1;
5881 p->level--;
5882 return NULL;
5883 }
5884 int _start_lineno = p->tokens[_mark]->lineno;
5885 UNUSED(_start_lineno); // Only used by EXTRA macro
5886 int _start_col_offset = p->tokens[_mark]->col_offset;
5887 UNUSED(_start_col_offset); // Only used by EXTRA macro
5888 if (p->call_invalid_rules) { // invalid_if_stmt
5889 if (p->error_indicator) {
5890 p->level--;
5891 return NULL;
5892 }
5893 D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_if_stmt"));
5894 void *invalid_if_stmt_var;
5895 if (
5896 (invalid_if_stmt_var = invalid_if_stmt_rule(p)) // invalid_if_stmt
5897 )
5898 {
5899 D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_if_stmt"));
5900 _res = invalid_if_stmt_var;
5901 goto done;
5902 }
5903 p->mark = _mark;
5904 D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ',
5905 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_if_stmt"));
5906 }
5907 { // 'if' named_expression ':' block elif_stmt
5908 if (p->error_indicator) {
5909 p->level--;
5910 return NULL;
5911 }
5912 D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
5913 Token * _keyword;
5914 Token * _literal;
5915 expr_ty a;
5916 asdl_stmt_seq* b;
5917 stmt_ty c;
5918 if (
5919 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
5920 &&
5921 (a = named_expression_rule(p)) // named_expression
5922 &&
5923 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5924 &&
5925 (b = block_rule(p)) // block
5926 &&
5927 (c = elif_stmt_rule(p)) // elif_stmt
5928 )
5929 {
5930 D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
5931 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5932 if (_token == NULL) {
5933 p->level--;
5934 return NULL;
5935 }
5936 int _end_lineno = _token->end_lineno;
5937 UNUSED(_end_lineno); // Only used by EXTRA macro
5938 int _end_col_offset = _token->end_col_offset;
5939 UNUSED(_end_col_offset); // Only used by EXTRA macro
5940 _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
5941 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5942 p->error_indicator = 1;
5943 p->level--;
5944 return NULL;
5945 }
5946 goto done;
5947 }
5948 p->mark = _mark;
5949 D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ',
5950 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
5951 }
5952 { // 'if' named_expression ':' block else_block?
5953 if (p->error_indicator) {
5954 p->level--;
5955 return NULL;
5956 }
5957 D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?"));
5958 Token * _keyword;
5959 Token * _literal;
5960 expr_ty a;
5961 asdl_stmt_seq* b;
5962 void *c;
5963 if (
5964 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
5965 &&
5966 (a = named_expression_rule(p)) // named_expression
5967 &&
5968 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
5969 &&
5970 (b = block_rule(p)) // block
5971 &&
5972 (c = else_block_rule(p), !p->error_indicator) // else_block?
5973 )
5974 {
5975 D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?"));
5976 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
5977 if (_token == NULL) {
5978 p->level--;
5979 return NULL;
5980 }
5981 int _end_lineno = _token->end_lineno;
5982 UNUSED(_end_lineno); // Only used by EXTRA macro
5983 int _end_col_offset = _token->end_col_offset;
5984 UNUSED(_end_col_offset); // Only used by EXTRA macro
5985 _res = _PyAST_If ( a , b , c , EXTRA );
5986 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
5987 p->error_indicator = 1;
5988 p->level--;
5989 return NULL;
5990 }
5991 goto done;
5992 }
5993 p->mark = _mark;
5994 D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ',
5995 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block else_block?"));
5996 }
5997 _res = NULL;
5998 done:
5999 p->level--;
6000 return _res;
6001 }
6002
6003 // elif_stmt:
6004 // | invalid_elif_stmt
6005 // | 'elif' named_expression ':' block elif_stmt
6006 // | 'elif' named_expression ':' block else_block?
6007 static stmt_ty
6008 elif_stmt_rule(Parser *p)
6009 {
6010 if (p->level++ == MAXSTACK) {
6011 _Pypegen_stack_overflow(p);
6012 }
6013 if (p->error_indicator) {
6014 p->level--;
6015 return NULL;
6016 }
6017 stmt_ty _res = NULL;
6018 int _mark = p->mark;
6019 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6020 p->error_indicator = 1;
6021 p->level--;
6022 return NULL;
6023 }
6024 int _start_lineno = p->tokens[_mark]->lineno;
6025 UNUSED(_start_lineno); // Only used by EXTRA macro
6026 int _start_col_offset = p->tokens[_mark]->col_offset;
6027 UNUSED(_start_col_offset); // Only used by EXTRA macro
6028 if (p->call_invalid_rules) { // invalid_elif_stmt
6029 if (p->error_indicator) {
6030 p->level--;
6031 return NULL;
6032 }
6033 D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_elif_stmt"));
6034 void *invalid_elif_stmt_var;
6035 if (
6036 (invalid_elif_stmt_var = invalid_elif_stmt_rule(p)) // invalid_elif_stmt
6037 )
6038 {
6039 D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_elif_stmt"));
6040 _res = invalid_elif_stmt_var;
6041 goto done;
6042 }
6043 p->mark = _mark;
6044 D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6045 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_elif_stmt"));
6046 }
6047 { // 'elif' named_expression ':' block elif_stmt
6048 if (p->error_indicator) {
6049 p->level--;
6050 return NULL;
6051 }
6052 D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
6053 Token * _keyword;
6054 Token * _literal;
6055 expr_ty a;
6056 asdl_stmt_seq* b;
6057 stmt_ty c;
6058 if (
6059 (_keyword = _PyPegen_expect_token(p, 662)) // token='elif'
6060 &&
6061 (a = named_expression_rule(p)) // named_expression
6062 &&
6063 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6064 &&
6065 (b = block_rule(p)) // block
6066 &&
6067 (c = elif_stmt_rule(p)) // elif_stmt
6068 )
6069 {
6070 D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
6071 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6072 if (_token == NULL) {
6073 p->level--;
6074 return NULL;
6075 }
6076 int _end_lineno = _token->end_lineno;
6077 UNUSED(_end_lineno); // Only used by EXTRA macro
6078 int _end_col_offset = _token->end_col_offset;
6079 UNUSED(_end_col_offset); // Only used by EXTRA macro
6080 _res = _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
6081 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6082 p->error_indicator = 1;
6083 p->level--;
6084 return NULL;
6085 }
6086 goto done;
6087 }
6088 p->mark = _mark;
6089 D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6090 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
6091 }
6092 { // 'elif' named_expression ':' block else_block?
6093 if (p->error_indicator) {
6094 p->level--;
6095 return NULL;
6096 }
6097 D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?"));
6098 Token * _keyword;
6099 Token * _literal;
6100 expr_ty a;
6101 asdl_stmt_seq* b;
6102 void *c;
6103 if (
6104 (_keyword = _PyPegen_expect_token(p, 662)) // token='elif'
6105 &&
6106 (a = named_expression_rule(p)) // named_expression
6107 &&
6108 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6109 &&
6110 (b = block_rule(p)) // block
6111 &&
6112 (c = else_block_rule(p), !p->error_indicator) // else_block?
6113 )
6114 {
6115 D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?"));
6116 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6117 if (_token == NULL) {
6118 p->level--;
6119 return NULL;
6120 }
6121 int _end_lineno = _token->end_lineno;
6122 UNUSED(_end_lineno); // Only used by EXTRA macro
6123 int _end_col_offset = _token->end_col_offset;
6124 UNUSED(_end_col_offset); // Only used by EXTRA macro
6125 _res = _PyAST_If ( a , b , c , EXTRA );
6126 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6127 p->error_indicator = 1;
6128 p->level--;
6129 return NULL;
6130 }
6131 goto done;
6132 }
6133 p->mark = _mark;
6134 D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6135 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block else_block?"));
6136 }
6137 _res = NULL;
6138 done:
6139 p->level--;
6140 return _res;
6141 }
6142
6143 // else_block: invalid_else_stmt | 'else' &&':' block
6144 static asdl_stmt_seq*
6145 else_block_rule(Parser *p)
6146 {
6147 if (p->level++ == MAXSTACK) {
6148 _Pypegen_stack_overflow(p);
6149 }
6150 if (p->error_indicator) {
6151 p->level--;
6152 return NULL;
6153 }
6154 asdl_stmt_seq* _res = NULL;
6155 int _mark = p->mark;
6156 if (p->call_invalid_rules) { // invalid_else_stmt
6157 if (p->error_indicator) {
6158 p->level--;
6159 return NULL;
6160 }
6161 D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_else_stmt"));
6162 void *invalid_else_stmt_var;
6163 if (
6164 (invalid_else_stmt_var = invalid_else_stmt_rule(p)) // invalid_else_stmt
6165 )
6166 {
6167 D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_else_stmt"));
6168 _res = invalid_else_stmt_var;
6169 goto done;
6170 }
6171 p->mark = _mark;
6172 D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ',
6173 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_else_stmt"));
6174 }
6175 { // 'else' &&':' block
6176 if (p->error_indicator) {
6177 p->level--;
6178 return NULL;
6179 }
6180 D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' &&':' block"));
6181 Token * _keyword;
6182 Token * _literal;
6183 asdl_stmt_seq* b;
6184 if (
6185 (_keyword = _PyPegen_expect_token(p, 663)) // token='else'
6186 &&
6187 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6188 &&
6189 (b = block_rule(p)) // block
6190 )
6191 {
6192 D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' &&':' block"));
6193 _res = b;
6194 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6195 p->error_indicator = 1;
6196 p->level--;
6197 return NULL;
6198 }
6199 goto done;
6200 }
6201 p->mark = _mark;
6202 D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ',
6203 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' &&':' block"));
6204 }
6205 _res = NULL;
6206 done:
6207 p->level--;
6208 return _res;
6209 }
6210
6211 // while_stmt: invalid_while_stmt | 'while' named_expression ':' block else_block?
6212 static stmt_ty
6213 while_stmt_rule(Parser *p)
6214 {
6215 if (p->level++ == MAXSTACK) {
6216 _Pypegen_stack_overflow(p);
6217 }
6218 if (p->error_indicator) {
6219 p->level--;
6220 return NULL;
6221 }
6222 stmt_ty _res = NULL;
6223 int _mark = p->mark;
6224 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6225 p->error_indicator = 1;
6226 p->level--;
6227 return NULL;
6228 }
6229 int _start_lineno = p->tokens[_mark]->lineno;
6230 UNUSED(_start_lineno); // Only used by EXTRA macro
6231 int _start_col_offset = p->tokens[_mark]->col_offset;
6232 UNUSED(_start_col_offset); // Only used by EXTRA macro
6233 if (p->call_invalid_rules) { // invalid_while_stmt
6234 if (p->error_indicator) {
6235 p->level--;
6236 return NULL;
6237 }
6238 D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_while_stmt"));
6239 void *invalid_while_stmt_var;
6240 if (
6241 (invalid_while_stmt_var = invalid_while_stmt_rule(p)) // invalid_while_stmt
6242 )
6243 {
6244 D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_while_stmt"));
6245 _res = invalid_while_stmt_var;
6246 goto done;
6247 }
6248 p->mark = _mark;
6249 D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6250 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_while_stmt"));
6251 }
6252 { // 'while' named_expression ':' block else_block?
6253 if (p->error_indicator) {
6254 p->level--;
6255 return NULL;
6256 }
6257 D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?"));
6258 Token * _keyword;
6259 Token * _literal;
6260 expr_ty a;
6261 asdl_stmt_seq* b;
6262 void *c;
6263 if (
6264 (_keyword = _PyPegen_expect_token(p, 665)) // token='while'
6265 &&
6266 (a = named_expression_rule(p)) // named_expression
6267 &&
6268 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6269 &&
6270 (b = block_rule(p)) // block
6271 &&
6272 (c = else_block_rule(p), !p->error_indicator) // else_block?
6273 )
6274 {
6275 D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?"));
6276 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6277 if (_token == NULL) {
6278 p->level--;
6279 return NULL;
6280 }
6281 int _end_lineno = _token->end_lineno;
6282 UNUSED(_end_lineno); // Only used by EXTRA macro
6283 int _end_col_offset = _token->end_col_offset;
6284 UNUSED(_end_col_offset); // Only used by EXTRA macro
6285 _res = _PyAST_While ( a , b , c , EXTRA );
6286 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6287 p->error_indicator = 1;
6288 p->level--;
6289 return NULL;
6290 }
6291 goto done;
6292 }
6293 p->mark = _mark;
6294 D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6295 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' block else_block?"));
6296 }
6297 _res = NULL;
6298 done:
6299 p->level--;
6300 return _res;
6301 }
6302
6303 // for_stmt:
6304 // | invalid_for_stmt
6305 // | 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
6306 // | 'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
6307 // | invalid_for_target
6308 static stmt_ty
6309 for_stmt_rule(Parser *p)
6310 {
6311 if (p->level++ == MAXSTACK) {
6312 _Pypegen_stack_overflow(p);
6313 }
6314 if (p->error_indicator) {
6315 p->level--;
6316 return NULL;
6317 }
6318 stmt_ty _res = NULL;
6319 int _mark = p->mark;
6320 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6321 p->error_indicator = 1;
6322 p->level--;
6323 return NULL;
6324 }
6325 int _start_lineno = p->tokens[_mark]->lineno;
6326 UNUSED(_start_lineno); // Only used by EXTRA macro
6327 int _start_col_offset = p->tokens[_mark]->col_offset;
6328 UNUSED(_start_col_offset); // Only used by EXTRA macro
6329 if (p->call_invalid_rules) { // invalid_for_stmt
6330 if (p->error_indicator) {
6331 p->level--;
6332 return NULL;
6333 }
6334 D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_stmt"));
6335 void *invalid_for_stmt_var;
6336 if (
6337 (invalid_for_stmt_var = invalid_for_stmt_rule(p)) // invalid_for_stmt
6338 )
6339 {
6340 D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_stmt"));
6341 _res = invalid_for_stmt_var;
6342 goto done;
6343 }
6344 p->mark = _mark;
6345 D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6346 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_stmt"));
6347 }
6348 { // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
6349 if (p->error_indicator) {
6350 p->level--;
6351 return NULL;
6352 }
6353 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?"));
6354 int _cut_var = 0;
6355 Token * _keyword;
6356 Token * _keyword_1;
6357 Token * _literal;
6358 asdl_stmt_seq* b;
6359 void *el;
6360 expr_ty ex;
6361 expr_ty t;
6362 void *tc;
6363 if (
6364 (_keyword = _PyPegen_expect_token(p, 670)) // token='for'
6365 &&
6366 (t = star_targets_rule(p)) // star_targets
6367 &&
6368 (_keyword_1 = _PyPegen_expect_token(p, 671)) // token='in'
6369 &&
6370 (_cut_var = 1)
6371 &&
6372 (ex = star_expressions_rule(p)) // star_expressions
6373 &&
6374 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6375 &&
6376 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6377 &&
6378 (b = block_rule(p)) // block
6379 &&
6380 (el = else_block_rule(p), !p->error_indicator) // else_block?
6381 )
6382 {
6383 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?"));
6384 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6385 if (_token == NULL) {
6386 p->level--;
6387 return NULL;
6388 }
6389 int _end_lineno = _token->end_lineno;
6390 UNUSED(_end_lineno); // Only used by EXTRA macro
6391 int _end_col_offset = _token->end_col_offset;
6392 UNUSED(_end_col_offset); // Only used by EXTRA macro
6393 _res = _PyAST_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
6394 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6395 p->error_indicator = 1;
6396 p->level--;
6397 return NULL;
6398 }
6399 goto done;
6400 }
6401 p->mark = _mark;
6402 D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6403 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
6404 if (_cut_var) {
6405 p->level--;
6406 return NULL;
6407 }
6408 }
6409 { // 'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
6410 if (p->error_indicator) {
6411 p->level--;
6412 return NULL;
6413 }
6414 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?"));
6415 int _cut_var = 0;
6416 Token * _keyword;
6417 Token * _keyword_1;
6418 Token * _keyword_2;
6419 Token * _literal;
6420 asdl_stmt_seq* b;
6421 void *el;
6422 expr_ty ex;
6423 expr_ty t;
6424 void *tc;
6425 if (
6426 (_keyword = _PyPegen_expect_token(p, 674)) // token='async'
6427 &&
6428 (_keyword_1 = _PyPegen_expect_token(p, 670)) // token='for'
6429 &&
6430 (t = star_targets_rule(p)) // star_targets
6431 &&
6432 (_keyword_2 = _PyPegen_expect_token(p, 671)) // token='in'
6433 &&
6434 (_cut_var = 1)
6435 &&
6436 (ex = star_expressions_rule(p)) // star_expressions
6437 &&
6438 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6439 &&
6440 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6441 &&
6442 (b = block_rule(p)) // block
6443 &&
6444 (el = else_block_rule(p), !p->error_indicator) // else_block?
6445 )
6446 {
6447 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?"));
6448 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6449 if (_token == NULL) {
6450 p->level--;
6451 return NULL;
6452 }
6453 int _end_lineno = _token->end_lineno;
6454 UNUSED(_end_lineno); // Only used by EXTRA macro
6455 int _end_col_offset = _token->end_col_offset;
6456 UNUSED(_end_col_offset); // Only used by EXTRA macro
6457 _res = CHECK_VERSION ( stmt_ty , 5 , "Async for loops are" , _PyAST_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
6458 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6459 p->error_indicator = 1;
6460 p->level--;
6461 return NULL;
6462 }
6463 goto done;
6464 }
6465 p->mark = _mark;
6466 D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6467 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
6468 if (_cut_var) {
6469 p->level--;
6470 return NULL;
6471 }
6472 }
6473 if (p->call_invalid_rules) { // invalid_for_target
6474 if (p->error_indicator) {
6475 p->level--;
6476 return NULL;
6477 }
6478 D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
6479 void *invalid_for_target_var;
6480 if (
6481 (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target
6482 )
6483 {
6484 D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
6485 _res = invalid_for_target_var;
6486 goto done;
6487 }
6488 p->mark = _mark;
6489 D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6490 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target"));
6491 }
6492 _res = NULL;
6493 done:
6494 p->level--;
6495 return _res;
6496 }
6497
6498 // with_stmt:
6499 // | invalid_with_stmt_indent
6500 // | 'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block
6501 // | 'with' ','.with_item+ ':' TYPE_COMMENT? block
6502 // | 'async' 'with' '(' ','.with_item+ ','? ')' ':' block
6503 // | 'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block
6504 // | invalid_with_stmt
6505 static stmt_ty
6506 with_stmt_rule(Parser *p)
6507 {
6508 if (p->level++ == MAXSTACK) {
6509 _Pypegen_stack_overflow(p);
6510 }
6511 if (p->error_indicator) {
6512 p->level--;
6513 return NULL;
6514 }
6515 stmt_ty _res = NULL;
6516 int _mark = p->mark;
6517 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6518 p->error_indicator = 1;
6519 p->level--;
6520 return NULL;
6521 }
6522 int _start_lineno = p->tokens[_mark]->lineno;
6523 UNUSED(_start_lineno); // Only used by EXTRA macro
6524 int _start_col_offset = p->tokens[_mark]->col_offset;
6525 UNUSED(_start_col_offset); // Only used by EXTRA macro
6526 if (p->call_invalid_rules) { // invalid_with_stmt_indent
6527 if (p->error_indicator) {
6528 p->level--;
6529 return NULL;
6530 }
6531 D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt_indent"));
6532 void *invalid_with_stmt_indent_var;
6533 if (
6534 (invalid_with_stmt_indent_var = invalid_with_stmt_indent_rule(p)) // invalid_with_stmt_indent
6535 )
6536 {
6537 D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt_indent"));
6538 _res = invalid_with_stmt_indent_var;
6539 goto done;
6540 }
6541 p->mark = _mark;
6542 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6543 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt_indent"));
6544 }
6545 { // 'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block
6546 if (p->error_indicator) {
6547 p->level--;
6548 return NULL;
6549 }
6550 D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block"));
6551 Token * _keyword;
6552 Token * _literal;
6553 Token * _literal_1;
6554 Token * _literal_2;
6555 void *_opt_var;
6556 UNUSED(_opt_var); // Silence compiler warnings
6557 asdl_withitem_seq* a;
6558 asdl_stmt_seq* b;
6559 void *tc;
6560 if (
6561 (_keyword = _PyPegen_expect_token(p, 633)) // token='with'
6562 &&
6563 (_literal = _PyPegen_expect_token(p, 7)) // token='('
6564 &&
6565 (a = (asdl_withitem_seq*)_gather_51_rule(p)) // ','.with_item+
6566 &&
6567 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
6568 &&
6569 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
6570 &&
6571 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
6572 &&
6573 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6574 &&
6575 (b = block_rule(p)) // block
6576 )
6577 {
6578 D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block"));
6579 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6580 if (_token == NULL) {
6581 p->level--;
6582 return NULL;
6583 }
6584 int _end_lineno = _token->end_lineno;
6585 UNUSED(_end_lineno); // Only used by EXTRA macro
6586 int _end_col_offset = _token->end_col_offset;
6587 UNUSED(_end_col_offset); // Only used by EXTRA macro
6588 _res = _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
6589 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6590 p->error_indicator = 1;
6591 p->level--;
6592 return NULL;
6593 }
6594 goto done;
6595 }
6596 p->mark = _mark;
6597 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6598 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block"));
6599 }
6600 { // 'with' ','.with_item+ ':' TYPE_COMMENT? block
6601 if (p->error_indicator) {
6602 p->level--;
6603 return NULL;
6604 }
6605 D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
6606 Token * _keyword;
6607 Token * _literal;
6608 asdl_withitem_seq* a;
6609 asdl_stmt_seq* b;
6610 void *tc;
6611 if (
6612 (_keyword = _PyPegen_expect_token(p, 633)) // token='with'
6613 &&
6614 (a = (asdl_withitem_seq*)_gather_53_rule(p)) // ','.with_item+
6615 &&
6616 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6617 &&
6618 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6619 &&
6620 (b = block_rule(p)) // block
6621 )
6622 {
6623 D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
6624 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6625 if (_token == NULL) {
6626 p->level--;
6627 return NULL;
6628 }
6629 int _end_lineno = _token->end_lineno;
6630 UNUSED(_end_lineno); // Only used by EXTRA macro
6631 int _end_col_offset = _token->end_col_offset;
6632 UNUSED(_end_col_offset); // Only used by EXTRA macro
6633 _res = _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
6634 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6635 p->error_indicator = 1;
6636 p->level--;
6637 return NULL;
6638 }
6639 goto done;
6640 }
6641 p->mark = _mark;
6642 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6643 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
6644 }
6645 { // 'async' 'with' '(' ','.with_item+ ','? ')' ':' block
6646 if (p->error_indicator) {
6647 p->level--;
6648 return NULL;
6649 }
6650 D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async' 'with' '(' ','.with_item+ ','? ')' ':' block"));
6651 Token * _keyword;
6652 Token * _keyword_1;
6653 Token * _literal;
6654 Token * _literal_1;
6655 Token * _literal_2;
6656 void *_opt_var;
6657 UNUSED(_opt_var); // Silence compiler warnings
6658 asdl_withitem_seq* a;
6659 asdl_stmt_seq* b;
6660 if (
6661 (_keyword = _PyPegen_expect_token(p, 674)) // token='async'
6662 &&
6663 (_keyword_1 = _PyPegen_expect_token(p, 633)) // token='with'
6664 &&
6665 (_literal = _PyPegen_expect_token(p, 7)) // token='('
6666 &&
6667 (a = (asdl_withitem_seq*)_gather_55_rule(p)) // ','.with_item+
6668 &&
6669 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
6670 &&
6671 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
6672 &&
6673 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
6674 &&
6675 (b = block_rule(p)) // block
6676 )
6677 {
6678 D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async' 'with' '(' ','.with_item+ ','? ')' ':' block"));
6679 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6680 if (_token == NULL) {
6681 p->level--;
6682 return NULL;
6683 }
6684 int _end_lineno = _token->end_lineno;
6685 UNUSED(_end_lineno); // Only used by EXTRA macro
6686 int _end_col_offset = _token->end_col_offset;
6687 UNUSED(_end_col_offset); // Only used by EXTRA macro
6688 _res = CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NULL , EXTRA ) );
6689 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6690 p->error_indicator = 1;
6691 p->level--;
6692 return NULL;
6693 }
6694 goto done;
6695 }
6696 p->mark = _mark;
6697 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6698 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'with' '(' ','.with_item+ ','? ')' ':' block"));
6699 }
6700 { // 'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block
6701 if (p->error_indicator) {
6702 p->level--;
6703 return NULL;
6704 }
6705 D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block"));
6706 Token * _keyword;
6707 Token * _keyword_1;
6708 Token * _literal;
6709 asdl_withitem_seq* a;
6710 asdl_stmt_seq* b;
6711 void *tc;
6712 if (
6713 (_keyword = _PyPegen_expect_token(p, 674)) // token='async'
6714 &&
6715 (_keyword_1 = _PyPegen_expect_token(p, 633)) // token='with'
6716 &&
6717 (a = (asdl_withitem_seq*)_gather_57_rule(p)) // ','.with_item+
6718 &&
6719 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
6720 &&
6721 (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator) // TYPE_COMMENT?
6722 &&
6723 (b = block_rule(p)) // block
6724 )
6725 {
6726 D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block"));
6727 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6728 if (_token == NULL) {
6729 p->level--;
6730 return NULL;
6731 }
6732 int _end_lineno = _token->end_lineno;
6733 UNUSED(_end_lineno); // Only used by EXTRA macro
6734 int _end_col_offset = _token->end_col_offset;
6735 UNUSED(_end_col_offset); // Only used by EXTRA macro
6736 _res = CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
6737 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6738 p->error_indicator = 1;
6739 p->level--;
6740 return NULL;
6741 }
6742 goto done;
6743 }
6744 p->mark = _mark;
6745 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6746 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block"));
6747 }
6748 if (p->call_invalid_rules) { // invalid_with_stmt
6749 if (p->error_indicator) {
6750 p->level--;
6751 return NULL;
6752 }
6753 D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt"));
6754 void *invalid_with_stmt_var;
6755 if (
6756 (invalid_with_stmt_var = invalid_with_stmt_rule(p)) // invalid_with_stmt
6757 )
6758 {
6759 D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_stmt"));
6760 _res = invalid_with_stmt_var;
6761 goto done;
6762 }
6763 p->mark = _mark;
6764 D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6765 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt"));
6766 }
6767 _res = NULL;
6768 done:
6769 p->level--;
6770 return _res;
6771 }
6772
6773 // with_item:
6774 // | expression 'as' star_target &(',' | ')' | ':')
6775 // | invalid_with_item
6776 // | expression
6777 static withitem_ty
6778 with_item_rule(Parser *p)
6779 {
6780 if (p->level++ == MAXSTACK) {
6781 _Pypegen_stack_overflow(p);
6782 }
6783 if (p->error_indicator) {
6784 p->level--;
6785 return NULL;
6786 }
6787 withitem_ty _res = NULL;
6788 int _mark = p->mark;
6789 { // expression 'as' star_target &(',' | ')' | ':')
6790 if (p->error_indicator) {
6791 p->level--;
6792 return NULL;
6793 }
6794 D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
6795 Token * _keyword;
6796 expr_ty e;
6797 expr_ty t;
6798 if (
6799 (e = expression_rule(p)) // expression
6800 &&
6801 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
6802 &&
6803 (t = star_target_rule(p)) // star_target
6804 &&
6805 _PyPegen_lookahead(1, _tmp_59_rule, p)
6806 )
6807 {
6808 D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
6809 _res = _PyAST_withitem ( e , t , p -> arena );
6810 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6811 p->error_indicator = 1;
6812 p->level--;
6813 return NULL;
6814 }
6815 goto done;
6816 }
6817 p->mark = _mark;
6818 D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',
6819 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
6820 }
6821 if (p->call_invalid_rules) { // invalid_with_item
6822 if (p->error_indicator) {
6823 p->level--;
6824 return NULL;
6825 }
6826 D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_item"));
6827 void *invalid_with_item_var;
6828 if (
6829 (invalid_with_item_var = invalid_with_item_rule(p)) // invalid_with_item
6830 )
6831 {
6832 D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_item"));
6833 _res = invalid_with_item_var;
6834 goto done;
6835 }
6836 p->mark = _mark;
6837 D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',
6838 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_item"));
6839 }
6840 { // expression
6841 if (p->error_indicator) {
6842 p->level--;
6843 return NULL;
6844 }
6845 D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
6846 expr_ty e;
6847 if (
6848 (e = expression_rule(p)) // expression
6849 )
6850 {
6851 D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
6852 _res = _PyAST_withitem ( e , NULL , p -> arena );
6853 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6854 p->error_indicator = 1;
6855 p->level--;
6856 return NULL;
6857 }
6858 goto done;
6859 }
6860 p->mark = _mark;
6861 D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',
6862 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
6863 }
6864 _res = NULL;
6865 done:
6866 p->level--;
6867 return _res;
6868 }
6869
6870 // try_stmt:
6871 // | invalid_try_stmt
6872 // | 'try' &&':' block finally_block
6873 // | 'try' &&':' block except_block+ else_block? finally_block?
6874 // | 'try' &&':' block except_star_block+ else_block? finally_block?
6875 static stmt_ty
6876 try_stmt_rule(Parser *p)
6877 {
6878 if (p->level++ == MAXSTACK) {
6879 _Pypegen_stack_overflow(p);
6880 }
6881 if (p->error_indicator) {
6882 p->level--;
6883 return NULL;
6884 }
6885 stmt_ty _res = NULL;
6886 int _mark = p->mark;
6887 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
6888 p->error_indicator = 1;
6889 p->level--;
6890 return NULL;
6891 }
6892 int _start_lineno = p->tokens[_mark]->lineno;
6893 UNUSED(_start_lineno); // Only used by EXTRA macro
6894 int _start_col_offset = p->tokens[_mark]->col_offset;
6895 UNUSED(_start_col_offset); // Only used by EXTRA macro
6896 if (p->call_invalid_rules) { // invalid_try_stmt
6897 if (p->error_indicator) {
6898 p->level--;
6899 return NULL;
6900 }
6901 D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_try_stmt"));
6902 void *invalid_try_stmt_var;
6903 if (
6904 (invalid_try_stmt_var = invalid_try_stmt_rule(p)) // invalid_try_stmt
6905 )
6906 {
6907 D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_try_stmt"));
6908 _res = invalid_try_stmt_var;
6909 goto done;
6910 }
6911 p->mark = _mark;
6912 D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6913 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_try_stmt"));
6914 }
6915 { // 'try' &&':' block finally_block
6916 if (p->error_indicator) {
6917 p->level--;
6918 return NULL;
6919 }
6920 D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block finally_block"));
6921 Token * _keyword;
6922 Token * _literal;
6923 asdl_stmt_seq* b;
6924 asdl_stmt_seq* f;
6925 if (
6926 (_keyword = _PyPegen_expect_token(p, 642)) // token='try'
6927 &&
6928 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6929 &&
6930 (b = block_rule(p)) // block
6931 &&
6932 (f = finally_block_rule(p)) // finally_block
6933 )
6934 {
6935 D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &&':' block finally_block"));
6936 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6937 if (_token == NULL) {
6938 p->level--;
6939 return NULL;
6940 }
6941 int _end_lineno = _token->end_lineno;
6942 UNUSED(_end_lineno); // Only used by EXTRA macro
6943 int _end_col_offset = _token->end_col_offset;
6944 UNUSED(_end_col_offset); // Only used by EXTRA macro
6945 _res = _PyAST_Try ( b , NULL , NULL , f , EXTRA );
6946 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6947 p->error_indicator = 1;
6948 p->level--;
6949 return NULL;
6950 }
6951 goto done;
6952 }
6953 p->mark = _mark;
6954 D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
6955 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block finally_block"));
6956 }
6957 { // 'try' &&':' block except_block+ else_block? finally_block?
6958 if (p->error_indicator) {
6959 p->level--;
6960 return NULL;
6961 }
6962 D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block except_block+ else_block? finally_block?"));
6963 Token * _keyword;
6964 Token * _literal;
6965 asdl_stmt_seq* b;
6966 void *el;
6967 asdl_excepthandler_seq* ex;
6968 void *f;
6969 if (
6970 (_keyword = _PyPegen_expect_token(p, 642)) // token='try'
6971 &&
6972 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
6973 &&
6974 (b = block_rule(p)) // block
6975 &&
6976 (ex = (asdl_excepthandler_seq*)_loop1_60_rule(p)) // except_block+
6977 &&
6978 (el = else_block_rule(p), !p->error_indicator) // else_block?
6979 &&
6980 (f = finally_block_rule(p), !p->error_indicator) // finally_block?
6981 )
6982 {
6983 D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' &&':' block except_block+ else_block? finally_block?"));
6984 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
6985 if (_token == NULL) {
6986 p->level--;
6987 return NULL;
6988 }
6989 int _end_lineno = _token->end_lineno;
6990 UNUSED(_end_lineno); // Only used by EXTRA macro
6991 int _end_col_offset = _token->end_col_offset;
6992 UNUSED(_end_col_offset); // Only used by EXTRA macro
6993 _res = _PyAST_Try ( b , ex , el , f , EXTRA );
6994 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
6995 p->error_indicator = 1;
6996 p->level--;
6997 return NULL;
6998 }
6999 goto done;
7000 }
7001 p->mark = _mark;
7002 D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
7003 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block except_block+ else_block? finally_block?"));
7004 }
7005 { // 'try' &&':' block except_star_block+ else_block? finally_block?
7006 if (p->error_indicator) {
7007 p->level--;
7008 return NULL;
7009 }
7010 D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' &&':' block except_star_block+ else_block? finally_block?"));
7011 Token * _keyword;
7012 Token * _literal;
7013 asdl_stmt_seq* b;
7014 void *el;
7015 asdl_excepthandler_seq* ex;
7016 void *f;
7017 if (
7018 (_keyword = _PyPegen_expect_token(p, 642)) // token='try'
7019 &&
7020 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
7021 &&
7022 (b = block_rule(p)) // block
7023 &&
7024 (ex = (asdl_excepthandler_seq*)_loop1_61_rule(p)) // except_star_block+
7025 &&
7026 (el = else_block_rule(p), !p->error_indicator) // else_block?
7027 &&
7028 (f = finally_block_rule(p), !p->error_indicator) // finally_block?
7029 )
7030 {
7031 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?"));
7032 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7033 if (_token == NULL) {
7034 p->level--;
7035 return NULL;
7036 }
7037 int _end_lineno = _token->end_lineno;
7038 UNUSED(_end_lineno); // Only used by EXTRA macro
7039 int _end_col_offset = _token->end_col_offset;
7040 UNUSED(_end_col_offset); // Only used by EXTRA macro
7041 _res = CHECK_VERSION ( stmt_ty , 11 , "Exception groups are" , _PyAST_TryStar ( b , ex , el , f , EXTRA ) );
7042 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7043 p->error_indicator = 1;
7044 p->level--;
7045 return NULL;
7046 }
7047 goto done;
7048 }
7049 p->mark = _mark;
7050 D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
7051 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' &&':' block except_star_block+ else_block? finally_block?"));
7052 }
7053 _res = NULL;
7054 done:
7055 p->level--;
7056 return _res;
7057 }
7058
7059 // except_block:
7060 // | invalid_except_stmt_indent
7061 // | 'except' expression ['as' NAME] ':' block
7062 // | 'except' ':' block
7063 // | invalid_except_stmt
7064 static excepthandler_ty
7065 except_block_rule(Parser *p)
7066 {
7067 if (p->level++ == MAXSTACK) {
7068 _Pypegen_stack_overflow(p);
7069 }
7070 if (p->error_indicator) {
7071 p->level--;
7072 return NULL;
7073 }
7074 excepthandler_ty _res = NULL;
7075 int _mark = p->mark;
7076 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7077 p->error_indicator = 1;
7078 p->level--;
7079 return NULL;
7080 }
7081 int _start_lineno = p->tokens[_mark]->lineno;
7082 UNUSED(_start_lineno); // Only used by EXTRA macro
7083 int _start_col_offset = p->tokens[_mark]->col_offset;
7084 UNUSED(_start_col_offset); // Only used by EXTRA macro
7085 if (p->call_invalid_rules) { // invalid_except_stmt_indent
7086 if (p->error_indicator) {
7087 p->level--;
7088 return NULL;
7089 }
7090 D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt_indent"));
7091 void *invalid_except_stmt_indent_var;
7092 if (
7093 (invalid_except_stmt_indent_var = invalid_except_stmt_indent_rule(p)) // invalid_except_stmt_indent
7094 )
7095 {
7096 D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt_indent"));
7097 _res = invalid_except_stmt_indent_var;
7098 goto done;
7099 }
7100 p->mark = _mark;
7101 D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',
7102 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt_indent"));
7103 }
7104 { // 'except' expression ['as' NAME] ':' block
7105 if (p->error_indicator) {
7106 p->level--;
7107 return NULL;
7108 }
7109 D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
7110 Token * _keyword;
7111 Token * _literal;
7112 asdl_stmt_seq* b;
7113 expr_ty e;
7114 void *t;
7115 if (
7116 (_keyword = _PyPegen_expect_token(p, 655)) // token='except'
7117 &&
7118 (e = expression_rule(p)) // expression
7119 &&
7120 (t = _tmp_62_rule(p), !p->error_indicator) // ['as' NAME]
7121 &&
7122 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7123 &&
7124 (b = block_rule(p)) // block
7125 )
7126 {
7127 D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
7128 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7129 if (_token == NULL) {
7130 p->level--;
7131 return NULL;
7132 }
7133 int _end_lineno = _token->end_lineno;
7134 UNUSED(_end_lineno); // Only used by EXTRA macro
7135 int _end_col_offset = _token->end_col_offset;
7136 UNUSED(_end_col_offset); // Only used by EXTRA macro
7137 _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
7138 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7139 p->error_indicator = 1;
7140 p->level--;
7141 return NULL;
7142 }
7143 goto done;
7144 }
7145 p->mark = _mark;
7146 D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',
7147 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
7148 }
7149 { // 'except' ':' block
7150 if (p->error_indicator) {
7151 p->level--;
7152 return NULL;
7153 }
7154 D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' block"));
7155 Token * _keyword;
7156 Token * _literal;
7157 asdl_stmt_seq* b;
7158 if (
7159 (_keyword = _PyPegen_expect_token(p, 655)) // token='except'
7160 &&
7161 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7162 &&
7163 (b = block_rule(p)) // block
7164 )
7165 {
7166 D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' block"));
7167 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7168 if (_token == NULL) {
7169 p->level--;
7170 return NULL;
7171 }
7172 int _end_lineno = _token->end_lineno;
7173 UNUSED(_end_lineno); // Only used by EXTRA macro
7174 int _end_col_offset = _token->end_col_offset;
7175 UNUSED(_end_col_offset); // Only used by EXTRA macro
7176 _res = _PyAST_ExceptHandler ( NULL , NULL , b , EXTRA );
7177 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7178 p->error_indicator = 1;
7179 p->level--;
7180 return NULL;
7181 }
7182 goto done;
7183 }
7184 p->mark = _mark;
7185 D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',
7186 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' block"));
7187 }
7188 if (p->call_invalid_rules) { // invalid_except_stmt
7189 if (p->error_indicator) {
7190 p->level--;
7191 return NULL;
7192 }
7193 D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt"));
7194 void *invalid_except_stmt_var;
7195 if (
7196 (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt
7197 )
7198 {
7199 D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt"));
7200 _res = invalid_except_stmt_var;
7201 goto done;
7202 }
7203 p->mark = _mark;
7204 D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',
7205 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt"));
7206 }
7207 _res = NULL;
7208 done:
7209 p->level--;
7210 return _res;
7211 }
7212
7213 // except_star_block:
7214 // | invalid_except_star_stmt_indent
7215 // | 'except' '*' expression ['as' NAME] ':' block
7216 // | invalid_except_stmt
7217 static excepthandler_ty
7218 except_star_block_rule(Parser *p)
7219 {
7220 if (p->level++ == MAXSTACK) {
7221 _Pypegen_stack_overflow(p);
7222 }
7223 if (p->error_indicator) {
7224 p->level--;
7225 return NULL;
7226 }
7227 excepthandler_ty _res = NULL;
7228 int _mark = p->mark;
7229 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7230 p->error_indicator = 1;
7231 p->level--;
7232 return NULL;
7233 }
7234 int _start_lineno = p->tokens[_mark]->lineno;
7235 UNUSED(_start_lineno); // Only used by EXTRA macro
7236 int _start_col_offset = p->tokens[_mark]->col_offset;
7237 UNUSED(_start_col_offset); // Only used by EXTRA macro
7238 if (p->call_invalid_rules) { // invalid_except_star_stmt_indent
7239 if (p->error_indicator) {
7240 p->level--;
7241 return NULL;
7242 }
7243 D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except_star_stmt_indent"));
7244 void *invalid_except_star_stmt_indent_var;
7245 if (
7246 (invalid_except_star_stmt_indent_var = invalid_except_star_stmt_indent_rule(p)) // invalid_except_star_stmt_indent
7247 )
7248 {
7249 D(fprintf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_star_stmt_indent"));
7250 _res = invalid_except_star_stmt_indent_var;
7251 goto done;
7252 }
7253 p->mark = _mark;
7254 D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ',
7255 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_star_stmt_indent"));
7256 }
7257 { // 'except' '*' expression ['as' NAME] ':' block
7258 if (p->error_indicator) {
7259 p->level--;
7260 return NULL;
7261 }
7262 D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*' expression ['as' NAME] ':' block"));
7263 Token * _keyword;
7264 Token * _literal;
7265 Token * _literal_1;
7266 asdl_stmt_seq* b;
7267 expr_ty e;
7268 void *t;
7269 if (
7270 (_keyword = _PyPegen_expect_token(p, 655)) // token='except'
7271 &&
7272 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
7273 &&
7274 (e = expression_rule(p)) // expression
7275 &&
7276 (t = _tmp_63_rule(p), !p->error_indicator) // ['as' NAME]
7277 &&
7278 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
7279 &&
7280 (b = block_rule(p)) // block
7281 )
7282 {
7283 D(fprintf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' expression ['as' NAME] ':' block"));
7284 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7285 if (_token == NULL) {
7286 p->level--;
7287 return NULL;
7288 }
7289 int _end_lineno = _token->end_lineno;
7290 UNUSED(_end_lineno); // Only used by EXTRA macro
7291 int _end_col_offset = _token->end_col_offset;
7292 UNUSED(_end_col_offset); // Only used by EXTRA macro
7293 _res = _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
7294 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7295 p->error_indicator = 1;
7296 p->level--;
7297 return NULL;
7298 }
7299 goto done;
7300 }
7301 p->mark = _mark;
7302 D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ',
7303 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' expression ['as' NAME] ':' block"));
7304 }
7305 if (p->call_invalid_rules) { // invalid_except_stmt
7306 if (p->error_indicator) {
7307 p->level--;
7308 return NULL;
7309 }
7310 D(fprintf(stderr, "%*c> except_star_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt"));
7311 void *invalid_except_stmt_var;
7312 if (
7313 (invalid_except_stmt_var = invalid_except_stmt_rule(p)) // invalid_except_stmt
7314 )
7315 {
7316 D(fprintf(stderr, "%*c+ except_star_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_except_stmt"));
7317 _res = invalid_except_stmt_var;
7318 goto done;
7319 }
7320 p->mark = _mark;
7321 D(fprintf(stderr, "%*c%s except_star_block[%d-%d]: %s failed!\n", p->level, ' ',
7322 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_except_stmt"));
7323 }
7324 _res = NULL;
7325 done:
7326 p->level--;
7327 return _res;
7328 }
7329
7330 // finally_block: invalid_finally_stmt | 'finally' &&':' block
7331 static asdl_stmt_seq*
7332 finally_block_rule(Parser *p)
7333 {
7334 if (p->level++ == MAXSTACK) {
7335 _Pypegen_stack_overflow(p);
7336 }
7337 if (p->error_indicator) {
7338 p->level--;
7339 return NULL;
7340 }
7341 asdl_stmt_seq* _res = NULL;
7342 int _mark = p->mark;
7343 if (p->call_invalid_rules) { // invalid_finally_stmt
7344 if (p->error_indicator) {
7345 p->level--;
7346 return NULL;
7347 }
7348 D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_finally_stmt"));
7349 void *invalid_finally_stmt_var;
7350 if (
7351 (invalid_finally_stmt_var = invalid_finally_stmt_rule(p)) // invalid_finally_stmt
7352 )
7353 {
7354 D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_finally_stmt"));
7355 _res = invalid_finally_stmt_var;
7356 goto done;
7357 }
7358 p->mark = _mark;
7359 D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ',
7360 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_finally_stmt"));
7361 }
7362 { // 'finally' &&':' block
7363 if (p->error_indicator) {
7364 p->level--;
7365 return NULL;
7366 }
7367 D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' &&':' block"));
7368 Token * _keyword;
7369 Token * _literal;
7370 asdl_stmt_seq* a;
7371 if (
7372 (_keyword = _PyPegen_expect_token(p, 651)) // token='finally'
7373 &&
7374 (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
7375 &&
7376 (a = block_rule(p)) // block
7377 )
7378 {
7379 D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally' &&':' block"));
7380 _res = a;
7381 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7382 p->error_indicator = 1;
7383 p->level--;
7384 return NULL;
7385 }
7386 goto done;
7387 }
7388 p->mark = _mark;
7389 D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ',
7390 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' &&':' block"));
7391 }
7392 _res = NULL;
7393 done:
7394 p->level--;
7395 return _res;
7396 }
7397
7398 // match_stmt:
7399 // | "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT
7400 // | invalid_match_stmt
7401 static stmt_ty
7402 match_stmt_rule(Parser *p)
7403 {
7404 if (p->level++ == MAXSTACK) {
7405 _Pypegen_stack_overflow(p);
7406 }
7407 if (p->error_indicator) {
7408 p->level--;
7409 return NULL;
7410 }
7411 stmt_ty _res = NULL;
7412 int _mark = p->mark;
7413 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7414 p->error_indicator = 1;
7415 p->level--;
7416 return NULL;
7417 }
7418 int _start_lineno = p->tokens[_mark]->lineno;
7419 UNUSED(_start_lineno); // Only used by EXTRA macro
7420 int _start_col_offset = p->tokens[_mark]->col_offset;
7421 UNUSED(_start_col_offset); // Only used by EXTRA macro
7422 { // "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT
7423 if (p->error_indicator) {
7424 p->level--;
7425 return NULL;
7426 }
7427 D(fprintf(stderr, "%*c> match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr ':' NEWLINE INDENT case_block+ DEDENT"));
7428 expr_ty _keyword;
7429 Token * _literal;
7430 asdl_match_case_seq* cases;
7431 Token * dedent_var;
7432 Token * indent_var;
7433 Token * newline_var;
7434 expr_ty subject;
7435 if (
7436 (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"'
7437 &&
7438 (subject = subject_expr_rule(p)) // subject_expr
7439 &&
7440 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7441 &&
7442 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
7443 &&
7444 (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT'
7445 &&
7446 (cases = (asdl_match_case_seq*)_loop1_64_rule(p)) // case_block+
7447 &&
7448 (dedent_var = _PyPegen_expect_token(p, DEDENT)) // token='DEDENT'
7449 )
7450 {
7451 D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr ':' NEWLINE INDENT case_block+ DEDENT"));
7452 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7453 if (_token == NULL) {
7454 p->level--;
7455 return NULL;
7456 }
7457 int _end_lineno = _token->end_lineno;
7458 UNUSED(_end_lineno); // Only used by EXTRA macro
7459 int _end_col_offset = _token->end_col_offset;
7460 UNUSED(_end_col_offset); // Only used by EXTRA macro
7461 _res = CHECK_VERSION ( stmt_ty , 10 , "Pattern matching is" , _PyAST_Match ( subject , cases , EXTRA ) );
7462 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7463 p->error_indicator = 1;
7464 p->level--;
7465 return NULL;
7466 }
7467 goto done;
7468 }
7469 p->mark = _mark;
7470 D(fprintf(stderr, "%*c%s match_stmt[%d-%d]: %s failed!\n", p->level, ' ',
7471 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr ':' NEWLINE INDENT case_block+ DEDENT"));
7472 }
7473 if (p->call_invalid_rules) { // invalid_match_stmt
7474 if (p->error_indicator) {
7475 p->level--;
7476 return NULL;
7477 }
7478 D(fprintf(stderr, "%*c> match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_match_stmt"));
7479 void *invalid_match_stmt_var;
7480 if (
7481 (invalid_match_stmt_var = invalid_match_stmt_rule(p)) // invalid_match_stmt
7482 )
7483 {
7484 D(fprintf(stderr, "%*c+ match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_match_stmt"));
7485 _res = invalid_match_stmt_var;
7486 goto done;
7487 }
7488 p->mark = _mark;
7489 D(fprintf(stderr, "%*c%s match_stmt[%d-%d]: %s failed!\n", p->level, ' ',
7490 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_match_stmt"));
7491 }
7492 _res = NULL;
7493 done:
7494 p->level--;
7495 return _res;
7496 }
7497
7498 // subject_expr: star_named_expression ',' star_named_expressions? | named_expression
7499 static expr_ty
7500 subject_expr_rule(Parser *p)
7501 {
7502 if (p->level++ == MAXSTACK) {
7503 _Pypegen_stack_overflow(p);
7504 }
7505 if (p->error_indicator) {
7506 p->level--;
7507 return NULL;
7508 }
7509 expr_ty _res = NULL;
7510 int _mark = p->mark;
7511 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7512 p->error_indicator = 1;
7513 p->level--;
7514 return NULL;
7515 }
7516 int _start_lineno = p->tokens[_mark]->lineno;
7517 UNUSED(_start_lineno); // Only used by EXTRA macro
7518 int _start_col_offset = p->tokens[_mark]->col_offset;
7519 UNUSED(_start_col_offset); // Only used by EXTRA macro
7520 { // star_named_expression ',' star_named_expressions?
7521 if (p->error_indicator) {
7522 p->level--;
7523 return NULL;
7524 }
7525 D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
7526 Token * _literal;
7527 expr_ty value;
7528 void *values;
7529 if (
7530 (value = star_named_expression_rule(p)) // star_named_expression
7531 &&
7532 (_literal = _PyPegen_expect_token(p, 12)) // token=','
7533 &&
7534 (values = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions?
7535 )
7536 {
7537 D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
7538 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7539 if (_token == NULL) {
7540 p->level--;
7541 return NULL;
7542 }
7543 int _end_lineno = _token->end_lineno;
7544 UNUSED(_end_lineno); // Only used by EXTRA macro
7545 int _end_col_offset = _token->end_col_offset;
7546 UNUSED(_end_col_offset); // Only used by EXTRA macro
7547 _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , value , values ) ) , Load , EXTRA );
7548 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7549 p->error_indicator = 1;
7550 p->level--;
7551 return NULL;
7552 }
7553 goto done;
7554 }
7555 p->mark = _mark;
7556 D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ',
7557 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
7558 }
7559 { // named_expression
7560 if (p->error_indicator) {
7561 p->level--;
7562 return NULL;
7563 }
7564 D(fprintf(stderr, "%*c> subject_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
7565 expr_ty named_expression_var;
7566 if (
7567 (named_expression_var = named_expression_rule(p)) // named_expression
7568 )
7569 {
7570 D(fprintf(stderr, "%*c+ subject_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
7571 _res = named_expression_var;
7572 goto done;
7573 }
7574 p->mark = _mark;
7575 D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ',
7576 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
7577 }
7578 _res = NULL;
7579 done:
7580 p->level--;
7581 return _res;
7582 }
7583
7584 // case_block: invalid_case_block | "case" patterns guard? ':' block
7585 static match_case_ty
7586 case_block_rule(Parser *p)
7587 {
7588 if (p->level++ == MAXSTACK) {
7589 _Pypegen_stack_overflow(p);
7590 }
7591 if (p->error_indicator) {
7592 p->level--;
7593 return NULL;
7594 }
7595 match_case_ty _res = NULL;
7596 int _mark = p->mark;
7597 if (p->call_invalid_rules) { // invalid_case_block
7598 if (p->error_indicator) {
7599 p->level--;
7600 return NULL;
7601 }
7602 D(fprintf(stderr, "%*c> case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_case_block"));
7603 void *invalid_case_block_var;
7604 if (
7605 (invalid_case_block_var = invalid_case_block_rule(p)) // invalid_case_block
7606 )
7607 {
7608 D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_case_block"));
7609 _res = invalid_case_block_var;
7610 goto done;
7611 }
7612 p->mark = _mark;
7613 D(fprintf(stderr, "%*c%s case_block[%d-%d]: %s failed!\n", p->level, ' ',
7614 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_case_block"));
7615 }
7616 { // "case" patterns guard? ':' block
7617 if (p->error_indicator) {
7618 p->level--;
7619 return NULL;
7620 }
7621 D(fprintf(stderr, "%*c> case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' block"));
7622 expr_ty _keyword;
7623 Token * _literal;
7624 asdl_stmt_seq* body;
7625 void *guard;
7626 pattern_ty pattern;
7627 if (
7628 (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"'
7629 &&
7630 (pattern = patterns_rule(p)) // patterns
7631 &&
7632 (guard = guard_rule(p), !p->error_indicator) // guard?
7633 &&
7634 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
7635 &&
7636 (body = block_rule(p)) // block
7637 )
7638 {
7639 D(fprintf(stderr, "%*c+ case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' block"));
7640 _res = _PyAST_match_case ( pattern , guard , body , p -> arena );
7641 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7642 p->error_indicator = 1;
7643 p->level--;
7644 return NULL;
7645 }
7646 goto done;
7647 }
7648 p->mark = _mark;
7649 D(fprintf(stderr, "%*c%s case_block[%d-%d]: %s failed!\n", p->level, ' ',
7650 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? ':' block"));
7651 }
7652 _res = NULL;
7653 done:
7654 p->level--;
7655 return _res;
7656 }
7657
7658 // guard: 'if' named_expression
7659 static expr_ty
7660 guard_rule(Parser *p)
7661 {
7662 if (p->level++ == MAXSTACK) {
7663 _Pypegen_stack_overflow(p);
7664 }
7665 if (p->error_indicator) {
7666 p->level--;
7667 return NULL;
7668 }
7669 expr_ty _res = NULL;
7670 int _mark = p->mark;
7671 { // 'if' named_expression
7672 if (p->error_indicator) {
7673 p->level--;
7674 return NULL;
7675 }
7676 D(fprintf(stderr, "%*c> guard[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression"));
7677 Token * _keyword;
7678 expr_ty guard;
7679 if (
7680 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
7681 &&
7682 (guard = named_expression_rule(p)) // named_expression
7683 )
7684 {
7685 D(fprintf(stderr, "%*c+ guard[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression"));
7686 _res = guard;
7687 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7688 p->error_indicator = 1;
7689 p->level--;
7690 return NULL;
7691 }
7692 goto done;
7693 }
7694 p->mark = _mark;
7695 D(fprintf(stderr, "%*c%s guard[%d-%d]: %s failed!\n", p->level, ' ',
7696 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression"));
7697 }
7698 _res = NULL;
7699 done:
7700 p->level--;
7701 return _res;
7702 }
7703
7704 // patterns: open_sequence_pattern | pattern
7705 static pattern_ty
7706 patterns_rule(Parser *p)
7707 {
7708 if (p->level++ == MAXSTACK) {
7709 _Pypegen_stack_overflow(p);
7710 }
7711 if (p->error_indicator) {
7712 p->level--;
7713 return NULL;
7714 }
7715 pattern_ty _res = NULL;
7716 int _mark = p->mark;
7717 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7718 p->error_indicator = 1;
7719 p->level--;
7720 return NULL;
7721 }
7722 int _start_lineno = p->tokens[_mark]->lineno;
7723 UNUSED(_start_lineno); // Only used by EXTRA macro
7724 int _start_col_offset = p->tokens[_mark]->col_offset;
7725 UNUSED(_start_col_offset); // Only used by EXTRA macro
7726 { // open_sequence_pattern
7727 if (p->error_indicator) {
7728 p->level--;
7729 return NULL;
7730 }
7731 D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "open_sequence_pattern"));
7732 asdl_pattern_seq* patterns;
7733 if (
7734 (patterns = (asdl_pattern_seq*)open_sequence_pattern_rule(p)) // open_sequence_pattern
7735 )
7736 {
7737 D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "open_sequence_pattern"));
7738 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7739 if (_token == NULL) {
7740 p->level--;
7741 return NULL;
7742 }
7743 int _end_lineno = _token->end_lineno;
7744 UNUSED(_end_lineno); // Only used by EXTRA macro
7745 int _end_col_offset = _token->end_col_offset;
7746 UNUSED(_end_col_offset); // Only used by EXTRA macro
7747 _res = _PyAST_MatchSequence ( patterns , EXTRA );
7748 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7749 p->error_indicator = 1;
7750 p->level--;
7751 return NULL;
7752 }
7753 goto done;
7754 }
7755 p->mark = _mark;
7756 D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ',
7757 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "open_sequence_pattern"));
7758 }
7759 { // pattern
7760 if (p->error_indicator) {
7761 p->level--;
7762 return NULL;
7763 }
7764 D(fprintf(stderr, "%*c> patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern"));
7765 pattern_ty pattern_var;
7766 if (
7767 (pattern_var = pattern_rule(p)) // pattern
7768 )
7769 {
7770 D(fprintf(stderr, "%*c+ patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern"));
7771 _res = pattern_var;
7772 goto done;
7773 }
7774 p->mark = _mark;
7775 D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ',
7776 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern"));
7777 }
7778 _res = NULL;
7779 done:
7780 p->level--;
7781 return _res;
7782 }
7783
7784 // pattern: as_pattern | or_pattern
7785 static pattern_ty
7786 pattern_rule(Parser *p)
7787 {
7788 if (p->level++ == MAXSTACK) {
7789 _Pypegen_stack_overflow(p);
7790 }
7791 if (p->error_indicator) {
7792 p->level--;
7793 return NULL;
7794 }
7795 pattern_ty _res = NULL;
7796 int _mark = p->mark;
7797 { // as_pattern
7798 if (p->error_indicator) {
7799 p->level--;
7800 return NULL;
7801 }
7802 D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "as_pattern"));
7803 pattern_ty as_pattern_var;
7804 if (
7805 (as_pattern_var = as_pattern_rule(p)) // as_pattern
7806 )
7807 {
7808 D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "as_pattern"));
7809 _res = as_pattern_var;
7810 goto done;
7811 }
7812 p->mark = _mark;
7813 D(fprintf(stderr, "%*c%s pattern[%d-%d]: %s failed!\n", p->level, ' ',
7814 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "as_pattern"));
7815 }
7816 { // or_pattern
7817 if (p->error_indicator) {
7818 p->level--;
7819 return NULL;
7820 }
7821 D(fprintf(stderr, "%*c> pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern"));
7822 pattern_ty or_pattern_var;
7823 if (
7824 (or_pattern_var = or_pattern_rule(p)) // or_pattern
7825 )
7826 {
7827 D(fprintf(stderr, "%*c+ pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern"));
7828 _res = or_pattern_var;
7829 goto done;
7830 }
7831 p->mark = _mark;
7832 D(fprintf(stderr, "%*c%s pattern[%d-%d]: %s failed!\n", p->level, ' ',
7833 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern"));
7834 }
7835 _res = NULL;
7836 done:
7837 p->level--;
7838 return _res;
7839 }
7840
7841 // as_pattern: or_pattern 'as' pattern_capture_target | invalid_as_pattern
7842 static pattern_ty
7843 as_pattern_rule(Parser *p)
7844 {
7845 if (p->level++ == MAXSTACK) {
7846 _Pypegen_stack_overflow(p);
7847 }
7848 if (p->error_indicator) {
7849 p->level--;
7850 return NULL;
7851 }
7852 pattern_ty _res = NULL;
7853 int _mark = p->mark;
7854 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7855 p->error_indicator = 1;
7856 p->level--;
7857 return NULL;
7858 }
7859 int _start_lineno = p->tokens[_mark]->lineno;
7860 UNUSED(_start_lineno); // Only used by EXTRA macro
7861 int _start_col_offset = p->tokens[_mark]->col_offset;
7862 UNUSED(_start_col_offset); // Only used by EXTRA macro
7863 { // or_pattern 'as' pattern_capture_target
7864 if (p->error_indicator) {
7865 p->level--;
7866 return NULL;
7867 }
7868 D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' pattern_capture_target"));
7869 Token * _keyword;
7870 pattern_ty pattern;
7871 expr_ty target;
7872 if (
7873 (pattern = or_pattern_rule(p)) // or_pattern
7874 &&
7875 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
7876 &&
7877 (target = pattern_capture_target_rule(p)) // pattern_capture_target
7878 )
7879 {
7880 D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' pattern_capture_target"));
7881 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7882 if (_token == NULL) {
7883 p->level--;
7884 return NULL;
7885 }
7886 int _end_lineno = _token->end_lineno;
7887 UNUSED(_end_lineno); // Only used by EXTRA macro
7888 int _end_col_offset = _token->end_col_offset;
7889 UNUSED(_end_col_offset); // Only used by EXTRA macro
7890 _res = _PyAST_MatchAs ( pattern , target -> v . Name . id , EXTRA );
7891 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7892 p->error_indicator = 1;
7893 p->level--;
7894 return NULL;
7895 }
7896 goto done;
7897 }
7898 p->mark = _mark;
7899 D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ',
7900 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' pattern_capture_target"));
7901 }
7902 if (p->call_invalid_rules) { // invalid_as_pattern
7903 if (p->error_indicator) {
7904 p->level--;
7905 return NULL;
7906 }
7907 D(fprintf(stderr, "%*c> as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_as_pattern"));
7908 void *invalid_as_pattern_var;
7909 if (
7910 (invalid_as_pattern_var = invalid_as_pattern_rule(p)) // invalid_as_pattern
7911 )
7912 {
7913 D(fprintf(stderr, "%*c+ as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_as_pattern"));
7914 _res = invalid_as_pattern_var;
7915 goto done;
7916 }
7917 p->mark = _mark;
7918 D(fprintf(stderr, "%*c%s as_pattern[%d-%d]: %s failed!\n", p->level, ' ',
7919 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_as_pattern"));
7920 }
7921 _res = NULL;
7922 done:
7923 p->level--;
7924 return _res;
7925 }
7926
7927 // or_pattern: '|'.closed_pattern+
7928 static pattern_ty
7929 or_pattern_rule(Parser *p)
7930 {
7931 if (p->level++ == MAXSTACK) {
7932 _Pypegen_stack_overflow(p);
7933 }
7934 if (p->error_indicator) {
7935 p->level--;
7936 return NULL;
7937 }
7938 pattern_ty _res = NULL;
7939 int _mark = p->mark;
7940 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
7941 p->error_indicator = 1;
7942 p->level--;
7943 return NULL;
7944 }
7945 int _start_lineno = p->tokens[_mark]->lineno;
7946 UNUSED(_start_lineno); // Only used by EXTRA macro
7947 int _start_col_offset = p->tokens[_mark]->col_offset;
7948 UNUSED(_start_col_offset); // Only used by EXTRA macro
7949 { // '|'.closed_pattern+
7950 if (p->error_indicator) {
7951 p->level--;
7952 return NULL;
7953 }
7954 D(fprintf(stderr, "%*c> or_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+"));
7955 asdl_pattern_seq* patterns;
7956 if (
7957 (patterns = (asdl_pattern_seq*)_gather_65_rule(p)) // '|'.closed_pattern+
7958 )
7959 {
7960 D(fprintf(stderr, "%*c+ or_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|'.closed_pattern+"));
7961 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
7962 if (_token == NULL) {
7963 p->level--;
7964 return NULL;
7965 }
7966 int _end_lineno = _token->end_lineno;
7967 UNUSED(_end_lineno); // Only used by EXTRA macro
7968 int _end_col_offset = _token->end_col_offset;
7969 UNUSED(_end_col_offset); // Only used by EXTRA macro
7970 _res = asdl_seq_LEN ( patterns ) == 1 ? asdl_seq_GET ( patterns , 0 ) : _PyAST_MatchOr ( patterns , EXTRA );
7971 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
7972 p->error_indicator = 1;
7973 p->level--;
7974 return NULL;
7975 }
7976 goto done;
7977 }
7978 p->mark = _mark;
7979 D(fprintf(stderr, "%*c%s or_pattern[%d-%d]: %s failed!\n", p->level, ' ',
7980 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|'.closed_pattern+"));
7981 }
7982 _res = NULL;
7983 done:
7984 p->level--;
7985 return _res;
7986 }
7987
7988 // closed_pattern:
7989 // | literal_pattern
7990 // | capture_pattern
7991 // | wildcard_pattern
7992 // | value_pattern
7993 // | group_pattern
7994 // | sequence_pattern
7995 // | mapping_pattern
7996 // | class_pattern
7997 static pattern_ty
7998 closed_pattern_rule(Parser *p)
7999 {
8000 if (p->level++ == MAXSTACK) {
8001 _Pypegen_stack_overflow(p);
8002 }
8003 if (p->error_indicator) {
8004 p->level--;
8005 return NULL;
8006 }
8007 pattern_ty _res = NULL;
8008 if (_PyPegen_is_memoized(p, closed_pattern_type, &_res)) {
8009 p->level--;
8010 return _res;
8011 }
8012 int _mark = p->mark;
8013 { // literal_pattern
8014 if (p->error_indicator) {
8015 p->level--;
8016 return NULL;
8017 }
8018 D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_pattern"));
8019 pattern_ty literal_pattern_var;
8020 if (
8021 (literal_pattern_var = literal_pattern_rule(p)) // literal_pattern
8022 )
8023 {
8024 D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_pattern"));
8025 _res = literal_pattern_var;
8026 goto done;
8027 }
8028 p->mark = _mark;
8029 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8030 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_pattern"));
8031 }
8032 { // capture_pattern
8033 if (p->error_indicator) {
8034 p->level--;
8035 return NULL;
8036 }
8037 D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "capture_pattern"));
8038 pattern_ty capture_pattern_var;
8039 if (
8040 (capture_pattern_var = capture_pattern_rule(p)) // capture_pattern
8041 )
8042 {
8043 D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "capture_pattern"));
8044 _res = capture_pattern_var;
8045 goto done;
8046 }
8047 p->mark = _mark;
8048 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8049 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "capture_pattern"));
8050 }
8051 { // wildcard_pattern
8052 if (p->error_indicator) {
8053 p->level--;
8054 return NULL;
8055 }
8056 D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "wildcard_pattern"));
8057 pattern_ty wildcard_pattern_var;
8058 if (
8059 (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern
8060 )
8061 {
8062 D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "wildcard_pattern"));
8063 _res = wildcard_pattern_var;
8064 goto done;
8065 }
8066 p->mark = _mark;
8067 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8068 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "wildcard_pattern"));
8069 }
8070 { // value_pattern
8071 if (p->error_indicator) {
8072 p->level--;
8073 return NULL;
8074 }
8075 D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "value_pattern"));
8076 pattern_ty value_pattern_var;
8077 if (
8078 (value_pattern_var = value_pattern_rule(p)) // value_pattern
8079 )
8080 {
8081 D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "value_pattern"));
8082 _res = value_pattern_var;
8083 goto done;
8084 }
8085 p->mark = _mark;
8086 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8087 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "value_pattern"));
8088 }
8089 { // group_pattern
8090 if (p->error_indicator) {
8091 p->level--;
8092 return NULL;
8093 }
8094 D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group_pattern"));
8095 pattern_ty group_pattern_var;
8096 if (
8097 (group_pattern_var = group_pattern_rule(p)) // group_pattern
8098 )
8099 {
8100 D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group_pattern"));
8101 _res = group_pattern_var;
8102 goto done;
8103 }
8104 p->mark = _mark;
8105 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8106 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group_pattern"));
8107 }
8108 { // sequence_pattern
8109 if (p->error_indicator) {
8110 p->level--;
8111 return NULL;
8112 }
8113 D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sequence_pattern"));
8114 pattern_ty sequence_pattern_var;
8115 if (
8116 (sequence_pattern_var = sequence_pattern_rule(p)) // sequence_pattern
8117 )
8118 {
8119 D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sequence_pattern"));
8120 _res = sequence_pattern_var;
8121 goto done;
8122 }
8123 p->mark = _mark;
8124 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8125 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sequence_pattern"));
8126 }
8127 { // mapping_pattern
8128 if (p->error_indicator) {
8129 p->level--;
8130 return NULL;
8131 }
8132 D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "mapping_pattern"));
8133 pattern_ty mapping_pattern_var;
8134 if (
8135 (mapping_pattern_var = mapping_pattern_rule(p)) // mapping_pattern
8136 )
8137 {
8138 D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "mapping_pattern"));
8139 _res = mapping_pattern_var;
8140 goto done;
8141 }
8142 p->mark = _mark;
8143 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8144 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "mapping_pattern"));
8145 }
8146 { // class_pattern
8147 if (p->error_indicator) {
8148 p->level--;
8149 return NULL;
8150 }
8151 D(fprintf(stderr, "%*c> closed_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_pattern"));
8152 pattern_ty class_pattern_var;
8153 if (
8154 (class_pattern_var = class_pattern_rule(p)) // class_pattern
8155 )
8156 {
8157 D(fprintf(stderr, "%*c+ closed_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_pattern"));
8158 _res = class_pattern_var;
8159 goto done;
8160 }
8161 p->mark = _mark;
8162 D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8163 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_pattern"));
8164 }
8165 _res = NULL;
8166 done:
8167 _PyPegen_insert_memo(p, _mark, closed_pattern_type, _res);
8168 p->level--;
8169 return _res;
8170 }
8171
8172 // literal_pattern:
8173 // | signed_number !('+' | '-')
8174 // | complex_number
8175 // | strings
8176 // | 'None'
8177 // | 'True'
8178 // | 'False'
8179 static pattern_ty
8180 literal_pattern_rule(Parser *p)
8181 {
8182 if (p->level++ == MAXSTACK) {
8183 _Pypegen_stack_overflow(p);
8184 }
8185 if (p->error_indicator) {
8186 p->level--;
8187 return NULL;
8188 }
8189 pattern_ty _res = NULL;
8190 int _mark = p->mark;
8191 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8192 p->error_indicator = 1;
8193 p->level--;
8194 return NULL;
8195 }
8196 int _start_lineno = p->tokens[_mark]->lineno;
8197 UNUSED(_start_lineno); // Only used by EXTRA macro
8198 int _start_col_offset = p->tokens[_mark]->col_offset;
8199 UNUSED(_start_col_offset); // Only used by EXTRA macro
8200 { // signed_number !('+' | '-')
8201 if (p->error_indicator) {
8202 p->level--;
8203 return NULL;
8204 }
8205 D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')"));
8206 expr_ty value;
8207 if (
8208 (value = signed_number_rule(p)) // signed_number
8209 &&
8210 _PyPegen_lookahead(0, _tmp_67_rule, p)
8211 )
8212 {
8213 D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')"));
8214 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8215 if (_token == NULL) {
8216 p->level--;
8217 return NULL;
8218 }
8219 int _end_lineno = _token->end_lineno;
8220 UNUSED(_end_lineno); // Only used by EXTRA macro
8221 int _end_col_offset = _token->end_col_offset;
8222 UNUSED(_end_col_offset); // Only used by EXTRA macro
8223 _res = _PyAST_MatchValue ( value , EXTRA );
8224 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8225 p->error_indicator = 1;
8226 p->level--;
8227 return NULL;
8228 }
8229 goto done;
8230 }
8231 p->mark = _mark;
8232 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8233 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')"));
8234 }
8235 { // complex_number
8236 if (p->error_indicator) {
8237 p->level--;
8238 return NULL;
8239 }
8240 D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number"));
8241 expr_ty value;
8242 if (
8243 (value = complex_number_rule(p)) // complex_number
8244 )
8245 {
8246 D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "complex_number"));
8247 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8248 if (_token == NULL) {
8249 p->level--;
8250 return NULL;
8251 }
8252 int _end_lineno = _token->end_lineno;
8253 UNUSED(_end_lineno); // Only used by EXTRA macro
8254 int _end_col_offset = _token->end_col_offset;
8255 UNUSED(_end_col_offset); // Only used by EXTRA macro
8256 _res = _PyAST_MatchValue ( value , EXTRA );
8257 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8258 p->error_indicator = 1;
8259 p->level--;
8260 return NULL;
8261 }
8262 goto done;
8263 }
8264 p->mark = _mark;
8265 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8266 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number"));
8267 }
8268 { // strings
8269 if (p->error_indicator) {
8270 p->level--;
8271 return NULL;
8272 }
8273 D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings"));
8274 expr_ty value;
8275 if (
8276 (value = strings_rule(p)) // strings
8277 )
8278 {
8279 D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings"));
8280 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8281 if (_token == NULL) {
8282 p->level--;
8283 return NULL;
8284 }
8285 int _end_lineno = _token->end_lineno;
8286 UNUSED(_end_lineno); // Only used by EXTRA macro
8287 int _end_col_offset = _token->end_col_offset;
8288 UNUSED(_end_col_offset); // Only used by EXTRA macro
8289 _res = _PyAST_MatchValue ( value , EXTRA );
8290 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8291 p->error_indicator = 1;
8292 p->level--;
8293 return NULL;
8294 }
8295 goto done;
8296 }
8297 p->mark = _mark;
8298 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8299 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings"));
8300 }
8301 { // 'None'
8302 if (p->error_indicator) {
8303 p->level--;
8304 return NULL;
8305 }
8306 D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
8307 Token * _keyword;
8308 if (
8309 (_keyword = _PyPegen_expect_token(p, 614)) // token='None'
8310 )
8311 {
8312 D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
8313 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8314 if (_token == NULL) {
8315 p->level--;
8316 return NULL;
8317 }
8318 int _end_lineno = _token->end_lineno;
8319 UNUSED(_end_lineno); // Only used by EXTRA macro
8320 int _end_col_offset = _token->end_col_offset;
8321 UNUSED(_end_col_offset); // Only used by EXTRA macro
8322 _res = _PyAST_MatchSingleton ( Py_None , EXTRA );
8323 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8324 p->error_indicator = 1;
8325 p->level--;
8326 return NULL;
8327 }
8328 goto done;
8329 }
8330 p->mark = _mark;
8331 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8332 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
8333 }
8334 { // 'True'
8335 if (p->error_indicator) {
8336 p->level--;
8337 return NULL;
8338 }
8339 D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
8340 Token * _keyword;
8341 if (
8342 (_keyword = _PyPegen_expect_token(p, 613)) // token='True'
8343 )
8344 {
8345 D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
8346 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8347 if (_token == NULL) {
8348 p->level--;
8349 return NULL;
8350 }
8351 int _end_lineno = _token->end_lineno;
8352 UNUSED(_end_lineno); // Only used by EXTRA macro
8353 int _end_col_offset = _token->end_col_offset;
8354 UNUSED(_end_col_offset); // Only used by EXTRA macro
8355 _res = _PyAST_MatchSingleton ( Py_True , EXTRA );
8356 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8357 p->error_indicator = 1;
8358 p->level--;
8359 return NULL;
8360 }
8361 goto done;
8362 }
8363 p->mark = _mark;
8364 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8365 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
8366 }
8367 { // 'False'
8368 if (p->error_indicator) {
8369 p->level--;
8370 return NULL;
8371 }
8372 D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
8373 Token * _keyword;
8374 if (
8375 (_keyword = _PyPegen_expect_token(p, 615)) // token='False'
8376 )
8377 {
8378 D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
8379 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8380 if (_token == NULL) {
8381 p->level--;
8382 return NULL;
8383 }
8384 int _end_lineno = _token->end_lineno;
8385 UNUSED(_end_lineno); // Only used by EXTRA macro
8386 int _end_col_offset = _token->end_col_offset;
8387 UNUSED(_end_col_offset); // Only used by EXTRA macro
8388 _res = _PyAST_MatchSingleton ( Py_False , EXTRA );
8389 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8390 p->error_indicator = 1;
8391 p->level--;
8392 return NULL;
8393 }
8394 goto done;
8395 }
8396 p->mark = _mark;
8397 D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
8398 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));
8399 }
8400 _res = NULL;
8401 done:
8402 p->level--;
8403 return _res;
8404 }
8405
8406 // literal_expr:
8407 // | signed_number !('+' | '-')
8408 // | complex_number
8409 // | strings
8410 // | 'None'
8411 // | 'True'
8412 // | 'False'
8413 static expr_ty
8414 literal_expr_rule(Parser *p)
8415 {
8416 if (p->level++ == MAXSTACK) {
8417 _Pypegen_stack_overflow(p);
8418 }
8419 if (p->error_indicator) {
8420 p->level--;
8421 return NULL;
8422 }
8423 expr_ty _res = NULL;
8424 int _mark = p->mark;
8425 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8426 p->error_indicator = 1;
8427 p->level--;
8428 return NULL;
8429 }
8430 int _start_lineno = p->tokens[_mark]->lineno;
8431 UNUSED(_start_lineno); // Only used by EXTRA macro
8432 int _start_col_offset = p->tokens[_mark]->col_offset;
8433 UNUSED(_start_col_offset); // Only used by EXTRA macro
8434 { // signed_number !('+' | '-')
8435 if (p->error_indicator) {
8436 p->level--;
8437 return NULL;
8438 }
8439 D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')"));
8440 expr_ty signed_number_var;
8441 if (
8442 (signed_number_var = signed_number_rule(p)) // signed_number
8443 &&
8444 _PyPegen_lookahead(0, _tmp_68_rule, p)
8445 )
8446 {
8447 D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_number !('+' | '-')"));
8448 _res = signed_number_var;
8449 goto done;
8450 }
8451 p->mark = _mark;
8452 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
8453 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')"));
8454 }
8455 { // complex_number
8456 if (p->error_indicator) {
8457 p->level--;
8458 return NULL;
8459 }
8460 D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "complex_number"));
8461 expr_ty complex_number_var;
8462 if (
8463 (complex_number_var = complex_number_rule(p)) // complex_number
8464 )
8465 {
8466 D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "complex_number"));
8467 _res = complex_number_var;
8468 goto done;
8469 }
8470 p->mark = _mark;
8471 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
8472 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number"));
8473 }
8474 { // strings
8475 if (p->error_indicator) {
8476 p->level--;
8477 return NULL;
8478 }
8479 D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "strings"));
8480 expr_ty strings_var;
8481 if (
8482 (strings_var = strings_rule(p)) // strings
8483 )
8484 {
8485 D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "strings"));
8486 _res = strings_var;
8487 goto done;
8488 }
8489 p->mark = _mark;
8490 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
8491 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings"));
8492 }
8493 { // 'None'
8494 if (p->error_indicator) {
8495 p->level--;
8496 return NULL;
8497 }
8498 D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
8499 Token * _keyword;
8500 if (
8501 (_keyword = _PyPegen_expect_token(p, 614)) // token='None'
8502 )
8503 {
8504 D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
8505 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8506 if (_token == NULL) {
8507 p->level--;
8508 return NULL;
8509 }
8510 int _end_lineno = _token->end_lineno;
8511 UNUSED(_end_lineno); // Only used by EXTRA macro
8512 int _end_col_offset = _token->end_col_offset;
8513 UNUSED(_end_col_offset); // Only used by EXTRA macro
8514 _res = _PyAST_Constant ( Py_None , NULL , EXTRA );
8515 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8516 p->error_indicator = 1;
8517 p->level--;
8518 return NULL;
8519 }
8520 goto done;
8521 }
8522 p->mark = _mark;
8523 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
8524 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
8525 }
8526 { // 'True'
8527 if (p->error_indicator) {
8528 p->level--;
8529 return NULL;
8530 }
8531 D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
8532 Token * _keyword;
8533 if (
8534 (_keyword = _PyPegen_expect_token(p, 613)) // token='True'
8535 )
8536 {
8537 D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
8538 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8539 if (_token == NULL) {
8540 p->level--;
8541 return NULL;
8542 }
8543 int _end_lineno = _token->end_lineno;
8544 UNUSED(_end_lineno); // Only used by EXTRA macro
8545 int _end_col_offset = _token->end_col_offset;
8546 UNUSED(_end_col_offset); // Only used by EXTRA macro
8547 _res = _PyAST_Constant ( Py_True , NULL , EXTRA );
8548 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8549 p->error_indicator = 1;
8550 p->level--;
8551 return NULL;
8552 }
8553 goto done;
8554 }
8555 p->mark = _mark;
8556 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
8557 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
8558 }
8559 { // 'False'
8560 if (p->error_indicator) {
8561 p->level--;
8562 return NULL;
8563 }
8564 D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
8565 Token * _keyword;
8566 if (
8567 (_keyword = _PyPegen_expect_token(p, 615)) // token='False'
8568 )
8569 {
8570 D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
8571 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8572 if (_token == NULL) {
8573 p->level--;
8574 return NULL;
8575 }
8576 int _end_lineno = _token->end_lineno;
8577 UNUSED(_end_lineno); // Only used by EXTRA macro
8578 int _end_col_offset = _token->end_col_offset;
8579 UNUSED(_end_col_offset); // Only used by EXTRA macro
8580 _res = _PyAST_Constant ( Py_False , NULL , EXTRA );
8581 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8582 p->error_indicator = 1;
8583 p->level--;
8584 return NULL;
8585 }
8586 goto done;
8587 }
8588 p->mark = _mark;
8589 D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
8590 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));
8591 }
8592 _res = NULL;
8593 done:
8594 p->level--;
8595 return _res;
8596 }
8597
8598 // complex_number:
8599 // | signed_real_number '+' imaginary_number
8600 // | signed_real_number '-' imaginary_number
8601 static expr_ty
8602 complex_number_rule(Parser *p)
8603 {
8604 if (p->level++ == MAXSTACK) {
8605 _Pypegen_stack_overflow(p);
8606 }
8607 if (p->error_indicator) {
8608 p->level--;
8609 return NULL;
8610 }
8611 expr_ty _res = NULL;
8612 int _mark = p->mark;
8613 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8614 p->error_indicator = 1;
8615 p->level--;
8616 return NULL;
8617 }
8618 int _start_lineno = p->tokens[_mark]->lineno;
8619 UNUSED(_start_lineno); // Only used by EXTRA macro
8620 int _start_col_offset = p->tokens[_mark]->col_offset;
8621 UNUSED(_start_col_offset); // Only used by EXTRA macro
8622 { // signed_real_number '+' imaginary_number
8623 if (p->error_indicator) {
8624 p->level--;
8625 return NULL;
8626 }
8627 D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_real_number '+' imaginary_number"));
8628 Token * _literal;
8629 expr_ty imag;
8630 expr_ty real;
8631 if (
8632 (real = signed_real_number_rule(p)) // signed_real_number
8633 &&
8634 (_literal = _PyPegen_expect_token(p, 14)) // token='+'
8635 &&
8636 (imag = imaginary_number_rule(p)) // imaginary_number
8637 )
8638 {
8639 D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_real_number '+' imaginary_number"));
8640 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8641 if (_token == NULL) {
8642 p->level--;
8643 return NULL;
8644 }
8645 int _end_lineno = _token->end_lineno;
8646 UNUSED(_end_lineno); // Only used by EXTRA macro
8647 int _end_col_offset = _token->end_col_offset;
8648 UNUSED(_end_col_offset); // Only used by EXTRA macro
8649 _res = _PyAST_BinOp ( real , Add , imag , EXTRA );
8650 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8651 p->error_indicator = 1;
8652 p->level--;
8653 return NULL;
8654 }
8655 goto done;
8656 }
8657 p->mark = _mark;
8658 D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ',
8659 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_real_number '+' imaginary_number"));
8660 }
8661 { // signed_real_number '-' imaginary_number
8662 if (p->error_indicator) {
8663 p->level--;
8664 return NULL;
8665 }
8666 D(fprintf(stderr, "%*c> complex_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "signed_real_number '-' imaginary_number"));
8667 Token * _literal;
8668 expr_ty imag;
8669 expr_ty real;
8670 if (
8671 (real = signed_real_number_rule(p)) // signed_real_number
8672 &&
8673 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
8674 &&
8675 (imag = imaginary_number_rule(p)) // imaginary_number
8676 )
8677 {
8678 D(fprintf(stderr, "%*c+ complex_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "signed_real_number '-' imaginary_number"));
8679 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8680 if (_token == NULL) {
8681 p->level--;
8682 return NULL;
8683 }
8684 int _end_lineno = _token->end_lineno;
8685 UNUSED(_end_lineno); // Only used by EXTRA macro
8686 int _end_col_offset = _token->end_col_offset;
8687 UNUSED(_end_col_offset); // Only used by EXTRA macro
8688 _res = _PyAST_BinOp ( real , Sub , imag , EXTRA );
8689 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8690 p->error_indicator = 1;
8691 p->level--;
8692 return NULL;
8693 }
8694 goto done;
8695 }
8696 p->mark = _mark;
8697 D(fprintf(stderr, "%*c%s complex_number[%d-%d]: %s failed!\n", p->level, ' ',
8698 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_real_number '-' imaginary_number"));
8699 }
8700 _res = NULL;
8701 done:
8702 p->level--;
8703 return _res;
8704 }
8705
8706 // signed_number: NUMBER | '-' NUMBER
8707 static expr_ty
8708 signed_number_rule(Parser *p)
8709 {
8710 if (p->level++ == MAXSTACK) {
8711 _Pypegen_stack_overflow(p);
8712 }
8713 if (p->error_indicator) {
8714 p->level--;
8715 return NULL;
8716 }
8717 expr_ty _res = NULL;
8718 int _mark = p->mark;
8719 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8720 p->error_indicator = 1;
8721 p->level--;
8722 return NULL;
8723 }
8724 int _start_lineno = p->tokens[_mark]->lineno;
8725 UNUSED(_start_lineno); // Only used by EXTRA macro
8726 int _start_col_offset = p->tokens[_mark]->col_offset;
8727 UNUSED(_start_col_offset); // Only used by EXTRA macro
8728 { // NUMBER
8729 if (p->error_indicator) {
8730 p->level--;
8731 return NULL;
8732 }
8733 D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8734 expr_ty number_var;
8735 if (
8736 (number_var = _PyPegen_number_token(p)) // NUMBER
8737 )
8738 {
8739 D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8740 _res = number_var;
8741 goto done;
8742 }
8743 p->mark = _mark;
8744 D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ',
8745 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));
8746 }
8747 { // '-' NUMBER
8748 if (p->error_indicator) {
8749 p->level--;
8750 return NULL;
8751 }
8752 D(fprintf(stderr, "%*c> signed_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' NUMBER"));
8753 Token * _literal;
8754 expr_ty number;
8755 if (
8756 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
8757 &&
8758 (number = _PyPegen_number_token(p)) // NUMBER
8759 )
8760 {
8761 D(fprintf(stderr, "%*c+ signed_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' NUMBER"));
8762 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8763 if (_token == NULL) {
8764 p->level--;
8765 return NULL;
8766 }
8767 int _end_lineno = _token->end_lineno;
8768 UNUSED(_end_lineno); // Only used by EXTRA macro
8769 int _end_col_offset = _token->end_col_offset;
8770 UNUSED(_end_col_offset); // Only used by EXTRA macro
8771 _res = _PyAST_UnaryOp ( USub , number , EXTRA );
8772 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8773 p->error_indicator = 1;
8774 p->level--;
8775 return NULL;
8776 }
8777 goto done;
8778 }
8779 p->mark = _mark;
8780 D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ',
8781 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' NUMBER"));
8782 }
8783 _res = NULL;
8784 done:
8785 p->level--;
8786 return _res;
8787 }
8788
8789 // signed_real_number: real_number | '-' real_number
8790 static expr_ty
8791 signed_real_number_rule(Parser *p)
8792 {
8793 if (p->level++ == MAXSTACK) {
8794 _Pypegen_stack_overflow(p);
8795 }
8796 if (p->error_indicator) {
8797 p->level--;
8798 return NULL;
8799 }
8800 expr_ty _res = NULL;
8801 int _mark = p->mark;
8802 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8803 p->error_indicator = 1;
8804 p->level--;
8805 return NULL;
8806 }
8807 int _start_lineno = p->tokens[_mark]->lineno;
8808 UNUSED(_start_lineno); // Only used by EXTRA macro
8809 int _start_col_offset = p->tokens[_mark]->col_offset;
8810 UNUSED(_start_col_offset); // Only used by EXTRA macro
8811 { // real_number
8812 if (p->error_indicator) {
8813 p->level--;
8814 return NULL;
8815 }
8816 D(fprintf(stderr, "%*c> signed_real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "real_number"));
8817 expr_ty real_number_var;
8818 if (
8819 (real_number_var = real_number_rule(p)) // real_number
8820 )
8821 {
8822 D(fprintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "real_number"));
8823 _res = real_number_var;
8824 goto done;
8825 }
8826 p->mark = _mark;
8827 D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ',
8828 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "real_number"));
8829 }
8830 { // '-' real_number
8831 if (p->error_indicator) {
8832 p->level--;
8833 return NULL;
8834 }
8835 D(fprintf(stderr, "%*c> signed_real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' real_number"));
8836 Token * _literal;
8837 expr_ty real;
8838 if (
8839 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
8840 &&
8841 (real = real_number_rule(p)) // real_number
8842 )
8843 {
8844 D(fprintf(stderr, "%*c+ signed_real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' real_number"));
8845 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8846 if (_token == NULL) {
8847 p->level--;
8848 return NULL;
8849 }
8850 int _end_lineno = _token->end_lineno;
8851 UNUSED(_end_lineno); // Only used by EXTRA macro
8852 int _end_col_offset = _token->end_col_offset;
8853 UNUSED(_end_col_offset); // Only used by EXTRA macro
8854 _res = _PyAST_UnaryOp ( USub , real , EXTRA );
8855 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8856 p->error_indicator = 1;
8857 p->level--;
8858 return NULL;
8859 }
8860 goto done;
8861 }
8862 p->mark = _mark;
8863 D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ',
8864 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' real_number"));
8865 }
8866 _res = NULL;
8867 done:
8868 p->level--;
8869 return _res;
8870 }
8871
8872 // real_number: NUMBER
8873 static expr_ty
8874 real_number_rule(Parser *p)
8875 {
8876 if (p->level++ == MAXSTACK) {
8877 _Pypegen_stack_overflow(p);
8878 }
8879 if (p->error_indicator) {
8880 p->level--;
8881 return NULL;
8882 }
8883 expr_ty _res = NULL;
8884 int _mark = p->mark;
8885 { // NUMBER
8886 if (p->error_indicator) {
8887 p->level--;
8888 return NULL;
8889 }
8890 D(fprintf(stderr, "%*c> real_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8891 expr_ty real;
8892 if (
8893 (real = _PyPegen_number_token(p)) // NUMBER
8894 )
8895 {
8896 D(fprintf(stderr, "%*c+ real_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8897 _res = _PyPegen_ensure_real ( p , real );
8898 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8899 p->error_indicator = 1;
8900 p->level--;
8901 return NULL;
8902 }
8903 goto done;
8904 }
8905 p->mark = _mark;
8906 D(fprintf(stderr, "%*c%s real_number[%d-%d]: %s failed!\n", p->level, ' ',
8907 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));
8908 }
8909 _res = NULL;
8910 done:
8911 p->level--;
8912 return _res;
8913 }
8914
8915 // imaginary_number: NUMBER
8916 static expr_ty
8917 imaginary_number_rule(Parser *p)
8918 {
8919 if (p->level++ == MAXSTACK) {
8920 _Pypegen_stack_overflow(p);
8921 }
8922 if (p->error_indicator) {
8923 p->level--;
8924 return NULL;
8925 }
8926 expr_ty _res = NULL;
8927 int _mark = p->mark;
8928 { // NUMBER
8929 if (p->error_indicator) {
8930 p->level--;
8931 return NULL;
8932 }
8933 D(fprintf(stderr, "%*c> imaginary_number[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8934 expr_ty imag;
8935 if (
8936 (imag = _PyPegen_number_token(p)) // NUMBER
8937 )
8938 {
8939 D(fprintf(stderr, "%*c+ imaginary_number[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
8940 _res = _PyPegen_ensure_imaginary ( p , imag );
8941 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
8942 p->error_indicator = 1;
8943 p->level--;
8944 return NULL;
8945 }
8946 goto done;
8947 }
8948 p->mark = _mark;
8949 D(fprintf(stderr, "%*c%s imaginary_number[%d-%d]: %s failed!\n", p->level, ' ',
8950 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));
8951 }
8952 _res = NULL;
8953 done:
8954 p->level--;
8955 return _res;
8956 }
8957
8958 // capture_pattern: pattern_capture_target
8959 static pattern_ty
8960 capture_pattern_rule(Parser *p)
8961 {
8962 if (p->level++ == MAXSTACK) {
8963 _Pypegen_stack_overflow(p);
8964 }
8965 if (p->error_indicator) {
8966 p->level--;
8967 return NULL;
8968 }
8969 pattern_ty _res = NULL;
8970 int _mark = p->mark;
8971 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
8972 p->error_indicator = 1;
8973 p->level--;
8974 return NULL;
8975 }
8976 int _start_lineno = p->tokens[_mark]->lineno;
8977 UNUSED(_start_lineno); // Only used by EXTRA macro
8978 int _start_col_offset = p->tokens[_mark]->col_offset;
8979 UNUSED(_start_col_offset); // Only used by EXTRA macro
8980 { // pattern_capture_target
8981 if (p->error_indicator) {
8982 p->level--;
8983 return NULL;
8984 }
8985 D(fprintf(stderr, "%*c> capture_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern_capture_target"));
8986 expr_ty target;
8987 if (
8988 (target = pattern_capture_target_rule(p)) // pattern_capture_target
8989 )
8990 {
8991 D(fprintf(stderr, "%*c+ capture_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern_capture_target"));
8992 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
8993 if (_token == NULL) {
8994 p->level--;
8995 return NULL;
8996 }
8997 int _end_lineno = _token->end_lineno;
8998 UNUSED(_end_lineno); // Only used by EXTRA macro
8999 int _end_col_offset = _token->end_col_offset;
9000 UNUSED(_end_col_offset); // Only used by EXTRA macro
9001 _res = _PyAST_MatchAs ( NULL , target -> v . Name . id , EXTRA );
9002 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9003 p->error_indicator = 1;
9004 p->level--;
9005 return NULL;
9006 }
9007 goto done;
9008 }
9009 p->mark = _mark;
9010 D(fprintf(stderr, "%*c%s capture_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9011 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern_capture_target"));
9012 }
9013 _res = NULL;
9014 done:
9015 p->level--;
9016 return _res;
9017 }
9018
9019 // pattern_capture_target: !"_" NAME !('.' | '(' | '=')
9020 static expr_ty
9021 pattern_capture_target_rule(Parser *p)
9022 {
9023 if (p->level++ == MAXSTACK) {
9024 _Pypegen_stack_overflow(p);
9025 }
9026 if (p->error_indicator) {
9027 p->level--;
9028 return NULL;
9029 }
9030 expr_ty _res = NULL;
9031 int _mark = p->mark;
9032 { // !"_" NAME !('.' | '(' | '=')
9033 if (p->error_indicator) {
9034 p->level--;
9035 return NULL;
9036 }
9037 D(fprintf(stderr, "%*c> pattern_capture_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')"));
9038 expr_ty name;
9039 if (
9040 _PyPegen_lookahead_with_string(0, _PyPegen_expect_soft_keyword, p, "_")
9041 &&
9042 (name = _PyPegen_name_token(p)) // NAME
9043 &&
9044 _PyPegen_lookahead(0, _tmp_69_rule, p)
9045 )
9046 {
9047 D(fprintf(stderr, "%*c+ pattern_capture_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')"));
9048 _res = _PyPegen_set_expr_context ( p , name , Store );
9049 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9050 p->error_indicator = 1;
9051 p->level--;
9052 return NULL;
9053 }
9054 goto done;
9055 }
9056 p->mark = _mark;
9057 D(fprintf(stderr, "%*c%s pattern_capture_target[%d-%d]: %s failed!\n", p->level, ' ',
9058 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!\"_\" NAME !('.' | '(' | '=')"));
9059 }
9060 _res = NULL;
9061 done:
9062 p->level--;
9063 return _res;
9064 }
9065
9066 // wildcard_pattern: "_"
9067 static pattern_ty
9068 wildcard_pattern_rule(Parser *p)
9069 {
9070 if (p->level++ == MAXSTACK) {
9071 _Pypegen_stack_overflow(p);
9072 }
9073 if (p->error_indicator) {
9074 p->level--;
9075 return NULL;
9076 }
9077 pattern_ty _res = NULL;
9078 int _mark = p->mark;
9079 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9080 p->error_indicator = 1;
9081 p->level--;
9082 return NULL;
9083 }
9084 int _start_lineno = p->tokens[_mark]->lineno;
9085 UNUSED(_start_lineno); // Only used by EXTRA macro
9086 int _start_col_offset = p->tokens[_mark]->col_offset;
9087 UNUSED(_start_col_offset); // Only used by EXTRA macro
9088 { // "_"
9089 if (p->error_indicator) {
9090 p->level--;
9091 return NULL;
9092 }
9093 D(fprintf(stderr, "%*c> wildcard_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"_\""));
9094 expr_ty _keyword;
9095 if (
9096 (_keyword = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"'
9097 )
9098 {
9099 D(fprintf(stderr, "%*c+ wildcard_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"_\""));
9100 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9101 if (_token == NULL) {
9102 p->level--;
9103 return NULL;
9104 }
9105 int _end_lineno = _token->end_lineno;
9106 UNUSED(_end_lineno); // Only used by EXTRA macro
9107 int _end_col_offset = _token->end_col_offset;
9108 UNUSED(_end_col_offset); // Only used by EXTRA macro
9109 _res = _PyAST_MatchAs ( NULL , NULL , EXTRA );
9110 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9111 p->error_indicator = 1;
9112 p->level--;
9113 return NULL;
9114 }
9115 goto done;
9116 }
9117 p->mark = _mark;
9118 D(fprintf(stderr, "%*c%s wildcard_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9119 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"_\""));
9120 }
9121 _res = NULL;
9122 done:
9123 p->level--;
9124 return _res;
9125 }
9126
9127 // value_pattern: attr !('.' | '(' | '=')
9128 static pattern_ty
9129 value_pattern_rule(Parser *p)
9130 {
9131 if (p->level++ == MAXSTACK) {
9132 _Pypegen_stack_overflow(p);
9133 }
9134 if (p->error_indicator) {
9135 p->level--;
9136 return NULL;
9137 }
9138 pattern_ty _res = NULL;
9139 int _mark = p->mark;
9140 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9141 p->error_indicator = 1;
9142 p->level--;
9143 return NULL;
9144 }
9145 int _start_lineno = p->tokens[_mark]->lineno;
9146 UNUSED(_start_lineno); // Only used by EXTRA macro
9147 int _start_col_offset = p->tokens[_mark]->col_offset;
9148 UNUSED(_start_col_offset); // Only used by EXTRA macro
9149 { // attr !('.' | '(' | '=')
9150 if (p->error_indicator) {
9151 p->level--;
9152 return NULL;
9153 }
9154 D(fprintf(stderr, "%*c> value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr !('.' | '(' | '=')"));
9155 expr_ty attr;
9156 if (
9157 (attr = attr_rule(p)) // attr
9158 &&
9159 _PyPegen_lookahead(0, _tmp_70_rule, p)
9160 )
9161 {
9162 D(fprintf(stderr, "%*c+ value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr !('.' | '(' | '=')"));
9163 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9164 if (_token == NULL) {
9165 p->level--;
9166 return NULL;
9167 }
9168 int _end_lineno = _token->end_lineno;
9169 UNUSED(_end_lineno); // Only used by EXTRA macro
9170 int _end_col_offset = _token->end_col_offset;
9171 UNUSED(_end_col_offset); // Only used by EXTRA macro
9172 _res = _PyAST_MatchValue ( attr , EXTRA );
9173 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9174 p->error_indicator = 1;
9175 p->level--;
9176 return NULL;
9177 }
9178 goto done;
9179 }
9180 p->mark = _mark;
9181 D(fprintf(stderr, "%*c%s value_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9182 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr !('.' | '(' | '=')"));
9183 }
9184 _res = NULL;
9185 done:
9186 p->level--;
9187 return _res;
9188 }
9189
9190 // Left-recursive
9191 // attr: name_or_attr '.' NAME
9192 static expr_ty attr_raw(Parser *);
9193 static expr_ty
9194 attr_rule(Parser *p)
9195 {
9196 if (p->level++ == MAXSTACK) {
9197 _Pypegen_stack_overflow(p);
9198 }
9199 expr_ty _res = NULL;
9200 if (_PyPegen_is_memoized(p, attr_type, &_res)) {
9201 p->level--;
9202 return _res;
9203 }
9204 int _mark = p->mark;
9205 int _resmark = p->mark;
9206 while (1) {
9207 int tmpvar_1 = _PyPegen_update_memo(p, _mark, attr_type, _res);
9208 if (tmpvar_1) {
9209 p->level--;
9210 return _res;
9211 }
9212 p->mark = _mark;
9213 void *_raw = attr_raw(p);
9214 if (p->error_indicator) {
9215 p->level--;
9216 return NULL;
9217 }
9218 if (_raw == NULL || p->mark <= _resmark)
9219 break;
9220 _resmark = p->mark;
9221 _res = _raw;
9222 }
9223 p->mark = _resmark;
9224 p->level--;
9225 return _res;
9226 }
9227 static expr_ty
9228 attr_raw(Parser *p)
9229 {
9230 if (p->level++ == MAXSTACK) {
9231 _Pypegen_stack_overflow(p);
9232 }
9233 if (p->error_indicator) {
9234 p->level--;
9235 return NULL;
9236 }
9237 expr_ty _res = NULL;
9238 int _mark = p->mark;
9239 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9240 p->error_indicator = 1;
9241 p->level--;
9242 return NULL;
9243 }
9244 int _start_lineno = p->tokens[_mark]->lineno;
9245 UNUSED(_start_lineno); // Only used by EXTRA macro
9246 int _start_col_offset = p->tokens[_mark]->col_offset;
9247 UNUSED(_start_col_offset); // Only used by EXTRA macro
9248 { // name_or_attr '.' NAME
9249 if (p->error_indicator) {
9250 p->level--;
9251 return NULL;
9252 }
9253 D(fprintf(stderr, "%*c> attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '.' NAME"));
9254 Token * _literal;
9255 expr_ty attr;
9256 expr_ty value;
9257 if (
9258 (value = name_or_attr_rule(p)) // name_or_attr
9259 &&
9260 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
9261 &&
9262 (attr = _PyPegen_name_token(p)) // NAME
9263 )
9264 {
9265 D(fprintf(stderr, "%*c+ attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '.' NAME"));
9266 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9267 if (_token == NULL) {
9268 p->level--;
9269 return NULL;
9270 }
9271 int _end_lineno = _token->end_lineno;
9272 UNUSED(_end_lineno); // Only used by EXTRA macro
9273 int _end_col_offset = _token->end_col_offset;
9274 UNUSED(_end_col_offset); // Only used by EXTRA macro
9275 _res = _PyAST_Attribute ( value , attr -> v . Name . id , Load , EXTRA );
9276 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9277 p->error_indicator = 1;
9278 p->level--;
9279 return NULL;
9280 }
9281 goto done;
9282 }
9283 p->mark = _mark;
9284 D(fprintf(stderr, "%*c%s attr[%d-%d]: %s failed!\n", p->level, ' ',
9285 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '.' NAME"));
9286 }
9287 _res = NULL;
9288 done:
9289 p->level--;
9290 return _res;
9291 }
9292
9293 // Left-recursive
9294 // name_or_attr: attr | NAME
9295 static expr_ty
9296 name_or_attr_rule(Parser *p)
9297 {
9298 if (p->level++ == MAXSTACK) {
9299 _Pypegen_stack_overflow(p);
9300 }
9301 if (p->error_indicator) {
9302 p->level--;
9303 return NULL;
9304 }
9305 expr_ty _res = NULL;
9306 int _mark = p->mark;
9307 { // attr
9308 if (p->error_indicator) {
9309 p->level--;
9310 return NULL;
9311 }
9312 D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr"));
9313 expr_ty attr_var;
9314 if (
9315 (attr_var = attr_rule(p)) // attr
9316 )
9317 {
9318 D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr"));
9319 _res = attr_var;
9320 goto done;
9321 }
9322 p->mark = _mark;
9323 D(fprintf(stderr, "%*c%s name_or_attr[%d-%d]: %s failed!\n", p->level, ' ',
9324 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr"));
9325 }
9326 { // NAME
9327 if (p->error_indicator) {
9328 p->level--;
9329 return NULL;
9330 }
9331 D(fprintf(stderr, "%*c> name_or_attr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
9332 expr_ty name_var;
9333 if (
9334 (name_var = _PyPegen_name_token(p)) // NAME
9335 )
9336 {
9337 D(fprintf(stderr, "%*c+ name_or_attr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
9338 _res = name_var;
9339 goto done;
9340 }
9341 p->mark = _mark;
9342 D(fprintf(stderr, "%*c%s name_or_attr[%d-%d]: %s failed!\n", p->level, ' ',
9343 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
9344 }
9345 _res = NULL;
9346 done:
9347 p->level--;
9348 return _res;
9349 }
9350
9351 // group_pattern: '(' pattern ')'
9352 static pattern_ty
9353 group_pattern_rule(Parser *p)
9354 {
9355 if (p->level++ == MAXSTACK) {
9356 _Pypegen_stack_overflow(p);
9357 }
9358 if (p->error_indicator) {
9359 p->level--;
9360 return NULL;
9361 }
9362 pattern_ty _res = NULL;
9363 int _mark = p->mark;
9364 { // '(' pattern ')'
9365 if (p->error_indicator) {
9366 p->level--;
9367 return NULL;
9368 }
9369 D(fprintf(stderr, "%*c> group_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' pattern ')'"));
9370 Token * _literal;
9371 Token * _literal_1;
9372 pattern_ty pattern;
9373 if (
9374 (_literal = _PyPegen_expect_token(p, 7)) // token='('
9375 &&
9376 (pattern = pattern_rule(p)) // pattern
9377 &&
9378 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
9379 )
9380 {
9381 D(fprintf(stderr, "%*c+ group_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' pattern ')'"));
9382 _res = pattern;
9383 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9384 p->error_indicator = 1;
9385 p->level--;
9386 return NULL;
9387 }
9388 goto done;
9389 }
9390 p->mark = _mark;
9391 D(fprintf(stderr, "%*c%s group_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9392 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' pattern ')'"));
9393 }
9394 _res = NULL;
9395 done:
9396 p->level--;
9397 return _res;
9398 }
9399
9400 // sequence_pattern: '[' maybe_sequence_pattern? ']' | '(' open_sequence_pattern? ')'
9401 static pattern_ty
9402 sequence_pattern_rule(Parser *p)
9403 {
9404 if (p->level++ == MAXSTACK) {
9405 _Pypegen_stack_overflow(p);
9406 }
9407 if (p->error_indicator) {
9408 p->level--;
9409 return NULL;
9410 }
9411 pattern_ty _res = NULL;
9412 int _mark = p->mark;
9413 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9414 p->error_indicator = 1;
9415 p->level--;
9416 return NULL;
9417 }
9418 int _start_lineno = p->tokens[_mark]->lineno;
9419 UNUSED(_start_lineno); // Only used by EXTRA macro
9420 int _start_col_offset = p->tokens[_mark]->col_offset;
9421 UNUSED(_start_col_offset); // Only used by EXTRA macro
9422 { // '[' maybe_sequence_pattern? ']'
9423 if (p->error_indicator) {
9424 p->level--;
9425 return NULL;
9426 }
9427 D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' maybe_sequence_pattern? ']'"));
9428 Token * _literal;
9429 Token * _literal_1;
9430 void *patterns;
9431 if (
9432 (_literal = _PyPegen_expect_token(p, 9)) // token='['
9433 &&
9434 (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator) // maybe_sequence_pattern?
9435 &&
9436 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
9437 )
9438 {
9439 D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' maybe_sequence_pattern? ']'"));
9440 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9441 if (_token == NULL) {
9442 p->level--;
9443 return NULL;
9444 }
9445 int _end_lineno = _token->end_lineno;
9446 UNUSED(_end_lineno); // Only used by EXTRA macro
9447 int _end_col_offset = _token->end_col_offset;
9448 UNUSED(_end_col_offset); // Only used by EXTRA macro
9449 _res = _PyAST_MatchSequence ( patterns , EXTRA );
9450 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9451 p->error_indicator = 1;
9452 p->level--;
9453 return NULL;
9454 }
9455 goto done;
9456 }
9457 p->mark = _mark;
9458 D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9459 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' maybe_sequence_pattern? ']'"));
9460 }
9461 { // '(' open_sequence_pattern? ')'
9462 if (p->error_indicator) {
9463 p->level--;
9464 return NULL;
9465 }
9466 D(fprintf(stderr, "%*c> sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' open_sequence_pattern? ')'"));
9467 Token * _literal;
9468 Token * _literal_1;
9469 void *patterns;
9470 if (
9471 (_literal = _PyPegen_expect_token(p, 7)) // token='('
9472 &&
9473 (patterns = open_sequence_pattern_rule(p), !p->error_indicator) // open_sequence_pattern?
9474 &&
9475 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
9476 )
9477 {
9478 D(fprintf(stderr, "%*c+ sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' open_sequence_pattern? ')'"));
9479 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9480 if (_token == NULL) {
9481 p->level--;
9482 return NULL;
9483 }
9484 int _end_lineno = _token->end_lineno;
9485 UNUSED(_end_lineno); // Only used by EXTRA macro
9486 int _end_col_offset = _token->end_col_offset;
9487 UNUSED(_end_col_offset); // Only used by EXTRA macro
9488 _res = _PyAST_MatchSequence ( patterns , EXTRA );
9489 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9490 p->error_indicator = 1;
9491 p->level--;
9492 return NULL;
9493 }
9494 goto done;
9495 }
9496 p->mark = _mark;
9497 D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9498 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' open_sequence_pattern? ')'"));
9499 }
9500 _res = NULL;
9501 done:
9502 p->level--;
9503 return _res;
9504 }
9505
9506 // open_sequence_pattern: maybe_star_pattern ',' maybe_sequence_pattern?
9507 static asdl_seq*
9508 open_sequence_pattern_rule(Parser *p)
9509 {
9510 if (p->level++ == MAXSTACK) {
9511 _Pypegen_stack_overflow(p);
9512 }
9513 if (p->error_indicator) {
9514 p->level--;
9515 return NULL;
9516 }
9517 asdl_seq* _res = NULL;
9518 int _mark = p->mark;
9519 { // maybe_star_pattern ',' maybe_sequence_pattern?
9520 if (p->error_indicator) {
9521 p->level--;
9522 return NULL;
9523 }
9524 D(fprintf(stderr, "%*c> open_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_pattern?"));
9525 Token * _literal;
9526 pattern_ty pattern;
9527 void *patterns;
9528 if (
9529 (pattern = maybe_star_pattern_rule(p)) // maybe_star_pattern
9530 &&
9531 (_literal = _PyPegen_expect_token(p, 12)) // token=','
9532 &&
9533 (patterns = maybe_sequence_pattern_rule(p), !p->error_indicator) // maybe_sequence_pattern?
9534 )
9535 {
9536 D(fprintf(stderr, "%*c+ open_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_pattern?"));
9537 _res = _PyPegen_seq_insert_in_front ( p , pattern , patterns );
9538 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9539 p->error_indicator = 1;
9540 p->level--;
9541 return NULL;
9542 }
9543 goto done;
9544 }
9545 p->mark = _mark;
9546 D(fprintf(stderr, "%*c%s open_sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9547 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern ',' maybe_sequence_pattern?"));
9548 }
9549 _res = NULL;
9550 done:
9551 p->level--;
9552 return _res;
9553 }
9554
9555 // maybe_sequence_pattern: ','.maybe_star_pattern+ ','?
9556 static asdl_seq*
9557 maybe_sequence_pattern_rule(Parser *p)
9558 {
9559 if (p->level++ == MAXSTACK) {
9560 _Pypegen_stack_overflow(p);
9561 }
9562 if (p->error_indicator) {
9563 p->level--;
9564 return NULL;
9565 }
9566 asdl_seq* _res = NULL;
9567 int _mark = p->mark;
9568 { // ','.maybe_star_pattern+ ','?
9569 if (p->error_indicator) {
9570 p->level--;
9571 return NULL;
9572 }
9573 D(fprintf(stderr, "%*c> maybe_sequence_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.maybe_star_pattern+ ','?"));
9574 void *_opt_var;
9575 UNUSED(_opt_var); // Silence compiler warnings
9576 asdl_seq * patterns;
9577 if (
9578 (patterns = _gather_71_rule(p)) // ','.maybe_star_pattern+
9579 &&
9580 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9581 )
9582 {
9583 D(fprintf(stderr, "%*c+ maybe_sequence_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.maybe_star_pattern+ ','?"));
9584 _res = patterns;
9585 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9586 p->error_indicator = 1;
9587 p->level--;
9588 return NULL;
9589 }
9590 goto done;
9591 }
9592 p->mark = _mark;
9593 D(fprintf(stderr, "%*c%s maybe_sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9594 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.maybe_star_pattern+ ','?"));
9595 }
9596 _res = NULL;
9597 done:
9598 p->level--;
9599 return _res;
9600 }
9601
9602 // maybe_star_pattern: star_pattern | pattern
9603 static pattern_ty
9604 maybe_star_pattern_rule(Parser *p)
9605 {
9606 if (p->level++ == MAXSTACK) {
9607 _Pypegen_stack_overflow(p);
9608 }
9609 if (p->error_indicator) {
9610 p->level--;
9611 return NULL;
9612 }
9613 pattern_ty _res = NULL;
9614 int _mark = p->mark;
9615 { // star_pattern
9616 if (p->error_indicator) {
9617 p->level--;
9618 return NULL;
9619 }
9620 D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_pattern"));
9621 pattern_ty star_pattern_var;
9622 if (
9623 (star_pattern_var = star_pattern_rule(p)) // star_pattern
9624 )
9625 {
9626 D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_pattern"));
9627 _res = star_pattern_var;
9628 goto done;
9629 }
9630 p->mark = _mark;
9631 D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9632 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_pattern"));
9633 }
9634 { // pattern
9635 if (p->error_indicator) {
9636 p->level--;
9637 return NULL;
9638 }
9639 D(fprintf(stderr, "%*c> maybe_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern"));
9640 pattern_ty pattern_var;
9641 if (
9642 (pattern_var = pattern_rule(p)) // pattern
9643 )
9644 {
9645 D(fprintf(stderr, "%*c+ maybe_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern"));
9646 _res = pattern_var;
9647 goto done;
9648 }
9649 p->mark = _mark;
9650 D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9651 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern"));
9652 }
9653 _res = NULL;
9654 done:
9655 p->level--;
9656 return _res;
9657 }
9658
9659 // star_pattern: '*' pattern_capture_target | '*' wildcard_pattern
9660 static pattern_ty
9661 star_pattern_rule(Parser *p)
9662 {
9663 if (p->level++ == MAXSTACK) {
9664 _Pypegen_stack_overflow(p);
9665 }
9666 if (p->error_indicator) {
9667 p->level--;
9668 return NULL;
9669 }
9670 pattern_ty _res = NULL;
9671 if (_PyPegen_is_memoized(p, star_pattern_type, &_res)) {
9672 p->level--;
9673 return _res;
9674 }
9675 int _mark = p->mark;
9676 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9677 p->error_indicator = 1;
9678 p->level--;
9679 return NULL;
9680 }
9681 int _start_lineno = p->tokens[_mark]->lineno;
9682 UNUSED(_start_lineno); // Only used by EXTRA macro
9683 int _start_col_offset = p->tokens[_mark]->col_offset;
9684 UNUSED(_start_col_offset); // Only used by EXTRA macro
9685 { // '*' pattern_capture_target
9686 if (p->error_indicator) {
9687 p->level--;
9688 return NULL;
9689 }
9690 D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' pattern_capture_target"));
9691 Token * _literal;
9692 expr_ty target;
9693 if (
9694 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
9695 &&
9696 (target = pattern_capture_target_rule(p)) // pattern_capture_target
9697 )
9698 {
9699 D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' pattern_capture_target"));
9700 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9701 if (_token == NULL) {
9702 p->level--;
9703 return NULL;
9704 }
9705 int _end_lineno = _token->end_lineno;
9706 UNUSED(_end_lineno); // Only used by EXTRA macro
9707 int _end_col_offset = _token->end_col_offset;
9708 UNUSED(_end_col_offset); // Only used by EXTRA macro
9709 _res = _PyAST_MatchStar ( target -> v . Name . id , EXTRA );
9710 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9711 p->error_indicator = 1;
9712 p->level--;
9713 return NULL;
9714 }
9715 goto done;
9716 }
9717 p->mark = _mark;
9718 D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9719 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' pattern_capture_target"));
9720 }
9721 { // '*' wildcard_pattern
9722 if (p->error_indicator) {
9723 p->level--;
9724 return NULL;
9725 }
9726 D(fprintf(stderr, "%*c> star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' wildcard_pattern"));
9727 Token * _literal;
9728 pattern_ty wildcard_pattern_var;
9729 if (
9730 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
9731 &&
9732 (wildcard_pattern_var = wildcard_pattern_rule(p)) // wildcard_pattern
9733 )
9734 {
9735 D(fprintf(stderr, "%*c+ star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' wildcard_pattern"));
9736 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9737 if (_token == NULL) {
9738 p->level--;
9739 return NULL;
9740 }
9741 int _end_lineno = _token->end_lineno;
9742 UNUSED(_end_lineno); // Only used by EXTRA macro
9743 int _end_col_offset = _token->end_col_offset;
9744 UNUSED(_end_col_offset); // Only used by EXTRA macro
9745 _res = _PyAST_MatchStar ( NULL , EXTRA );
9746 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9747 p->error_indicator = 1;
9748 p->level--;
9749 return NULL;
9750 }
9751 goto done;
9752 }
9753 p->mark = _mark;
9754 D(fprintf(stderr, "%*c%s star_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9755 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' wildcard_pattern"));
9756 }
9757 _res = NULL;
9758 done:
9759 _PyPegen_insert_memo(p, _mark, star_pattern_type, _res);
9760 p->level--;
9761 return _res;
9762 }
9763
9764 // mapping_pattern:
9765 // | '{' '}'
9766 // | '{' double_star_pattern ','? '}'
9767 // | '{' items_pattern ',' double_star_pattern ','? '}'
9768 // | '{' items_pattern ','? '}'
9769 static pattern_ty
9770 mapping_pattern_rule(Parser *p)
9771 {
9772 if (p->level++ == MAXSTACK) {
9773 _Pypegen_stack_overflow(p);
9774 }
9775 if (p->error_indicator) {
9776 p->level--;
9777 return NULL;
9778 }
9779 pattern_ty _res = NULL;
9780 int _mark = p->mark;
9781 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
9782 p->error_indicator = 1;
9783 p->level--;
9784 return NULL;
9785 }
9786 int _start_lineno = p->tokens[_mark]->lineno;
9787 UNUSED(_start_lineno); // Only used by EXTRA macro
9788 int _start_col_offset = p->tokens[_mark]->col_offset;
9789 UNUSED(_start_col_offset); // Only used by EXTRA macro
9790 { // '{' '}'
9791 if (p->error_indicator) {
9792 p->level--;
9793 return NULL;
9794 }
9795 D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'"));
9796 Token * _literal;
9797 Token * _literal_1;
9798 if (
9799 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9800 &&
9801 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
9802 )
9803 {
9804 D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'"));
9805 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9806 if (_token == NULL) {
9807 p->level--;
9808 return NULL;
9809 }
9810 int _end_lineno = _token->end_lineno;
9811 UNUSED(_end_lineno); // Only used by EXTRA macro
9812 int _end_col_offset = _token->end_col_offset;
9813 UNUSED(_end_col_offset); // Only used by EXTRA macro
9814 _res = _PyAST_MatchMapping ( NULL , NULL , NULL , EXTRA );
9815 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9816 p->error_indicator = 1;
9817 p->level--;
9818 return NULL;
9819 }
9820 goto done;
9821 }
9822 p->mark = _mark;
9823 D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9824 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '}'"));
9825 }
9826 { // '{' double_star_pattern ','? '}'
9827 if (p->error_indicator) {
9828 p->level--;
9829 return NULL;
9830 }
9831 D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_star_pattern ','? '}'"));
9832 Token * _literal;
9833 Token * _literal_1;
9834 void *_opt_var;
9835 UNUSED(_opt_var); // Silence compiler warnings
9836 expr_ty rest;
9837 if (
9838 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9839 &&
9840 (rest = double_star_pattern_rule(p)) // double_star_pattern
9841 &&
9842 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9843 &&
9844 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
9845 )
9846 {
9847 D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_star_pattern ','? '}'"));
9848 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9849 if (_token == NULL) {
9850 p->level--;
9851 return NULL;
9852 }
9853 int _end_lineno = _token->end_lineno;
9854 UNUSED(_end_lineno); // Only used by EXTRA macro
9855 int _end_col_offset = _token->end_col_offset;
9856 UNUSED(_end_col_offset); // Only used by EXTRA macro
9857 _res = _PyAST_MatchMapping ( NULL , NULL , rest -> v . Name . id , EXTRA );
9858 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9859 p->error_indicator = 1;
9860 p->level--;
9861 return NULL;
9862 }
9863 goto done;
9864 }
9865 p->mark = _mark;
9866 D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9867 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_star_pattern ','? '}'"));
9868 }
9869 { // '{' items_pattern ',' double_star_pattern ','? '}'
9870 if (p->error_indicator) {
9871 p->level--;
9872 return NULL;
9873 }
9874 D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'"));
9875 Token * _literal;
9876 Token * _literal_1;
9877 Token * _literal_2;
9878 void *_opt_var;
9879 UNUSED(_opt_var); // Silence compiler warnings
9880 asdl_seq* items;
9881 expr_ty rest;
9882 if (
9883 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9884 &&
9885 (items = items_pattern_rule(p)) // items_pattern
9886 &&
9887 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
9888 &&
9889 (rest = double_star_pattern_rule(p)) // double_star_pattern
9890 &&
9891 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9892 &&
9893 (_literal_2 = _PyPegen_expect_token(p, 26)) // token='}'
9894 )
9895 {
9896 D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'"));
9897 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9898 if (_token == NULL) {
9899 p->level--;
9900 return NULL;
9901 }
9902 int _end_lineno = _token->end_lineno;
9903 UNUSED(_end_lineno); // Only used by EXTRA macro
9904 int _end_col_offset = _token->end_col_offset;
9905 UNUSED(_end_col_offset); // Only used by EXTRA macro
9906 _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 );
9907 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9908 p->error_indicator = 1;
9909 p->level--;
9910 return NULL;
9911 }
9912 goto done;
9913 }
9914 p->mark = _mark;
9915 D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9916 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ',' double_star_pattern ','? '}'"));
9917 }
9918 { // '{' items_pattern ','? '}'
9919 if (p->error_indicator) {
9920 p->level--;
9921 return NULL;
9922 }
9923 D(fprintf(stderr, "%*c> mapping_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ','? '}'"));
9924 Token * _literal;
9925 Token * _literal_1;
9926 void *_opt_var;
9927 UNUSED(_opt_var); // Silence compiler warnings
9928 asdl_seq* items;
9929 if (
9930 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
9931 &&
9932 (items = items_pattern_rule(p)) // items_pattern
9933 &&
9934 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
9935 &&
9936 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
9937 )
9938 {
9939 D(fprintf(stderr, "%*c+ mapping_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' items_pattern ','? '}'"));
9940 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
9941 if (_token == NULL) {
9942 p->level--;
9943 return NULL;
9944 }
9945 int _end_lineno = _token->end_lineno;
9946 UNUSED(_end_lineno); // Only used by EXTRA macro
9947 int _end_col_offset = _token->end_col_offset;
9948 UNUSED(_end_col_offset); // Only used by EXTRA macro
9949 _res = _PyAST_MatchMapping ( CHECK ( asdl_expr_seq* , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq* , _PyPegen_get_patterns ( p , items ) ) , NULL , EXTRA );
9950 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
9951 p->error_indicator = 1;
9952 p->level--;
9953 return NULL;
9954 }
9955 goto done;
9956 }
9957 p->mark = _mark;
9958 D(fprintf(stderr, "%*c%s mapping_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9959 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' items_pattern ','? '}'"));
9960 }
9961 _res = NULL;
9962 done:
9963 p->level--;
9964 return _res;
9965 }
9966
9967 // items_pattern: ','.key_value_pattern+
9968 static asdl_seq*
9969 items_pattern_rule(Parser *p)
9970 {
9971 if (p->level++ == MAXSTACK) {
9972 _Pypegen_stack_overflow(p);
9973 }
9974 if (p->error_indicator) {
9975 p->level--;
9976 return NULL;
9977 }
9978 asdl_seq* _res = NULL;
9979 int _mark = p->mark;
9980 { // ','.key_value_pattern+
9981 if (p->error_indicator) {
9982 p->level--;
9983 return NULL;
9984 }
9985 D(fprintf(stderr, "%*c> items_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+"));
9986 asdl_seq * _gather_73_var;
9987 if (
9988 (_gather_73_var = _gather_73_rule(p)) // ','.key_value_pattern+
9989 )
9990 {
9991 D(fprintf(stderr, "%*c+ items_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.key_value_pattern+"));
9992 _res = _gather_73_var;
9993 goto done;
9994 }
9995 p->mark = _mark;
9996 D(fprintf(stderr, "%*c%s items_pattern[%d-%d]: %s failed!\n", p->level, ' ',
9997 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.key_value_pattern+"));
9998 }
9999 _res = NULL;
10000 done:
10001 p->level--;
10002 return _res;
10003 }
10004
10005 // key_value_pattern: (literal_expr | attr) ':' pattern
10006 static KeyPatternPair*
10007 key_value_pattern_rule(Parser *p)
10008 {
10009 if (p->level++ == MAXSTACK) {
10010 _Pypegen_stack_overflow(p);
10011 }
10012 if (p->error_indicator) {
10013 p->level--;
10014 return NULL;
10015 }
10016 KeyPatternPair* _res = NULL;
10017 int _mark = p->mark;
10018 { // (literal_expr | attr) ':' pattern
10019 if (p->error_indicator) {
10020 p->level--;
10021 return NULL;
10022 }
10023 D(fprintf(stderr, "%*c> key_value_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(literal_expr | attr) ':' pattern"));
10024 Token * _literal;
10025 void *key;
10026 pattern_ty pattern;
10027 if (
10028 (key = _tmp_75_rule(p)) // literal_expr | attr
10029 &&
10030 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
10031 &&
10032 (pattern = pattern_rule(p)) // pattern
10033 )
10034 {
10035 D(fprintf(stderr, "%*c+ key_value_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(literal_expr | attr) ':' pattern"));
10036 _res = _PyPegen_key_pattern_pair ( p , key , pattern );
10037 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10038 p->error_indicator = 1;
10039 p->level--;
10040 return NULL;
10041 }
10042 goto done;
10043 }
10044 p->mark = _mark;
10045 D(fprintf(stderr, "%*c%s key_value_pattern[%d-%d]: %s failed!\n", p->level, ' ',
10046 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(literal_expr | attr) ':' pattern"));
10047 }
10048 _res = NULL;
10049 done:
10050 p->level--;
10051 return _res;
10052 }
10053
10054 // double_star_pattern: '**' pattern_capture_target
10055 static expr_ty
10056 double_star_pattern_rule(Parser *p)
10057 {
10058 if (p->level++ == MAXSTACK) {
10059 _Pypegen_stack_overflow(p);
10060 }
10061 if (p->error_indicator) {
10062 p->level--;
10063 return NULL;
10064 }
10065 expr_ty _res = NULL;
10066 int _mark = p->mark;
10067 { // '**' pattern_capture_target
10068 if (p->error_indicator) {
10069 p->level--;
10070 return NULL;
10071 }
10072 D(fprintf(stderr, "%*c> double_star_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' pattern_capture_target"));
10073 Token * _literal;
10074 expr_ty target;
10075 if (
10076 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
10077 &&
10078 (target = pattern_capture_target_rule(p)) // pattern_capture_target
10079 )
10080 {
10081 D(fprintf(stderr, "%*c+ double_star_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' pattern_capture_target"));
10082 _res = target;
10083 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10084 p->error_indicator = 1;
10085 p->level--;
10086 return NULL;
10087 }
10088 goto done;
10089 }
10090 p->mark = _mark;
10091 D(fprintf(stderr, "%*c%s double_star_pattern[%d-%d]: %s failed!\n", p->level, ' ',
10092 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' pattern_capture_target"));
10093 }
10094 _res = NULL;
10095 done:
10096 p->level--;
10097 return _res;
10098 }
10099
10100 // class_pattern:
10101 // | name_or_attr '(' ')'
10102 // | name_or_attr '(' positional_patterns ','? ')'
10103 // | name_or_attr '(' keyword_patterns ','? ')'
10104 // | name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'
10105 // | invalid_class_pattern
10106 static pattern_ty
10107 class_pattern_rule(Parser *p)
10108 {
10109 if (p->level++ == MAXSTACK) {
10110 _Pypegen_stack_overflow(p);
10111 }
10112 if (p->error_indicator) {
10113 p->level--;
10114 return NULL;
10115 }
10116 pattern_ty _res = NULL;
10117 int _mark = p->mark;
10118 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10119 p->error_indicator = 1;
10120 p->level--;
10121 return NULL;
10122 }
10123 int _start_lineno = p->tokens[_mark]->lineno;
10124 UNUSED(_start_lineno); // Only used by EXTRA macro
10125 int _start_col_offset = p->tokens[_mark]->col_offset;
10126 UNUSED(_start_col_offset); // Only used by EXTRA macro
10127 { // name_or_attr '(' ')'
10128 if (p->error_indicator) {
10129 p->level--;
10130 return NULL;
10131 }
10132 D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' ')'"));
10133 Token * _literal;
10134 Token * _literal_1;
10135 expr_ty cls;
10136 if (
10137 (cls = name_or_attr_rule(p)) // name_or_attr
10138 &&
10139 (_literal = _PyPegen_expect_token(p, 7)) // token='('
10140 &&
10141 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
10142 )
10143 {
10144 D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' ')'"));
10145 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10146 if (_token == NULL) {
10147 p->level--;
10148 return NULL;
10149 }
10150 int _end_lineno = _token->end_lineno;
10151 UNUSED(_end_lineno); // Only used by EXTRA macro
10152 int _end_col_offset = _token->end_col_offset;
10153 UNUSED(_end_col_offset); // Only used by EXTRA macro
10154 _res = _PyAST_MatchClass ( cls , NULL , NULL , NULL , EXTRA );
10155 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10156 p->error_indicator = 1;
10157 p->level--;
10158 return NULL;
10159 }
10160 goto done;
10161 }
10162 p->mark = _mark;
10163 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',
10164 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' ')'"));
10165 }
10166 { // name_or_attr '(' positional_patterns ','? ')'
10167 if (p->error_indicator) {
10168 p->level--;
10169 return NULL;
10170 }
10171 D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' positional_patterns ','? ')'"));
10172 Token * _literal;
10173 Token * _literal_1;
10174 void *_opt_var;
10175 UNUSED(_opt_var); // Silence compiler warnings
10176 expr_ty cls;
10177 asdl_pattern_seq* patterns;
10178 if (
10179 (cls = name_or_attr_rule(p)) // name_or_attr
10180 &&
10181 (_literal = _PyPegen_expect_token(p, 7)) // token='('
10182 &&
10183 (patterns = positional_patterns_rule(p)) // positional_patterns
10184 &&
10185 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10186 &&
10187 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
10188 )
10189 {
10190 D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' positional_patterns ','? ')'"));
10191 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10192 if (_token == NULL) {
10193 p->level--;
10194 return NULL;
10195 }
10196 int _end_lineno = _token->end_lineno;
10197 UNUSED(_end_lineno); // Only used by EXTRA macro
10198 int _end_col_offset = _token->end_col_offset;
10199 UNUSED(_end_col_offset); // Only used by EXTRA macro
10200 _res = _PyAST_MatchClass ( cls , patterns , NULL , NULL , EXTRA );
10201 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10202 p->error_indicator = 1;
10203 p->level--;
10204 return NULL;
10205 }
10206 goto done;
10207 }
10208 p->mark = _mark;
10209 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',
10210 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' positional_patterns ','? ')'"));
10211 }
10212 { // name_or_attr '(' keyword_patterns ','? ')'
10213 if (p->error_indicator) {
10214 p->level--;
10215 return NULL;
10216 }
10217 D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'"));
10218 Token * _literal;
10219 Token * _literal_1;
10220 void *_opt_var;
10221 UNUSED(_opt_var); // Silence compiler warnings
10222 expr_ty cls;
10223 asdl_seq* keywords;
10224 if (
10225 (cls = name_or_attr_rule(p)) // name_or_attr
10226 &&
10227 (_literal = _PyPegen_expect_token(p, 7)) // token='('
10228 &&
10229 (keywords = keyword_patterns_rule(p)) // keyword_patterns
10230 &&
10231 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10232 &&
10233 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
10234 )
10235 {
10236 D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'"));
10237 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10238 if (_token == NULL) {
10239 p->level--;
10240 return NULL;
10241 }
10242 int _end_lineno = _token->end_lineno;
10243 UNUSED(_end_lineno); // Only used by EXTRA macro
10244 int _end_col_offset = _token->end_col_offset;
10245 UNUSED(_end_col_offset); // Only used by EXTRA macro
10246 _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 );
10247 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10248 p->error_indicator = 1;
10249 p->level--;
10250 return NULL;
10251 }
10252 goto done;
10253 }
10254 p->mark = _mark;
10255 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',
10256 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' keyword_patterns ','? ')'"));
10257 }
10258 { // name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'
10259 if (p->error_indicator) {
10260 p->level--;
10261 return NULL;
10262 }
10263 D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'"));
10264 Token * _literal;
10265 Token * _literal_1;
10266 Token * _literal_2;
10267 void *_opt_var;
10268 UNUSED(_opt_var); // Silence compiler warnings
10269 expr_ty cls;
10270 asdl_seq* keywords;
10271 asdl_pattern_seq* patterns;
10272 if (
10273 (cls = name_or_attr_rule(p)) // name_or_attr
10274 &&
10275 (_literal = _PyPegen_expect_token(p, 7)) // token='('
10276 &&
10277 (patterns = positional_patterns_rule(p)) // positional_patterns
10278 &&
10279 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
10280 &&
10281 (keywords = keyword_patterns_rule(p)) // keyword_patterns
10282 &&
10283 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10284 &&
10285 (_literal_2 = _PyPegen_expect_token(p, 8)) // token=')'
10286 )
10287 {
10288 D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'"));
10289 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10290 if (_token == NULL) {
10291 p->level--;
10292 return NULL;
10293 }
10294 int _end_lineno = _token->end_lineno;
10295 UNUSED(_end_lineno); // Only used by EXTRA macro
10296 int _end_col_offset = _token->end_col_offset;
10297 UNUSED(_end_col_offset); // Only used by EXTRA macro
10298 _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 );
10299 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10300 p->error_indicator = 1;
10301 p->level--;
10302 return NULL;
10303 }
10304 goto done;
10305 }
10306 p->mark = _mark;
10307 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',
10308 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')'"));
10309 }
10310 if (p->call_invalid_rules) { // invalid_class_pattern
10311 if (p->error_indicator) {
10312 p->level--;
10313 return NULL;
10314 }
10315 D(fprintf(stderr, "%*c> class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_class_pattern"));
10316 void *invalid_class_pattern_var;
10317 if (
10318 (invalid_class_pattern_var = invalid_class_pattern_rule(p)) // invalid_class_pattern
10319 )
10320 {
10321 D(fprintf(stderr, "%*c+ class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_class_pattern"));
10322 _res = invalid_class_pattern_var;
10323 goto done;
10324 }
10325 p->mark = _mark;
10326 D(fprintf(stderr, "%*c%s class_pattern[%d-%d]: %s failed!\n", p->level, ' ',
10327 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_class_pattern"));
10328 }
10329 _res = NULL;
10330 done:
10331 p->level--;
10332 return _res;
10333 }
10334
10335 // positional_patterns: ','.pattern+
10336 static asdl_pattern_seq*
10337 positional_patterns_rule(Parser *p)
10338 {
10339 if (p->level++ == MAXSTACK) {
10340 _Pypegen_stack_overflow(p);
10341 }
10342 if (p->error_indicator) {
10343 p->level--;
10344 return NULL;
10345 }
10346 asdl_pattern_seq* _res = NULL;
10347 int _mark = p->mark;
10348 { // ','.pattern+
10349 if (p->error_indicator) {
10350 p->level--;
10351 return NULL;
10352 }
10353 D(fprintf(stderr, "%*c> positional_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.pattern+"));
10354 asdl_pattern_seq* args;
10355 if (
10356 (args = (asdl_pattern_seq*)_gather_76_rule(p)) // ','.pattern+
10357 )
10358 {
10359 D(fprintf(stderr, "%*c+ positional_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.pattern+"));
10360 _res = args;
10361 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10362 p->error_indicator = 1;
10363 p->level--;
10364 return NULL;
10365 }
10366 goto done;
10367 }
10368 p->mark = _mark;
10369 D(fprintf(stderr, "%*c%s positional_patterns[%d-%d]: %s failed!\n", p->level, ' ',
10370 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.pattern+"));
10371 }
10372 _res = NULL;
10373 done:
10374 p->level--;
10375 return _res;
10376 }
10377
10378 // keyword_patterns: ','.keyword_pattern+
10379 static asdl_seq*
10380 keyword_patterns_rule(Parser *p)
10381 {
10382 if (p->level++ == MAXSTACK) {
10383 _Pypegen_stack_overflow(p);
10384 }
10385 if (p->error_indicator) {
10386 p->level--;
10387 return NULL;
10388 }
10389 asdl_seq* _res = NULL;
10390 int _mark = p->mark;
10391 { // ','.keyword_pattern+
10392 if (p->error_indicator) {
10393 p->level--;
10394 return NULL;
10395 }
10396 D(fprintf(stderr, "%*c> keyword_patterns[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+"));
10397 asdl_seq * _gather_78_var;
10398 if (
10399 (_gather_78_var = _gather_78_rule(p)) // ','.keyword_pattern+
10400 )
10401 {
10402 D(fprintf(stderr, "%*c+ keyword_patterns[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.keyword_pattern+"));
10403 _res = _gather_78_var;
10404 goto done;
10405 }
10406 p->mark = _mark;
10407 D(fprintf(stderr, "%*c%s keyword_patterns[%d-%d]: %s failed!\n", p->level, ' ',
10408 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.keyword_pattern+"));
10409 }
10410 _res = NULL;
10411 done:
10412 p->level--;
10413 return _res;
10414 }
10415
10416 // keyword_pattern: NAME '=' pattern
10417 static KeyPatternPair*
10418 keyword_pattern_rule(Parser *p)
10419 {
10420 if (p->level++ == MAXSTACK) {
10421 _Pypegen_stack_overflow(p);
10422 }
10423 if (p->error_indicator) {
10424 p->level--;
10425 return NULL;
10426 }
10427 KeyPatternPair* _res = NULL;
10428 int _mark = p->mark;
10429 { // NAME '=' pattern
10430 if (p->error_indicator) {
10431 p->level--;
10432 return NULL;
10433 }
10434 D(fprintf(stderr, "%*c> keyword_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' pattern"));
10435 Token * _literal;
10436 expr_ty arg;
10437 pattern_ty value;
10438 if (
10439 (arg = _PyPegen_name_token(p)) // NAME
10440 &&
10441 (_literal = _PyPegen_expect_token(p, 22)) // token='='
10442 &&
10443 (value = pattern_rule(p)) // pattern
10444 )
10445 {
10446 D(fprintf(stderr, "%*c+ keyword_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' pattern"));
10447 _res = _PyPegen_key_pattern_pair ( p , arg , value );
10448 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10449 p->error_indicator = 1;
10450 p->level--;
10451 return NULL;
10452 }
10453 goto done;
10454 }
10455 p->mark = _mark;
10456 D(fprintf(stderr, "%*c%s keyword_pattern[%d-%d]: %s failed!\n", p->level, ' ',
10457 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' pattern"));
10458 }
10459 _res = NULL;
10460 done:
10461 p->level--;
10462 return _res;
10463 }
10464
10465 // type_alias: "type" NAME type_params? '=' expression
10466 static stmt_ty
10467 type_alias_rule(Parser *p)
10468 {
10469 if (p->level++ == MAXSTACK) {
10470 _Pypegen_stack_overflow(p);
10471 }
10472 if (p->error_indicator) {
10473 p->level--;
10474 return NULL;
10475 }
10476 stmt_ty _res = NULL;
10477 int _mark = p->mark;
10478 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10479 p->error_indicator = 1;
10480 p->level--;
10481 return NULL;
10482 }
10483 int _start_lineno = p->tokens[_mark]->lineno;
10484 UNUSED(_start_lineno); // Only used by EXTRA macro
10485 int _start_col_offset = p->tokens[_mark]->col_offset;
10486 UNUSED(_start_col_offset); // Only used by EXTRA macro
10487 { // "type" NAME type_params? '=' expression
10488 if (p->error_indicator) {
10489 p->level--;
10490 return NULL;
10491 }
10492 D(fprintf(stderr, "%*c> type_alias[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"type\" NAME type_params? '=' expression"));
10493 expr_ty _keyword;
10494 Token * _literal;
10495 expr_ty b;
10496 expr_ty n;
10497 void *t;
10498 if (
10499 (_keyword = _PyPegen_expect_soft_keyword(p, "type")) // soft_keyword='"type"'
10500 &&
10501 (n = _PyPegen_name_token(p)) // NAME
10502 &&
10503 (t = type_params_rule(p), !p->error_indicator) // type_params?
10504 &&
10505 (_literal = _PyPegen_expect_token(p, 22)) // token='='
10506 &&
10507 (b = expression_rule(p)) // expression
10508 )
10509 {
10510 D(fprintf(stderr, "%*c+ type_alias[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"type\" NAME type_params? '=' expression"));
10511 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10512 if (_token == NULL) {
10513 p->level--;
10514 return NULL;
10515 }
10516 int _end_lineno = _token->end_lineno;
10517 UNUSED(_end_lineno); // Only used by EXTRA macro
10518 int _end_col_offset = _token->end_col_offset;
10519 UNUSED(_end_col_offset); // Only used by EXTRA macro
10520 _res = CHECK_VERSION ( stmt_ty , 12 , "Type statement is" , _PyAST_TypeAlias ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , n , Store ) ) , t , b , EXTRA ) );
10521 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10522 p->error_indicator = 1;
10523 p->level--;
10524 return NULL;
10525 }
10526 goto done;
10527 }
10528 p->mark = _mark;
10529 D(fprintf(stderr, "%*c%s type_alias[%d-%d]: %s failed!\n", p->level, ' ',
10530 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"type\" NAME type_params? '=' expression"));
10531 }
10532 _res = NULL;
10533 done:
10534 p->level--;
10535 return _res;
10536 }
10537
10538 // type_params: invalid_type_params | '[' type_param_seq ']'
10539 static asdl_type_param_seq*
10540 type_params_rule(Parser *p)
10541 {
10542 if (p->level++ == MAXSTACK) {
10543 _Pypegen_stack_overflow(p);
10544 }
10545 if (p->error_indicator) {
10546 p->level--;
10547 return NULL;
10548 }
10549 asdl_type_param_seq* _res = NULL;
10550 int _mark = p->mark;
10551 if (p->call_invalid_rules) { // invalid_type_params
10552 if (p->error_indicator) {
10553 p->level--;
10554 return NULL;
10555 }
10556 D(fprintf(stderr, "%*c> type_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_type_params"));
10557 void *invalid_type_params_var;
10558 if (
10559 (invalid_type_params_var = invalid_type_params_rule(p)) // invalid_type_params
10560 )
10561 {
10562 D(fprintf(stderr, "%*c+ type_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_type_params"));
10563 _res = invalid_type_params_var;
10564 goto done;
10565 }
10566 p->mark = _mark;
10567 D(fprintf(stderr, "%*c%s type_params[%d-%d]: %s failed!\n", p->level, ' ',
10568 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_type_params"));
10569 }
10570 { // '[' type_param_seq ']'
10571 if (p->error_indicator) {
10572 p->level--;
10573 return NULL;
10574 }
10575 D(fprintf(stderr, "%*c> type_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' type_param_seq ']'"));
10576 Token * _literal;
10577 Token * _literal_1;
10578 asdl_type_param_seq* t;
10579 if (
10580 (_literal = _PyPegen_expect_token(p, 9)) // token='['
10581 &&
10582 (t = type_param_seq_rule(p)) // type_param_seq
10583 &&
10584 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
10585 )
10586 {
10587 D(fprintf(stderr, "%*c+ type_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' type_param_seq ']'"));
10588 _res = CHECK_VERSION ( asdl_type_param_seq* , 12 , "Type parameter lists are" , t );
10589 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10590 p->error_indicator = 1;
10591 p->level--;
10592 return NULL;
10593 }
10594 goto done;
10595 }
10596 p->mark = _mark;
10597 D(fprintf(stderr, "%*c%s type_params[%d-%d]: %s failed!\n", p->level, ' ',
10598 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' type_param_seq ']'"));
10599 }
10600 _res = NULL;
10601 done:
10602 p->level--;
10603 return _res;
10604 }
10605
10606 // type_param_seq: ','.type_param+ ','?
10607 static asdl_type_param_seq*
10608 type_param_seq_rule(Parser *p)
10609 {
10610 if (p->level++ == MAXSTACK) {
10611 _Pypegen_stack_overflow(p);
10612 }
10613 if (p->error_indicator) {
10614 p->level--;
10615 return NULL;
10616 }
10617 asdl_type_param_seq* _res = NULL;
10618 int _mark = p->mark;
10619 { // ','.type_param+ ','?
10620 if (p->error_indicator) {
10621 p->level--;
10622 return NULL;
10623 }
10624 D(fprintf(stderr, "%*c> type_param_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.type_param+ ','?"));
10625 void *_opt_var;
10626 UNUSED(_opt_var); // Silence compiler warnings
10627 asdl_type_param_seq* a;
10628 if (
10629 (a = (asdl_type_param_seq*)_gather_80_rule(p)) // ','.type_param+
10630 &&
10631 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
10632 )
10633 {
10634 D(fprintf(stderr, "%*c+ type_param_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.type_param+ ','?"));
10635 _res = a;
10636 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10637 p->error_indicator = 1;
10638 p->level--;
10639 return NULL;
10640 }
10641 goto done;
10642 }
10643 p->mark = _mark;
10644 D(fprintf(stderr, "%*c%s type_param_seq[%d-%d]: %s failed!\n", p->level, ' ',
10645 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.type_param+ ','?"));
10646 }
10647 _res = NULL;
10648 done:
10649 p->level--;
10650 return _res;
10651 }
10652
10653 // type_param:
10654 // | NAME type_param_bound? type_param_default?
10655 // | '*' NAME ':' expression
10656 // | '*' NAME type_param_starred_default?
10657 // | '**' NAME ':' expression
10658 // | '**' NAME type_param_default?
10659 static type_param_ty
10660 type_param_rule(Parser *p)
10661 {
10662 if (p->level++ == MAXSTACK) {
10663 _Pypegen_stack_overflow(p);
10664 }
10665 if (p->error_indicator) {
10666 p->level--;
10667 return NULL;
10668 }
10669 type_param_ty _res = NULL;
10670 if (_PyPegen_is_memoized(p, type_param_type, &_res)) {
10671 p->level--;
10672 return _res;
10673 }
10674 int _mark = p->mark;
10675 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
10676 p->error_indicator = 1;
10677 p->level--;
10678 return NULL;
10679 }
10680 int _start_lineno = p->tokens[_mark]->lineno;
10681 UNUSED(_start_lineno); // Only used by EXTRA macro
10682 int _start_col_offset = p->tokens[_mark]->col_offset;
10683 UNUSED(_start_col_offset); // Only used by EXTRA macro
10684 { // NAME type_param_bound? type_param_default?
10685 if (p->error_indicator) {
10686 p->level--;
10687 return NULL;
10688 }
10689 D(fprintf(stderr, "%*c> type_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME type_param_bound? type_param_default?"));
10690 expr_ty a;
10691 void *b;
10692 void *c;
10693 if (
10694 (a = _PyPegen_name_token(p)) // NAME
10695 &&
10696 (b = type_param_bound_rule(p), !p->error_indicator) // type_param_bound?
10697 &&
10698 (c = type_param_default_rule(p), !p->error_indicator) // type_param_default?
10699 )
10700 {
10701 D(fprintf(stderr, "%*c+ type_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME type_param_bound? type_param_default?"));
10702 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10703 if (_token == NULL) {
10704 p->level--;
10705 return NULL;
10706 }
10707 int _end_lineno = _token->end_lineno;
10708 UNUSED(_end_lineno); // Only used by EXTRA macro
10709 int _end_col_offset = _token->end_col_offset;
10710 UNUSED(_end_col_offset); // Only used by EXTRA macro
10711 _res = _PyAST_TypeVar ( a -> v . Name . id , b , c , EXTRA );
10712 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10713 p->error_indicator = 1;
10714 p->level--;
10715 return NULL;
10716 }
10717 goto done;
10718 }
10719 p->mark = _mark;
10720 D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
10721 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME type_param_bound? type_param_default?"));
10722 }
10723 { // '*' NAME ':' expression
10724 if (p->error_indicator) {
10725 p->level--;
10726 return NULL;
10727 }
10728 D(fprintf(stderr, "%*c> type_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' NAME ':' expression"));
10729 Token * _literal;
10730 expr_ty a;
10731 Token * colon;
10732 expr_ty e;
10733 if (
10734 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
10735 &&
10736 (a = _PyPegen_name_token(p)) // NAME
10737 &&
10738 (colon = _PyPegen_expect_token(p, 11)) // token=':'
10739 &&
10740 (e = expression_rule(p)) // expression
10741 )
10742 {
10743 D(fprintf(stderr, "%*c+ type_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' NAME ':' expression"));
10744 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( colon , e -> kind == Tuple_kind ? "cannot use constraints with TypeVarTuple" : "cannot use bound with TypeVarTuple" );
10745 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10746 p->error_indicator = 1;
10747 p->level--;
10748 return NULL;
10749 }
10750 goto done;
10751 }
10752 p->mark = _mark;
10753 D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
10754 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' NAME ':' expression"));
10755 }
10756 { // '*' NAME type_param_starred_default?
10757 if (p->error_indicator) {
10758 p->level--;
10759 return NULL;
10760 }
10761 D(fprintf(stderr, "%*c> type_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' NAME type_param_starred_default?"));
10762 Token * _literal;
10763 expr_ty a;
10764 void *b;
10765 if (
10766 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
10767 &&
10768 (a = _PyPegen_name_token(p)) // NAME
10769 &&
10770 (b = type_param_starred_default_rule(p), !p->error_indicator) // type_param_starred_default?
10771 )
10772 {
10773 D(fprintf(stderr, "%*c+ type_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' NAME type_param_starred_default?"));
10774 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10775 if (_token == NULL) {
10776 p->level--;
10777 return NULL;
10778 }
10779 int _end_lineno = _token->end_lineno;
10780 UNUSED(_end_lineno); // Only used by EXTRA macro
10781 int _end_col_offset = _token->end_col_offset;
10782 UNUSED(_end_col_offset); // Only used by EXTRA macro
10783 _res = _PyAST_TypeVarTuple ( a -> v . Name . id , b , EXTRA );
10784 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10785 p->error_indicator = 1;
10786 p->level--;
10787 return NULL;
10788 }
10789 goto done;
10790 }
10791 p->mark = _mark;
10792 D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
10793 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' NAME type_param_starred_default?"));
10794 }
10795 { // '**' NAME ':' expression
10796 if (p->error_indicator) {
10797 p->level--;
10798 return NULL;
10799 }
10800 D(fprintf(stderr, "%*c> type_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' NAME ':' expression"));
10801 Token * _literal;
10802 expr_ty a;
10803 Token * colon;
10804 expr_ty e;
10805 if (
10806 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
10807 &&
10808 (a = _PyPegen_name_token(p)) // NAME
10809 &&
10810 (colon = _PyPegen_expect_token(p, 11)) // token=':'
10811 &&
10812 (e = expression_rule(p)) // expression
10813 )
10814 {
10815 D(fprintf(stderr, "%*c+ type_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' NAME ':' expression"));
10816 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( colon , e -> kind == Tuple_kind ? "cannot use constraints with ParamSpec" : "cannot use bound with ParamSpec" );
10817 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10818 p->error_indicator = 1;
10819 p->level--;
10820 return NULL;
10821 }
10822 goto done;
10823 }
10824 p->mark = _mark;
10825 D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
10826 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' NAME ':' expression"));
10827 }
10828 { // '**' NAME type_param_default?
10829 if (p->error_indicator) {
10830 p->level--;
10831 return NULL;
10832 }
10833 D(fprintf(stderr, "%*c> type_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' NAME type_param_default?"));
10834 Token * _literal;
10835 expr_ty a;
10836 void *b;
10837 if (
10838 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
10839 &&
10840 (a = _PyPegen_name_token(p)) // NAME
10841 &&
10842 (b = type_param_default_rule(p), !p->error_indicator) // type_param_default?
10843 )
10844 {
10845 D(fprintf(stderr, "%*c+ type_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' NAME type_param_default?"));
10846 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
10847 if (_token == NULL) {
10848 p->level--;
10849 return NULL;
10850 }
10851 int _end_lineno = _token->end_lineno;
10852 UNUSED(_end_lineno); // Only used by EXTRA macro
10853 int _end_col_offset = _token->end_col_offset;
10854 UNUSED(_end_col_offset); // Only used by EXTRA macro
10855 _res = _PyAST_ParamSpec ( a -> v . Name . id , b , EXTRA );
10856 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10857 p->error_indicator = 1;
10858 p->level--;
10859 return NULL;
10860 }
10861 goto done;
10862 }
10863 p->mark = _mark;
10864 D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
10865 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' NAME type_param_default?"));
10866 }
10867 _res = NULL;
10868 done:
10869 _PyPegen_insert_memo(p, _mark, type_param_type, _res);
10870 p->level--;
10871 return _res;
10872 }
10873
10874 // type_param_bound: ':' expression
10875 static expr_ty
10876 type_param_bound_rule(Parser *p)
10877 {
10878 if (p->level++ == MAXSTACK) {
10879 _Pypegen_stack_overflow(p);
10880 }
10881 if (p->error_indicator) {
10882 p->level--;
10883 return NULL;
10884 }
10885 expr_ty _res = NULL;
10886 int _mark = p->mark;
10887 { // ':' expression
10888 if (p->error_indicator) {
10889 p->level--;
10890 return NULL;
10891 }
10892 D(fprintf(stderr, "%*c> type_param_bound[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression"));
10893 Token * _literal;
10894 expr_ty e;
10895 if (
10896 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
10897 &&
10898 (e = expression_rule(p)) // expression
10899 )
10900 {
10901 D(fprintf(stderr, "%*c+ type_param_bound[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression"));
10902 _res = e;
10903 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10904 p->error_indicator = 1;
10905 p->level--;
10906 return NULL;
10907 }
10908 goto done;
10909 }
10910 p->mark = _mark;
10911 D(fprintf(stderr, "%*c%s type_param_bound[%d-%d]: %s failed!\n", p->level, ' ',
10912 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression"));
10913 }
10914 _res = NULL;
10915 done:
10916 p->level--;
10917 return _res;
10918 }
10919
10920 // type_param_default: '=' expression
10921 static expr_ty
10922 type_param_default_rule(Parser *p)
10923 {
10924 if (p->level++ == MAXSTACK) {
10925 _Pypegen_stack_overflow(p);
10926 }
10927 if (p->error_indicator) {
10928 p->level--;
10929 return NULL;
10930 }
10931 expr_ty _res = NULL;
10932 int _mark = p->mark;
10933 { // '=' expression
10934 if (p->error_indicator) {
10935 p->level--;
10936 return NULL;
10937 }
10938 D(fprintf(stderr, "%*c> type_param_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression"));
10939 Token * _literal;
10940 expr_ty e;
10941 if (
10942 (_literal = _PyPegen_expect_token(p, 22)) // token='='
10943 &&
10944 (e = expression_rule(p)) // expression
10945 )
10946 {
10947 D(fprintf(stderr, "%*c+ type_param_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expression"));
10948 _res = CHECK_VERSION ( expr_ty , 13 , "Type parameter defaults are" , e );
10949 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10950 p->error_indicator = 1;
10951 p->level--;
10952 return NULL;
10953 }
10954 goto done;
10955 }
10956 p->mark = _mark;
10957 D(fprintf(stderr, "%*c%s type_param_default[%d-%d]: %s failed!\n", p->level, ' ',
10958 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' expression"));
10959 }
10960 _res = NULL;
10961 done:
10962 p->level--;
10963 return _res;
10964 }
10965
10966 // type_param_starred_default: '=' star_expression
10967 static expr_ty
10968 type_param_starred_default_rule(Parser *p)
10969 {
10970 if (p->level++ == MAXSTACK) {
10971 _Pypegen_stack_overflow(p);
10972 }
10973 if (p->error_indicator) {
10974 p->level--;
10975 return NULL;
10976 }
10977 expr_ty _res = NULL;
10978 int _mark = p->mark;
10979 { // '=' star_expression
10980 if (p->error_indicator) {
10981 p->level--;
10982 return NULL;
10983 }
10984 D(fprintf(stderr, "%*c> type_param_starred_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' star_expression"));
10985 Token * _literal;
10986 expr_ty e;
10987 if (
10988 (_literal = _PyPegen_expect_token(p, 22)) // token='='
10989 &&
10990 (e = star_expression_rule(p)) // star_expression
10991 )
10992 {
10993 D(fprintf(stderr, "%*c+ type_param_starred_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' star_expression"));
10994 _res = CHECK_VERSION ( expr_ty , 13 , "Type parameter defaults are" , e );
10995 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
10996 p->error_indicator = 1;
10997 p->level--;
10998 return NULL;
10999 }
11000 goto done;
11001 }
11002 p->mark = _mark;
11003 D(fprintf(stderr, "%*c%s type_param_starred_default[%d-%d]: %s failed!\n", p->level, ' ',
11004 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' star_expression"));
11005 }
11006 _res = NULL;
11007 done:
11008 p->level--;
11009 return _res;
11010 }
11011
11012 // expressions: expression ((',' expression))+ ','? | expression ',' | expression
11013 static expr_ty
11014 expressions_rule(Parser *p)
11015 {
11016 if (p->level++ == MAXSTACK) {
11017 _Pypegen_stack_overflow(p);
11018 }
11019 if (p->error_indicator) {
11020 p->level--;
11021 return NULL;
11022 }
11023 expr_ty _res = NULL;
11024 int _mark = p->mark;
11025 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11026 p->error_indicator = 1;
11027 p->level--;
11028 return NULL;
11029 }
11030 int _start_lineno = p->tokens[_mark]->lineno;
11031 UNUSED(_start_lineno); // Only used by EXTRA macro
11032 int _start_col_offset = p->tokens[_mark]->col_offset;
11033 UNUSED(_start_col_offset); // Only used by EXTRA macro
11034 { // expression ((',' expression))+ ','?
11035 if (p->error_indicator) {
11036 p->level--;
11037 return NULL;
11038 }
11039 D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?"));
11040 void *_opt_var;
11041 UNUSED(_opt_var); // Silence compiler warnings
11042 expr_ty a;
11043 asdl_seq * b;
11044 if (
11045 (a = expression_rule(p)) // expression
11046 &&
11047 (b = _loop1_82_rule(p)) // ((',' expression))+
11048 &&
11049 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
11050 )
11051 {
11052 D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?"));
11053 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11054 if (_token == NULL) {
11055 p->level--;
11056 return NULL;
11057 }
11058 int _end_lineno = _token->end_lineno;
11059 UNUSED(_end_lineno); // Only used by EXTRA macro
11060 int _end_col_offset = _token->end_col_offset;
11061 UNUSED(_end_col_offset); // Only used by EXTRA macro
11062 _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
11063 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11064 p->error_indicator = 1;
11065 p->level--;
11066 return NULL;
11067 }
11068 goto done;
11069 }
11070 p->mark = _mark;
11071 D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',
11072 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ((',' expression))+ ','?"));
11073 }
11074 { // expression ','
11075 if (p->error_indicator) {
11076 p->level--;
11077 return NULL;
11078 }
11079 D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ','"));
11080 Token * _literal;
11081 expr_ty a;
11082 if (
11083 (a = expression_rule(p)) // expression
11084 &&
11085 (_literal = _PyPegen_expect_token(p, 12)) // token=','
11086 )
11087 {
11088 D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ','"));
11089 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11090 if (_token == NULL) {
11091 p->level--;
11092 return NULL;
11093 }
11094 int _end_lineno = _token->end_lineno;
11095 UNUSED(_end_lineno); // Only used by EXTRA macro
11096 int _end_col_offset = _token->end_col_offset;
11097 UNUSED(_end_col_offset); // Only used by EXTRA macro
11098 _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
11099 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11100 p->error_indicator = 1;
11101 p->level--;
11102 return NULL;
11103 }
11104 goto done;
11105 }
11106 p->mark = _mark;
11107 D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',
11108 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ','"));
11109 }
11110 { // expression
11111 if (p->error_indicator) {
11112 p->level--;
11113 return NULL;
11114 }
11115 D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
11116 expr_ty expression_var;
11117 if (
11118 (expression_var = expression_rule(p)) // expression
11119 )
11120 {
11121 D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
11122 _res = expression_var;
11123 goto done;
11124 }
11125 p->mark = _mark;
11126 D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',
11127 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
11128 }
11129 _res = NULL;
11130 done:
11131 p->level--;
11132 return _res;
11133 }
11134
11135 // expression:
11136 // | invalid_expression
11137 // | invalid_legacy_expression
11138 // | disjunction 'if' disjunction 'else' expression
11139 // | disjunction
11140 // | lambdef
11141 static expr_ty
11142 expression_rule(Parser *p)
11143 {
11144 if (p->level++ == MAXSTACK) {
11145 _Pypegen_stack_overflow(p);
11146 }
11147 if (p->error_indicator) {
11148 p->level--;
11149 return NULL;
11150 }
11151 expr_ty _res = NULL;
11152 if (_PyPegen_is_memoized(p, expression_type, &_res)) {
11153 p->level--;
11154 return _res;
11155 }
11156 int _mark = p->mark;
11157 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11158 p->error_indicator = 1;
11159 p->level--;
11160 return NULL;
11161 }
11162 int _start_lineno = p->tokens[_mark]->lineno;
11163 UNUSED(_start_lineno); // Only used by EXTRA macro
11164 int _start_col_offset = p->tokens[_mark]->col_offset;
11165 UNUSED(_start_col_offset); // Only used by EXTRA macro
11166 if (p->call_invalid_rules) { // invalid_expression
11167 if (p->error_indicator) {
11168 p->level--;
11169 return NULL;
11170 }
11171 D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_expression"));
11172 void *invalid_expression_var;
11173 if (
11174 (invalid_expression_var = invalid_expression_rule(p)) // invalid_expression
11175 )
11176 {
11177 D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_expression"));
11178 _res = invalid_expression_var;
11179 goto done;
11180 }
11181 p->mark = _mark;
11182 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
11183 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_expression"));
11184 }
11185 if (p->call_invalid_rules) { // invalid_legacy_expression
11186 if (p->error_indicator) {
11187 p->level--;
11188 return NULL;
11189 }
11190 D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_legacy_expression"));
11191 void *invalid_legacy_expression_var;
11192 if (
11193 (invalid_legacy_expression_var = invalid_legacy_expression_rule(p)) // invalid_legacy_expression
11194 )
11195 {
11196 D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_legacy_expression"));
11197 _res = invalid_legacy_expression_var;
11198 goto done;
11199 }
11200 p->mark = _mark;
11201 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
11202 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_legacy_expression"));
11203 }
11204 { // disjunction 'if' disjunction 'else' expression
11205 if (p->error_indicator) {
11206 p->level--;
11207 return NULL;
11208 }
11209 D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
11210 Token * _keyword;
11211 Token * _keyword_1;
11212 expr_ty a;
11213 expr_ty b;
11214 expr_ty c;
11215 if (
11216 (a = disjunction_rule(p)) // disjunction
11217 &&
11218 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
11219 &&
11220 (b = disjunction_rule(p)) // disjunction
11221 &&
11222 (_keyword_1 = _PyPegen_expect_token(p, 663)) // token='else'
11223 &&
11224 (c = expression_rule(p)) // expression
11225 )
11226 {
11227 D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
11228 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11229 if (_token == NULL) {
11230 p->level--;
11231 return NULL;
11232 }
11233 int _end_lineno = _token->end_lineno;
11234 UNUSED(_end_lineno); // Only used by EXTRA macro
11235 int _end_col_offset = _token->end_col_offset;
11236 UNUSED(_end_col_offset); // Only used by EXTRA macro
11237 _res = _PyAST_IfExp ( b , a , c , EXTRA );
11238 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11239 p->error_indicator = 1;
11240 p->level--;
11241 return NULL;
11242 }
11243 goto done;
11244 }
11245 p->mark = _mark;
11246 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
11247 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
11248 }
11249 { // disjunction
11250 if (p->error_indicator) {
11251 p->level--;
11252 return NULL;
11253 }
11254 D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction"));
11255 expr_ty disjunction_var;
11256 if (
11257 (disjunction_var = disjunction_rule(p)) // disjunction
11258 )
11259 {
11260 D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction"));
11261 _res = disjunction_var;
11262 goto done;
11263 }
11264 p->mark = _mark;
11265 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
11266 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction"));
11267 }
11268 { // lambdef
11269 if (p->error_indicator) {
11270 p->level--;
11271 return NULL;
11272 }
11273 D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef"));
11274 expr_ty lambdef_var;
11275 if (
11276 (lambdef_var = lambdef_rule(p)) // lambdef
11277 )
11278 {
11279 D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef"));
11280 _res = lambdef_var;
11281 goto done;
11282 }
11283 p->mark = _mark;
11284 D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
11285 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef"));
11286 }
11287 _res = NULL;
11288 done:
11289 _PyPegen_insert_memo(p, _mark, expression_type, _res);
11290 p->level--;
11291 return _res;
11292 }
11293
11294 // yield_expr: 'yield' 'from' expression | 'yield' star_expressions?
11295 static expr_ty
11296 yield_expr_rule(Parser *p)
11297 {
11298 if (p->level++ == MAXSTACK) {
11299 _Pypegen_stack_overflow(p);
11300 }
11301 if (p->error_indicator) {
11302 p->level--;
11303 return NULL;
11304 }
11305 expr_ty _res = NULL;
11306 int _mark = p->mark;
11307 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11308 p->error_indicator = 1;
11309 p->level--;
11310 return NULL;
11311 }
11312 int _start_lineno = p->tokens[_mark]->lineno;
11313 UNUSED(_start_lineno); // Only used by EXTRA macro
11314 int _start_col_offset = p->tokens[_mark]->col_offset;
11315 UNUSED(_start_col_offset); // Only used by EXTRA macro
11316 { // 'yield' 'from' expression
11317 if (p->error_indicator) {
11318 p->level--;
11319 return NULL;
11320 }
11321 D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression"));
11322 Token * _keyword;
11323 Token * _keyword_1;
11324 expr_ty a;
11325 if (
11326 (_keyword = _PyPegen_expect_token(p, 580)) // token='yield'
11327 &&
11328 (_keyword_1 = _PyPegen_expect_token(p, 621)) // token='from'
11329 &&
11330 (a = expression_rule(p)) // expression
11331 )
11332 {
11333 D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression"));
11334 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11335 if (_token == NULL) {
11336 p->level--;
11337 return NULL;
11338 }
11339 int _end_lineno = _token->end_lineno;
11340 UNUSED(_end_lineno); // Only used by EXTRA macro
11341 int _end_col_offset = _token->end_col_offset;
11342 UNUSED(_end_col_offset); // Only used by EXTRA macro
11343 _res = _PyAST_YieldFrom ( a , EXTRA );
11344 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11345 p->error_indicator = 1;
11346 p->level--;
11347 return NULL;
11348 }
11349 goto done;
11350 }
11351 p->mark = _mark;
11352 D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ',
11353 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' 'from' expression"));
11354 }
11355 { // 'yield' star_expressions?
11356 if (p->error_indicator) {
11357 p->level--;
11358 return NULL;
11359 }
11360 D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?"));
11361 Token * _keyword;
11362 void *a;
11363 if (
11364 (_keyword = _PyPegen_expect_token(p, 580)) // token='yield'
11365 &&
11366 (a = star_expressions_rule(p), !p->error_indicator) // star_expressions?
11367 )
11368 {
11369 D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?"));
11370 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11371 if (_token == NULL) {
11372 p->level--;
11373 return NULL;
11374 }
11375 int _end_lineno = _token->end_lineno;
11376 UNUSED(_end_lineno); // Only used by EXTRA macro
11377 int _end_col_offset = _token->end_col_offset;
11378 UNUSED(_end_col_offset); // Only used by EXTRA macro
11379 _res = _PyAST_Yield ( a , EXTRA );
11380 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11381 p->error_indicator = 1;
11382 p->level--;
11383 return NULL;
11384 }
11385 goto done;
11386 }
11387 p->mark = _mark;
11388 D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ',
11389 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' star_expressions?"));
11390 }
11391 _res = NULL;
11392 done:
11393 p->level--;
11394 return _res;
11395 }
11396
11397 // star_expressions:
11398 // | star_expression ((',' star_expression))+ ','?
11399 // | star_expression ','
11400 // | star_expression
11401 static expr_ty
11402 star_expressions_rule(Parser *p)
11403 {
11404 if (p->level++ == MAXSTACK) {
11405 _Pypegen_stack_overflow(p);
11406 }
11407 if (p->error_indicator) {
11408 p->level--;
11409 return NULL;
11410 }
11411 expr_ty _res = NULL;
11412 int _mark = p->mark;
11413 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11414 p->error_indicator = 1;
11415 p->level--;
11416 return NULL;
11417 }
11418 int _start_lineno = p->tokens[_mark]->lineno;
11419 UNUSED(_start_lineno); // Only used by EXTRA macro
11420 int _start_col_offset = p->tokens[_mark]->col_offset;
11421 UNUSED(_start_col_offset); // Only used by EXTRA macro
11422 { // star_expression ((',' star_expression))+ ','?
11423 if (p->error_indicator) {
11424 p->level--;
11425 return NULL;
11426 }
11427 D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
11428 void *_opt_var;
11429 UNUSED(_opt_var); // Silence compiler warnings
11430 expr_ty a;
11431 asdl_seq * b;
11432 if (
11433 (a = star_expression_rule(p)) // star_expression
11434 &&
11435 (b = _loop1_83_rule(p)) // ((',' star_expression))+
11436 &&
11437 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
11438 )
11439 {
11440 D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
11441 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11442 if (_token == NULL) {
11443 p->level--;
11444 return NULL;
11445 }
11446 int _end_lineno = _token->end_lineno;
11447 UNUSED(_end_lineno); // Only used by EXTRA macro
11448 int _end_col_offset = _token->end_col_offset;
11449 UNUSED(_end_col_offset); // Only used by EXTRA macro
11450 _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
11451 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11452 p->error_indicator = 1;
11453 p->level--;
11454 return NULL;
11455 }
11456 goto done;
11457 }
11458 p->mark = _mark;
11459 D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',
11460 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
11461 }
11462 { // star_expression ','
11463 if (p->error_indicator) {
11464 p->level--;
11465 return NULL;
11466 }
11467 D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ','"));
11468 Token * _literal;
11469 expr_ty a;
11470 if (
11471 (a = star_expression_rule(p)) // star_expression
11472 &&
11473 (_literal = _PyPegen_expect_token(p, 12)) // token=','
11474 )
11475 {
11476 D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ','"));
11477 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11478 if (_token == NULL) {
11479 p->level--;
11480 return NULL;
11481 }
11482 int _end_lineno = _token->end_lineno;
11483 UNUSED(_end_lineno); // Only used by EXTRA macro
11484 int _end_col_offset = _token->end_col_offset;
11485 UNUSED(_end_col_offset); // Only used by EXTRA macro
11486 _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
11487 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11488 p->error_indicator = 1;
11489 p->level--;
11490 return NULL;
11491 }
11492 goto done;
11493 }
11494 p->mark = _mark;
11495 D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',
11496 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ','"));
11497 }
11498 { // star_expression
11499 if (p->error_indicator) {
11500 p->level--;
11501 return NULL;
11502 }
11503 D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression"));
11504 expr_ty star_expression_var;
11505 if (
11506 (star_expression_var = star_expression_rule(p)) // star_expression
11507 )
11508 {
11509 D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression"));
11510 _res = star_expression_var;
11511 goto done;
11512 }
11513 p->mark = _mark;
11514 D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',
11515 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression"));
11516 }
11517 _res = NULL;
11518 done:
11519 p->level--;
11520 return _res;
11521 }
11522
11523 // star_expression: '*' bitwise_or | expression
11524 static expr_ty
11525 star_expression_rule(Parser *p)
11526 {
11527 if (p->level++ == MAXSTACK) {
11528 _Pypegen_stack_overflow(p);
11529 }
11530 if (p->error_indicator) {
11531 p->level--;
11532 return NULL;
11533 }
11534 expr_ty _res = NULL;
11535 if (_PyPegen_is_memoized(p, star_expression_type, &_res)) {
11536 p->level--;
11537 return _res;
11538 }
11539 int _mark = p->mark;
11540 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11541 p->error_indicator = 1;
11542 p->level--;
11543 return NULL;
11544 }
11545 int _start_lineno = p->tokens[_mark]->lineno;
11546 UNUSED(_start_lineno); // Only used by EXTRA macro
11547 int _start_col_offset = p->tokens[_mark]->col_offset;
11548 UNUSED(_start_col_offset); // Only used by EXTRA macro
11549 { // '*' bitwise_or
11550 if (p->error_indicator) {
11551 p->level--;
11552 return NULL;
11553 }
11554 D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
11555 Token * _literal;
11556 expr_ty a;
11557 if (
11558 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
11559 &&
11560 (a = bitwise_or_rule(p)) // bitwise_or
11561 )
11562 {
11563 D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
11564 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11565 if (_token == NULL) {
11566 p->level--;
11567 return NULL;
11568 }
11569 int _end_lineno = _token->end_lineno;
11570 UNUSED(_end_lineno); // Only used by EXTRA macro
11571 int _end_col_offset = _token->end_col_offset;
11572 UNUSED(_end_col_offset); // Only used by EXTRA macro
11573 _res = _PyAST_Starred ( a , Load , EXTRA );
11574 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11575 p->error_indicator = 1;
11576 p->level--;
11577 return NULL;
11578 }
11579 goto done;
11580 }
11581 p->mark = _mark;
11582 D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ',
11583 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or"));
11584 }
11585 { // expression
11586 if (p->error_indicator) {
11587 p->level--;
11588 return NULL;
11589 }
11590 D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
11591 expr_ty expression_var;
11592 if (
11593 (expression_var = expression_rule(p)) // expression
11594 )
11595 {
11596 D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
11597 _res = expression_var;
11598 goto done;
11599 }
11600 p->mark = _mark;
11601 D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ',
11602 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
11603 }
11604 _res = NULL;
11605 done:
11606 _PyPegen_insert_memo(p, _mark, star_expression_type, _res);
11607 p->level--;
11608 return _res;
11609 }
11610
11611 // star_named_expressions: ','.star_named_expression+ ','?
11612 static asdl_expr_seq*
11613 star_named_expressions_rule(Parser *p)
11614 {
11615 if (p->level++ == MAXSTACK) {
11616 _Pypegen_stack_overflow(p);
11617 }
11618 if (p->error_indicator) {
11619 p->level--;
11620 return NULL;
11621 }
11622 asdl_expr_seq* _res = NULL;
11623 int _mark = p->mark;
11624 { // ','.star_named_expression+ ','?
11625 if (p->error_indicator) {
11626 p->level--;
11627 return NULL;
11628 }
11629 D(fprintf(stderr, "%*c> star_named_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?"));
11630 void *_opt_var;
11631 UNUSED(_opt_var); // Silence compiler warnings
11632 asdl_expr_seq* a;
11633 if (
11634 (a = (asdl_expr_seq*)_gather_84_rule(p)) // ','.star_named_expression+
11635 &&
11636 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
11637 )
11638 {
11639 D(fprintf(stderr, "%*c+ star_named_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?"));
11640 _res = a;
11641 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11642 p->error_indicator = 1;
11643 p->level--;
11644 return NULL;
11645 }
11646 goto done;
11647 }
11648 p->mark = _mark;
11649 D(fprintf(stderr, "%*c%s star_named_expressions[%d-%d]: %s failed!\n", p->level, ' ',
11650 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_named_expression+ ','?"));
11651 }
11652 _res = NULL;
11653 done:
11654 p->level--;
11655 return _res;
11656 }
11657
11658 // star_named_expression: '*' bitwise_or | named_expression
11659 static expr_ty
11660 star_named_expression_rule(Parser *p)
11661 {
11662 if (p->level++ == MAXSTACK) {
11663 _Pypegen_stack_overflow(p);
11664 }
11665 if (p->error_indicator) {
11666 p->level--;
11667 return NULL;
11668 }
11669 expr_ty _res = NULL;
11670 int _mark = p->mark;
11671 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11672 p->error_indicator = 1;
11673 p->level--;
11674 return NULL;
11675 }
11676 int _start_lineno = p->tokens[_mark]->lineno;
11677 UNUSED(_start_lineno); // Only used by EXTRA macro
11678 int _start_col_offset = p->tokens[_mark]->col_offset;
11679 UNUSED(_start_col_offset); // Only used by EXTRA macro
11680 { // '*' bitwise_or
11681 if (p->error_indicator) {
11682 p->level--;
11683 return NULL;
11684 }
11685 D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
11686 Token * _literal;
11687 expr_ty a;
11688 if (
11689 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
11690 &&
11691 (a = bitwise_or_rule(p)) // bitwise_or
11692 )
11693 {
11694 D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
11695 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11696 if (_token == NULL) {
11697 p->level--;
11698 return NULL;
11699 }
11700 int _end_lineno = _token->end_lineno;
11701 UNUSED(_end_lineno); // Only used by EXTRA macro
11702 int _end_col_offset = _token->end_col_offset;
11703 UNUSED(_end_col_offset); // Only used by EXTRA macro
11704 _res = _PyAST_Starred ( a , Load , EXTRA );
11705 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11706 p->error_indicator = 1;
11707 p->level--;
11708 return NULL;
11709 }
11710 goto done;
11711 }
11712 p->mark = _mark;
11713 D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
11714 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or"));
11715 }
11716 { // named_expression
11717 if (p->error_indicator) {
11718 p->level--;
11719 return NULL;
11720 }
11721 D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
11722 expr_ty named_expression_var;
11723 if (
11724 (named_expression_var = named_expression_rule(p)) // named_expression
11725 )
11726 {
11727 D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
11728 _res = named_expression_var;
11729 goto done;
11730 }
11731 p->mark = _mark;
11732 D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
11733 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
11734 }
11735 _res = NULL;
11736 done:
11737 p->level--;
11738 return _res;
11739 }
11740
11741 // assignment_expression: NAME ':=' ~ expression
11742 static expr_ty
11743 assignment_expression_rule(Parser *p)
11744 {
11745 if (p->level++ == MAXSTACK) {
11746 _Pypegen_stack_overflow(p);
11747 }
11748 if (p->error_indicator) {
11749 p->level--;
11750 return NULL;
11751 }
11752 expr_ty _res = NULL;
11753 int _mark = p->mark;
11754 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11755 p->error_indicator = 1;
11756 p->level--;
11757 return NULL;
11758 }
11759 int _start_lineno = p->tokens[_mark]->lineno;
11760 UNUSED(_start_lineno); // Only used by EXTRA macro
11761 int _start_col_offset = p->tokens[_mark]->col_offset;
11762 UNUSED(_start_col_offset); // Only used by EXTRA macro
11763 { // NAME ':=' ~ expression
11764 if (p->error_indicator) {
11765 p->level--;
11766 return NULL;
11767 }
11768 D(fprintf(stderr, "%*c> assignment_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
11769 int _cut_var = 0;
11770 Token * _literal;
11771 expr_ty a;
11772 expr_ty b;
11773 if (
11774 (a = _PyPegen_name_token(p)) // NAME
11775 &&
11776 (_literal = _PyPegen_expect_token(p, 53)) // token=':='
11777 &&
11778 (_cut_var = 1)
11779 &&
11780 (b = expression_rule(p)) // expression
11781 )
11782 {
11783 D(fprintf(stderr, "%*c+ assignment_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
11784 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11785 if (_token == NULL) {
11786 p->level--;
11787 return NULL;
11788 }
11789 int _end_lineno = _token->end_lineno;
11790 UNUSED(_end_lineno); // Only used by EXTRA macro
11791 int _end_col_offset = _token->end_col_offset;
11792 UNUSED(_end_col_offset); // Only used by EXTRA macro
11793 _res = CHECK_VERSION ( expr_ty , 8 , "Assignment expressions are" , _PyAST_NamedExpr ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA ) );
11794 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11795 p->error_indicator = 1;
11796 p->level--;
11797 return NULL;
11798 }
11799 goto done;
11800 }
11801 p->mark = _mark;
11802 D(fprintf(stderr, "%*c%s assignment_expression[%d-%d]: %s failed!\n", p->level, ' ',
11803 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':=' ~ expression"));
11804 if (_cut_var) {
11805 p->level--;
11806 return NULL;
11807 }
11808 }
11809 _res = NULL;
11810 done:
11811 p->level--;
11812 return _res;
11813 }
11814
11815 // named_expression: assignment_expression | invalid_named_expression | expression !':='
11816 static expr_ty
11817 named_expression_rule(Parser *p)
11818 {
11819 if (p->level++ == MAXSTACK) {
11820 _Pypegen_stack_overflow(p);
11821 }
11822 if (p->error_indicator) {
11823 p->level--;
11824 return NULL;
11825 }
11826 expr_ty _res = NULL;
11827 int _mark = p->mark;
11828 { // assignment_expression
11829 if (p->error_indicator) {
11830 p->level--;
11831 return NULL;
11832 }
11833 D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
11834 expr_ty assignment_expression_var;
11835 if (
11836 (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
11837 )
11838 {
11839 D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
11840 _res = assignment_expression_var;
11841 goto done;
11842 }
11843 p->mark = _mark;
11844 D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
11845 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));
11846 }
11847 if (p->call_invalid_rules) { // invalid_named_expression
11848 if (p->error_indicator) {
11849 p->level--;
11850 return NULL;
11851 }
11852 D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_named_expression"));
11853 void *invalid_named_expression_var;
11854 if (
11855 (invalid_named_expression_var = invalid_named_expression_rule(p)) // invalid_named_expression
11856 )
11857 {
11858 D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_named_expression"));
11859 _res = invalid_named_expression_var;
11860 goto done;
11861 }
11862 p->mark = _mark;
11863 D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
11864 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_named_expression"));
11865 }
11866 { // expression !':='
11867 if (p->error_indicator) {
11868 p->level--;
11869 return NULL;
11870 }
11871 D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
11872 expr_ty expression_var;
11873 if (
11874 (expression_var = expression_rule(p)) // expression
11875 &&
11876 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
11877 )
11878 {
11879 D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
11880 _res = expression_var;
11881 goto done;
11882 }
11883 p->mark = _mark;
11884 D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
11885 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));
11886 }
11887 _res = NULL;
11888 done:
11889 p->level--;
11890 return _res;
11891 }
11892
11893 // disjunction: conjunction (('or' conjunction))+ | conjunction
11894 static expr_ty
11895 disjunction_rule(Parser *p)
11896 {
11897 if (p->level++ == MAXSTACK) {
11898 _Pypegen_stack_overflow(p);
11899 }
11900 if (p->error_indicator) {
11901 p->level--;
11902 return NULL;
11903 }
11904 expr_ty _res = NULL;
11905 if (_PyPegen_is_memoized(p, disjunction_type, &_res)) {
11906 p->level--;
11907 return _res;
11908 }
11909 int _mark = p->mark;
11910 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11911 p->error_indicator = 1;
11912 p->level--;
11913 return NULL;
11914 }
11915 int _start_lineno = p->tokens[_mark]->lineno;
11916 UNUSED(_start_lineno); // Only used by EXTRA macro
11917 int _start_col_offset = p->tokens[_mark]->col_offset;
11918 UNUSED(_start_col_offset); // Only used by EXTRA macro
11919 { // conjunction (('or' conjunction))+
11920 if (p->error_indicator) {
11921 p->level--;
11922 return NULL;
11923 }
11924 D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+"));
11925 expr_ty a;
11926 asdl_seq * b;
11927 if (
11928 (a = conjunction_rule(p)) // conjunction
11929 &&
11930 (b = _loop1_86_rule(p)) // (('or' conjunction))+
11931 )
11932 {
11933 D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+"));
11934 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
11935 if (_token == NULL) {
11936 p->level--;
11937 return NULL;
11938 }
11939 int _end_lineno = _token->end_lineno;
11940 UNUSED(_end_lineno); // Only used by EXTRA macro
11941 int _end_col_offset = _token->end_col_offset;
11942 UNUSED(_end_col_offset); // Only used by EXTRA macro
11943 _res = _PyAST_BoolOp ( Or , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
11944 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
11945 p->error_indicator = 1;
11946 p->level--;
11947 return NULL;
11948 }
11949 goto done;
11950 }
11951 p->mark = _mark;
11952 D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ',
11953 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction (('or' conjunction))+"));
11954 }
11955 { // conjunction
11956 if (p->error_indicator) {
11957 p->level--;
11958 return NULL;
11959 }
11960 D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction"));
11961 expr_ty conjunction_var;
11962 if (
11963 (conjunction_var = conjunction_rule(p)) // conjunction
11964 )
11965 {
11966 D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction"));
11967 _res = conjunction_var;
11968 goto done;
11969 }
11970 p->mark = _mark;
11971 D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ',
11972 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction"));
11973 }
11974 _res = NULL;
11975 done:
11976 _PyPegen_insert_memo(p, _mark, disjunction_type, _res);
11977 p->level--;
11978 return _res;
11979 }
11980
11981 // conjunction: inversion (('and' inversion))+ | inversion
11982 static expr_ty
11983 conjunction_rule(Parser *p)
11984 {
11985 if (p->level++ == MAXSTACK) {
11986 _Pypegen_stack_overflow(p);
11987 }
11988 if (p->error_indicator) {
11989 p->level--;
11990 return NULL;
11991 }
11992 expr_ty _res = NULL;
11993 if (_PyPegen_is_memoized(p, conjunction_type, &_res)) {
11994 p->level--;
11995 return _res;
11996 }
11997 int _mark = p->mark;
11998 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
11999 p->error_indicator = 1;
12000 p->level--;
12001 return NULL;
12002 }
12003 int _start_lineno = p->tokens[_mark]->lineno;
12004 UNUSED(_start_lineno); // Only used by EXTRA macro
12005 int _start_col_offset = p->tokens[_mark]->col_offset;
12006 UNUSED(_start_col_offset); // Only used by EXTRA macro
12007 { // inversion (('and' inversion))+
12008 if (p->error_indicator) {
12009 p->level--;
12010 return NULL;
12011 }
12012 D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+"));
12013 expr_ty a;
12014 asdl_seq * b;
12015 if (
12016 (a = inversion_rule(p)) // inversion
12017 &&
12018 (b = _loop1_87_rule(p)) // (('and' inversion))+
12019 )
12020 {
12021 D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+"));
12022 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12023 if (_token == NULL) {
12024 p->level--;
12025 return NULL;
12026 }
12027 int _end_lineno = _token->end_lineno;
12028 UNUSED(_end_lineno); // Only used by EXTRA macro
12029 int _end_col_offset = _token->end_col_offset;
12030 UNUSED(_end_col_offset); // Only used by EXTRA macro
12031 _res = _PyAST_BoolOp ( And , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
12032 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12033 p->error_indicator = 1;
12034 p->level--;
12035 return NULL;
12036 }
12037 goto done;
12038 }
12039 p->mark = _mark;
12040 D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ',
12041 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion (('and' inversion))+"));
12042 }
12043 { // inversion
12044 if (p->error_indicator) {
12045 p->level--;
12046 return NULL;
12047 }
12048 D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion"));
12049 expr_ty inversion_var;
12050 if (
12051 (inversion_var = inversion_rule(p)) // inversion
12052 )
12053 {
12054 D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion"));
12055 _res = inversion_var;
12056 goto done;
12057 }
12058 p->mark = _mark;
12059 D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ',
12060 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion"));
12061 }
12062 _res = NULL;
12063 done:
12064 _PyPegen_insert_memo(p, _mark, conjunction_type, _res);
12065 p->level--;
12066 return _res;
12067 }
12068
12069 // inversion: 'not' inversion | comparison
12070 static expr_ty
12071 inversion_rule(Parser *p)
12072 {
12073 if (p->level++ == MAXSTACK) {
12074 _Pypegen_stack_overflow(p);
12075 }
12076 if (p->error_indicator) {
12077 p->level--;
12078 return NULL;
12079 }
12080 expr_ty _res = NULL;
12081 if (_PyPegen_is_memoized(p, inversion_type, &_res)) {
12082 p->level--;
12083 return _res;
12084 }
12085 int _mark = p->mark;
12086 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
12087 p->error_indicator = 1;
12088 p->level--;
12089 return NULL;
12090 }
12091 int _start_lineno = p->tokens[_mark]->lineno;
12092 UNUSED(_start_lineno); // Only used by EXTRA macro
12093 int _start_col_offset = p->tokens[_mark]->col_offset;
12094 UNUSED(_start_col_offset); // Only used by EXTRA macro
12095 { // 'not' inversion
12096 if (p->error_indicator) {
12097 p->level--;
12098 return NULL;
12099 }
12100 D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
12101 Token * _keyword;
12102 expr_ty a;
12103 if (
12104 (_keyword = _PyPegen_expect_token(p, 679)) // token='not'
12105 &&
12106 (a = inversion_rule(p)) // inversion
12107 )
12108 {
12109 D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
12110 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12111 if (_token == NULL) {
12112 p->level--;
12113 return NULL;
12114 }
12115 int _end_lineno = _token->end_lineno;
12116 UNUSED(_end_lineno); // Only used by EXTRA macro
12117 int _end_col_offset = _token->end_col_offset;
12118 UNUSED(_end_col_offset); // Only used by EXTRA macro
12119 _res = _PyAST_UnaryOp ( Not , a , EXTRA );
12120 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12121 p->error_indicator = 1;
12122 p->level--;
12123 return NULL;
12124 }
12125 goto done;
12126 }
12127 p->mark = _mark;
12128 D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',
12129 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' inversion"));
12130 }
12131 { // comparison
12132 if (p->error_indicator) {
12133 p->level--;
12134 return NULL;
12135 }
12136 D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "comparison"));
12137 expr_ty comparison_var;
12138 if (
12139 (comparison_var = comparison_rule(p)) // comparison
12140 )
12141 {
12142 D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "comparison"));
12143 _res = comparison_var;
12144 goto done;
12145 }
12146 p->mark = _mark;
12147 D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',
12148 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison"));
12149 }
12150 _res = NULL;
12151 done:
12152 _PyPegen_insert_memo(p, _mark, inversion_type, _res);
12153 p->level--;
12154 return _res;
12155 }
12156
12157 // comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or
12158 static expr_ty
12159 comparison_rule(Parser *p)
12160 {
12161 if (p->level++ == MAXSTACK) {
12162 _Pypegen_stack_overflow(p);
12163 }
12164 if (p->error_indicator) {
12165 p->level--;
12166 return NULL;
12167 }
12168 expr_ty _res = NULL;
12169 int _mark = p->mark;
12170 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
12171 p->error_indicator = 1;
12172 p->level--;
12173 return NULL;
12174 }
12175 int _start_lineno = p->tokens[_mark]->lineno;
12176 UNUSED(_start_lineno); // Only used by EXTRA macro
12177 int _start_col_offset = p->tokens[_mark]->col_offset;
12178 UNUSED(_start_col_offset); // Only used by EXTRA macro
12179 { // bitwise_or compare_op_bitwise_or_pair+
12180 if (p->error_indicator) {
12181 p->level--;
12182 return NULL;
12183 }
12184 D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
12185 expr_ty a;
12186 asdl_seq * b;
12187 if (
12188 (a = bitwise_or_rule(p)) // bitwise_or
12189 &&
12190 (b = _loop1_88_rule(p)) // compare_op_bitwise_or_pair+
12191 )
12192 {
12193 D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
12194 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
12195 if (_token == NULL) {
12196 p->level--;
12197 return NULL;
12198 }
12199 int _end_lineno = _token->end_lineno;
12200 UNUSED(_end_lineno); // Only used by EXTRA macro
12201 int _end_col_offset = _token->end_col_offset;
12202 UNUSED(_end_col_offset); // Only used by EXTRA macro
12203 _res = _PyAST_Compare ( a , CHECK ( asdl_int_seq* , _PyPegen_get_cmpops ( p , b ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_exprs ( p , b ) ) , EXTRA );
12204 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12205 p->error_indicator = 1;
12206 p->level--;
12207 return NULL;
12208 }
12209 goto done;
12210 }
12211 p->mark = _mark;
12212 D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ',
12213 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
12214 }
12215 { // bitwise_or
12216 if (p->error_indicator) {
12217 p->level--;
12218 return NULL;
12219 }
12220 D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or"));
12221 expr_ty bitwise_or_var;
12222 if (
12223 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
12224 )
12225 {
12226 D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or"));
12227 _res = bitwise_or_var;
12228 goto done;
12229 }
12230 p->mark = _mark;
12231 D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ',
12232 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or"));
12233 }
12234 _res = NULL;
12235 done:
12236 p->level--;
12237 return _res;
12238 }
12239
12240 // compare_op_bitwise_or_pair:
12241 // | eq_bitwise_or
12242 // | noteq_bitwise_or
12243 // | lte_bitwise_or
12244 // | lt_bitwise_or
12245 // | gte_bitwise_or
12246 // | gt_bitwise_or
12247 // | notin_bitwise_or
12248 // | in_bitwise_or
12249 // | isnot_bitwise_or
12250 // | is_bitwise_or
12251 static CmpopExprPair*
12252 compare_op_bitwise_or_pair_rule(Parser *p)
12253 {
12254 if (p->level++ == MAXSTACK) {
12255 _Pypegen_stack_overflow(p);
12256 }
12257 if (p->error_indicator) {
12258 p->level--;
12259 return NULL;
12260 }
12261 CmpopExprPair* _res = NULL;
12262 int _mark = p->mark;
12263 { // eq_bitwise_or
12264 if (p->error_indicator) {
12265 p->level--;
12266 return NULL;
12267 }
12268 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or"));
12269 CmpopExprPair* eq_bitwise_or_var;
12270 if (
12271 (eq_bitwise_or_var = eq_bitwise_or_rule(p)) // eq_bitwise_or
12272 )
12273 {
12274 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or"));
12275 _res = eq_bitwise_or_var;
12276 goto done;
12277 }
12278 p->mark = _mark;
12279 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12280 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "eq_bitwise_or"));
12281 }
12282 { // noteq_bitwise_or
12283 if (p->error_indicator) {
12284 p->level--;
12285 return NULL;
12286 }
12287 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or"));
12288 CmpopExprPair* noteq_bitwise_or_var;
12289 if (
12290 (noteq_bitwise_or_var = noteq_bitwise_or_rule(p)) // noteq_bitwise_or
12291 )
12292 {
12293 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or"));
12294 _res = noteq_bitwise_or_var;
12295 goto done;
12296 }
12297 p->mark = _mark;
12298 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12299 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "noteq_bitwise_or"));
12300 }
12301 { // lte_bitwise_or
12302 if (p->error_indicator) {
12303 p->level--;
12304 return NULL;
12305 }
12306 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or"));
12307 CmpopExprPair* lte_bitwise_or_var;
12308 if (
12309 (lte_bitwise_or_var = lte_bitwise_or_rule(p)) // lte_bitwise_or
12310 )
12311 {
12312 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or"));
12313 _res = lte_bitwise_or_var;
12314 goto done;
12315 }
12316 p->mark = _mark;
12317 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12318 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lte_bitwise_or"));
12319 }
12320 { // lt_bitwise_or
12321 if (p->error_indicator) {
12322 p->level--;
12323 return NULL;
12324 }
12325 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or"));
12326 CmpopExprPair* lt_bitwise_or_var;
12327 if (
12328 (lt_bitwise_or_var = lt_bitwise_or_rule(p)) // lt_bitwise_or
12329 )
12330 {
12331 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or"));
12332 _res = lt_bitwise_or_var;
12333 goto done;
12334 }
12335 p->mark = _mark;
12336 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12337 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lt_bitwise_or"));
12338 }
12339 { // gte_bitwise_or
12340 if (p->error_indicator) {
12341 p->level--;
12342 return NULL;
12343 }
12344 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or"));
12345 CmpopExprPair* gte_bitwise_or_var;
12346 if (
12347 (gte_bitwise_or_var = gte_bitwise_or_rule(p)) // gte_bitwise_or
12348 )
12349 {
12350 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or"));
12351 _res = gte_bitwise_or_var;
12352 goto done;
12353 }
12354 p->mark = _mark;
12355 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12356 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gte_bitwise_or"));
12357 }
12358 { // gt_bitwise_or
12359 if (p->error_indicator) {
12360 p->level--;
12361 return NULL;
12362 }
12363 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or"));
12364 CmpopExprPair* gt_bitwise_or_var;
12365 if (
12366 (gt_bitwise_or_var = gt_bitwise_or_rule(p)) // gt_bitwise_or
12367 )
12368 {
12369 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or"));
12370 _res = gt_bitwise_or_var;
12371 goto done;
12372 }
12373 p->mark = _mark;
12374 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12375 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gt_bitwise_or"));
12376 }
12377 { // notin_bitwise_or
12378 if (p->error_indicator) {
12379 p->level--;
12380 return NULL;
12381 }
12382 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or"));
12383 CmpopExprPair* notin_bitwise_or_var;
12384 if (
12385 (notin_bitwise_or_var = notin_bitwise_or_rule(p)) // notin_bitwise_or
12386 )
12387 {
12388 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or"));
12389 _res = notin_bitwise_or_var;
12390 goto done;
12391 }
12392 p->mark = _mark;
12393 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12394 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "notin_bitwise_or"));
12395 }
12396 { // in_bitwise_or
12397 if (p->error_indicator) {
12398 p->level--;
12399 return NULL;
12400 }
12401 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "in_bitwise_or"));
12402 CmpopExprPair* in_bitwise_or_var;
12403 if (
12404 (in_bitwise_or_var = in_bitwise_or_rule(p)) // in_bitwise_or
12405 )
12406 {
12407 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in_bitwise_or"));
12408 _res = in_bitwise_or_var;
12409 goto done;
12410 }
12411 p->mark = _mark;
12412 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12413 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "in_bitwise_or"));
12414 }
12415 { // isnot_bitwise_or
12416 if (p->error_indicator) {
12417 p->level--;
12418 return NULL;
12419 }
12420 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or"));
12421 CmpopExprPair* isnot_bitwise_or_var;
12422 if (
12423 (isnot_bitwise_or_var = isnot_bitwise_or_rule(p)) // isnot_bitwise_or
12424 )
12425 {
12426 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or"));
12427 _res = isnot_bitwise_or_var;
12428 goto done;
12429 }
12430 p->mark = _mark;
12431 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12432 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "isnot_bitwise_or"));
12433 }
12434 { // is_bitwise_or
12435 if (p->error_indicator) {
12436 p->level--;
12437 return NULL;
12438 }
12439 D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "is_bitwise_or"));
12440 CmpopExprPair* is_bitwise_or_var;
12441 if (
12442 (is_bitwise_or_var = is_bitwise_or_rule(p)) // is_bitwise_or
12443 )
12444 {
12445 D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "is_bitwise_or"));
12446 _res = is_bitwise_or_var;
12447 goto done;
12448 }
12449 p->mark = _mark;
12450 D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
12451 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "is_bitwise_or"));
12452 }
12453 _res = NULL;
12454 done:
12455 p->level--;
12456 return _res;
12457 }
12458
12459 // eq_bitwise_or: '==' bitwise_or
12460 static CmpopExprPair*
12461 eq_bitwise_or_rule(Parser *p)
12462 {
12463 if (p->level++ == MAXSTACK) {
12464 _Pypegen_stack_overflow(p);
12465 }
12466 if (p->error_indicator) {
12467 p->level--;
12468 return NULL;
12469 }
12470 CmpopExprPair* _res = NULL;
12471 int _mark = p->mark;
12472 { // '==' bitwise_or
12473 if (p->error_indicator) {
12474 p->level--;
12475 return NULL;
12476 }
12477 D(fprintf(stderr, "%*c> eq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or"));
12478 Token * _literal;
12479 expr_ty a;
12480 if (
12481 (_literal = _PyPegen_expect_token(p, 27)) // token='=='
12482 &&
12483 (a = bitwise_or_rule(p)) // bitwise_or
12484 )
12485 {
12486 D(fprintf(stderr, "%*c+ eq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or"));
12487 _res = _PyPegen_cmpop_expr_pair ( p , Eq , a );
12488 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12489 p->error_indicator = 1;
12490 p->level--;
12491 return NULL;
12492 }
12493 goto done;
12494 }
12495 p->mark = _mark;
12496 D(fprintf(stderr, "%*c%s eq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12497 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'==' bitwise_or"));
12498 }
12499 _res = NULL;
12500 done:
12501 p->level--;
12502 return _res;
12503 }
12504
12505 // noteq_bitwise_or: ('!=') bitwise_or
12506 static CmpopExprPair*
12507 noteq_bitwise_or_rule(Parser *p)
12508 {
12509 if (p->level++ == MAXSTACK) {
12510 _Pypegen_stack_overflow(p);
12511 }
12512 if (p->error_indicator) {
12513 p->level--;
12514 return NULL;
12515 }
12516 CmpopExprPair* _res = NULL;
12517 int _mark = p->mark;
12518 { // ('!=') bitwise_or
12519 if (p->error_indicator) {
12520 p->level--;
12521 return NULL;
12522 }
12523 D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or"));
12524 void *_tmp_89_var;
12525 expr_ty a;
12526 if (
12527 (_tmp_89_var = _tmp_89_rule(p)) // '!='
12528 &&
12529 (a = bitwise_or_rule(p)) // bitwise_or
12530 )
12531 {
12532 D(fprintf(stderr, "%*c+ noteq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or"));
12533 _res = _PyPegen_cmpop_expr_pair ( p , NotEq , a );
12534 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12535 p->error_indicator = 1;
12536 p->level--;
12537 return NULL;
12538 }
12539 goto done;
12540 }
12541 p->mark = _mark;
12542 D(fprintf(stderr, "%*c%s noteq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12543 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('!=') bitwise_or"));
12544 }
12545 _res = NULL;
12546 done:
12547 p->level--;
12548 return _res;
12549 }
12550
12551 // lte_bitwise_or: '<=' bitwise_or
12552 static CmpopExprPair*
12553 lte_bitwise_or_rule(Parser *p)
12554 {
12555 if (p->level++ == MAXSTACK) {
12556 _Pypegen_stack_overflow(p);
12557 }
12558 if (p->error_indicator) {
12559 p->level--;
12560 return NULL;
12561 }
12562 CmpopExprPair* _res = NULL;
12563 int _mark = p->mark;
12564 { // '<=' bitwise_or
12565 if (p->error_indicator) {
12566 p->level--;
12567 return NULL;
12568 }
12569 D(fprintf(stderr, "%*c> lte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or"));
12570 Token * _literal;
12571 expr_ty a;
12572 if (
12573 (_literal = _PyPegen_expect_token(p, 29)) // token='<='
12574 &&
12575 (a = bitwise_or_rule(p)) // bitwise_or
12576 )
12577 {
12578 D(fprintf(stderr, "%*c+ lte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or"));
12579 _res = _PyPegen_cmpop_expr_pair ( p , LtE , a );
12580 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12581 p->error_indicator = 1;
12582 p->level--;
12583 return NULL;
12584 }
12585 goto done;
12586 }
12587 p->mark = _mark;
12588 D(fprintf(stderr, "%*c%s lte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12589 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<=' bitwise_or"));
12590 }
12591 _res = NULL;
12592 done:
12593 p->level--;
12594 return _res;
12595 }
12596
12597 // lt_bitwise_or: '<' bitwise_or
12598 static CmpopExprPair*
12599 lt_bitwise_or_rule(Parser *p)
12600 {
12601 if (p->level++ == MAXSTACK) {
12602 _Pypegen_stack_overflow(p);
12603 }
12604 if (p->error_indicator) {
12605 p->level--;
12606 return NULL;
12607 }
12608 CmpopExprPair* _res = NULL;
12609 int _mark = p->mark;
12610 { // '<' bitwise_or
12611 if (p->error_indicator) {
12612 p->level--;
12613 return NULL;
12614 }
12615 D(fprintf(stderr, "%*c> lt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or"));
12616 Token * _literal;
12617 expr_ty a;
12618 if (
12619 (_literal = _PyPegen_expect_token(p, 20)) // token='<'
12620 &&
12621 (a = bitwise_or_rule(p)) // bitwise_or
12622 )
12623 {
12624 D(fprintf(stderr, "%*c+ lt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or"));
12625 _res = _PyPegen_cmpop_expr_pair ( p , Lt , a );
12626 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12627 p->error_indicator = 1;
12628 p->level--;
12629 return NULL;
12630 }
12631 goto done;
12632 }
12633 p->mark = _mark;
12634 D(fprintf(stderr, "%*c%s lt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12635 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<' bitwise_or"));
12636 }
12637 _res = NULL;
12638 done:
12639 p->level--;
12640 return _res;
12641 }
12642
12643 // gte_bitwise_or: '>=' bitwise_or
12644 static CmpopExprPair*
12645 gte_bitwise_or_rule(Parser *p)
12646 {
12647 if (p->level++ == MAXSTACK) {
12648 _Pypegen_stack_overflow(p);
12649 }
12650 if (p->error_indicator) {
12651 p->level--;
12652 return NULL;
12653 }
12654 CmpopExprPair* _res = NULL;
12655 int _mark = p->mark;
12656 { // '>=' bitwise_or
12657 if (p->error_indicator) {
12658 p->level--;
12659 return NULL;
12660 }
12661 D(fprintf(stderr, "%*c> gte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or"));
12662 Token * _literal;
12663 expr_ty a;
12664 if (
12665 (_literal = _PyPegen_expect_token(p, 30)) // token='>='
12666 &&
12667 (a = bitwise_or_rule(p)) // bitwise_or
12668 )
12669 {
12670 D(fprintf(stderr, "%*c+ gte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or"));
12671 _res = _PyPegen_cmpop_expr_pair ( p , GtE , a );
12672 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12673 p->error_indicator = 1;
12674 p->level--;
12675 return NULL;
12676 }
12677 goto done;
12678 }
12679 p->mark = _mark;
12680 D(fprintf(stderr, "%*c%s gte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12681 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>=' bitwise_or"));
12682 }
12683 _res = NULL;
12684 done:
12685 p->level--;
12686 return _res;
12687 }
12688
12689 // gt_bitwise_or: '>' bitwise_or
12690 static CmpopExprPair*
12691 gt_bitwise_or_rule(Parser *p)
12692 {
12693 if (p->level++ == MAXSTACK) {
12694 _Pypegen_stack_overflow(p);
12695 }
12696 if (p->error_indicator) {
12697 p->level--;
12698 return NULL;
12699 }
12700 CmpopExprPair* _res = NULL;
12701 int _mark = p->mark;
12702 { // '>' bitwise_or
12703 if (p->error_indicator) {
12704 p->level--;
12705 return NULL;
12706 }
12707 D(fprintf(stderr, "%*c> gt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or"));
12708 Token * _literal;
12709 expr_ty a;
12710 if (
12711 (_literal = _PyPegen_expect_token(p, 21)) // token='>'
12712 &&
12713 (a = bitwise_or_rule(p)) // bitwise_or
12714 )
12715 {
12716 D(fprintf(stderr, "%*c+ gt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or"));
12717 _res = _PyPegen_cmpop_expr_pair ( p , Gt , a );
12718 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12719 p->error_indicator = 1;
12720 p->level--;
12721 return NULL;
12722 }
12723 goto done;
12724 }
12725 p->mark = _mark;
12726 D(fprintf(stderr, "%*c%s gt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12727 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>' bitwise_or"));
12728 }
12729 _res = NULL;
12730 done:
12731 p->level--;
12732 return _res;
12733 }
12734
12735 // notin_bitwise_or: 'not' 'in' bitwise_or
12736 static CmpopExprPair*
12737 notin_bitwise_or_rule(Parser *p)
12738 {
12739 if (p->level++ == MAXSTACK) {
12740 _Pypegen_stack_overflow(p);
12741 }
12742 if (p->error_indicator) {
12743 p->level--;
12744 return NULL;
12745 }
12746 CmpopExprPair* _res = NULL;
12747 int _mark = p->mark;
12748 { // 'not' 'in' bitwise_or
12749 if (p->error_indicator) {
12750 p->level--;
12751 return NULL;
12752 }
12753 D(fprintf(stderr, "%*c> notin_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or"));
12754 Token * _keyword;
12755 Token * _keyword_1;
12756 expr_ty a;
12757 if (
12758 (_keyword = _PyPegen_expect_token(p, 679)) // token='not'
12759 &&
12760 (_keyword_1 = _PyPegen_expect_token(p, 671)) // token='in'
12761 &&
12762 (a = bitwise_or_rule(p)) // bitwise_or
12763 )
12764 {
12765 D(fprintf(stderr, "%*c+ notin_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or"));
12766 _res = _PyPegen_cmpop_expr_pair ( p , NotIn , a );
12767 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12768 p->error_indicator = 1;
12769 p->level--;
12770 return NULL;
12771 }
12772 goto done;
12773 }
12774 p->mark = _mark;
12775 D(fprintf(stderr, "%*c%s notin_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12776 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' 'in' bitwise_or"));
12777 }
12778 _res = NULL;
12779 done:
12780 p->level--;
12781 return _res;
12782 }
12783
12784 // in_bitwise_or: 'in' bitwise_or
12785 static CmpopExprPair*
12786 in_bitwise_or_rule(Parser *p)
12787 {
12788 if (p->level++ == MAXSTACK) {
12789 _Pypegen_stack_overflow(p);
12790 }
12791 if (p->error_indicator) {
12792 p->level--;
12793 return NULL;
12794 }
12795 CmpopExprPair* _res = NULL;
12796 int _mark = p->mark;
12797 { // 'in' bitwise_or
12798 if (p->error_indicator) {
12799 p->level--;
12800 return NULL;
12801 }
12802 D(fprintf(stderr, "%*c> in_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or"));
12803 Token * _keyword;
12804 expr_ty a;
12805 if (
12806 (_keyword = _PyPegen_expect_token(p, 671)) // token='in'
12807 &&
12808 (a = bitwise_or_rule(p)) // bitwise_or
12809 )
12810 {
12811 D(fprintf(stderr, "%*c+ in_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or"));
12812 _res = _PyPegen_cmpop_expr_pair ( p , In , a );
12813 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12814 p->error_indicator = 1;
12815 p->level--;
12816 return NULL;
12817 }
12818 goto done;
12819 }
12820 p->mark = _mark;
12821 D(fprintf(stderr, "%*c%s in_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12822 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'in' bitwise_or"));
12823 }
12824 _res = NULL;
12825 done:
12826 p->level--;
12827 return _res;
12828 }
12829
12830 // isnot_bitwise_or: 'is' 'not' bitwise_or
12831 static CmpopExprPair*
12832 isnot_bitwise_or_rule(Parser *p)
12833 {
12834 if (p->level++ == MAXSTACK) {
12835 _Pypegen_stack_overflow(p);
12836 }
12837 if (p->error_indicator) {
12838 p->level--;
12839 return NULL;
12840 }
12841 CmpopExprPair* _res = NULL;
12842 int _mark = p->mark;
12843 { // 'is' 'not' bitwise_or
12844 if (p->error_indicator) {
12845 p->level--;
12846 return NULL;
12847 }
12848 D(fprintf(stderr, "%*c> isnot_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or"));
12849 Token * _keyword;
12850 Token * _keyword_1;
12851 expr_ty a;
12852 if (
12853 (_keyword = _PyPegen_expect_token(p, 589)) // token='is'
12854 &&
12855 (_keyword_1 = _PyPegen_expect_token(p, 679)) // token='not'
12856 &&
12857 (a = bitwise_or_rule(p)) // bitwise_or
12858 )
12859 {
12860 D(fprintf(stderr, "%*c+ isnot_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or"));
12861 _res = _PyPegen_cmpop_expr_pair ( p , IsNot , a );
12862 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12863 p->error_indicator = 1;
12864 p->level--;
12865 return NULL;
12866 }
12867 goto done;
12868 }
12869 p->mark = _mark;
12870 D(fprintf(stderr, "%*c%s isnot_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12871 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' 'not' bitwise_or"));
12872 }
12873 _res = NULL;
12874 done:
12875 p->level--;
12876 return _res;
12877 }
12878
12879 // is_bitwise_or: 'is' bitwise_or
12880 static CmpopExprPair*
12881 is_bitwise_or_rule(Parser *p)
12882 {
12883 if (p->level++ == MAXSTACK) {
12884 _Pypegen_stack_overflow(p);
12885 }
12886 if (p->error_indicator) {
12887 p->level--;
12888 return NULL;
12889 }
12890 CmpopExprPair* _res = NULL;
12891 int _mark = p->mark;
12892 { // 'is' bitwise_or
12893 if (p->error_indicator) {
12894 p->level--;
12895 return NULL;
12896 }
12897 D(fprintf(stderr, "%*c> is_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or"));
12898 Token * _keyword;
12899 expr_ty a;
12900 if (
12901 (_keyword = _PyPegen_expect_token(p, 589)) // token='is'
12902 &&
12903 (a = bitwise_or_rule(p)) // bitwise_or
12904 )
12905 {
12906 D(fprintf(stderr, "%*c+ is_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or"));
12907 _res = _PyPegen_cmpop_expr_pair ( p , Is , a );
12908 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
12909 p->error_indicator = 1;
12910 p->level--;
12911 return NULL;
12912 }
12913 goto done;
12914 }
12915 p->mark = _mark;
12916 D(fprintf(stderr, "%*c%s is_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
12917 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' bitwise_or"));
12918 }
12919 _res = NULL;
12920 done:
12921 p->level--;
12922 return _res;
12923 }
12924
12925 // Left-recursive
12926 // bitwise_or: bitwise_or '|' bitwise_xor | bitwise_xor
12927 static expr_ty bitwise_or_raw(Parser *);
12928 static expr_ty
12929 bitwise_or_rule(Parser *p)
12930 {
12931 if (p->level++ == MAXSTACK) {
12932 _Pypegen_stack_overflow(p);
12933 }
12934 expr_ty _res = NULL;
12935 if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) {
12936 p->level--;
12937 return _res;
12938 }
12939 int _mark = p->mark;
12940 int _resmark = p->mark;
12941 while (1) {
12942 int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res);
12943 if (tmpvar_2) {
12944 p->level--;
12945 return _res;
12946 }
12947 p->mark = _mark;
12948 void *_raw = bitwise_or_raw(p);
12949 if (p->error_indicator) {
12950 p->level--;
12951 return NULL;
12952 }
12953 if (_raw == NULL || p->mark <= _resmark)
12954 break;
12955 _resmark = p->mark;
12956 _res = _raw;
12957 }
12958 p->mark = _resmark;
12959 p->level--;
12960 return _res;
12961 }
12962 static expr_ty
12963 bitwise_or_raw(Parser *p)
12964 {
12965 if (p->level++ == MAXSTACK) {
12966 _Pypegen_stack_overflow(p);
12967 }
12968 if (p->error_indicator) {
12969 p->level--;
12970 return NULL;
12971 }
12972 expr_ty _res = NULL;
12973 int _mark = p->mark;
12974 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
12975 p->error_indicator = 1;
12976 p->level--;
12977 return NULL;
12978 }
12979 int _start_lineno = p->tokens[_mark]->lineno;
12980 UNUSED(_start_lineno); // Only used by EXTRA macro
12981 int _start_col_offset = p->tokens[_mark]->col_offset;
12982 UNUSED(_start_col_offset); // Only used by EXTRA macro
12983 { // bitwise_or '|' bitwise_xor
12984 if (p->error_indicator) {
12985 p->level--;
12986 return NULL;
12987 }
12988 D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor"));
12989 Token * _literal;
12990 expr_ty a;
12991 expr_ty b;
12992 if (
12993 (a = bitwise_or_rule(p)) // bitwise_or
12994 &&
12995 (_literal = _PyPegen_expect_token(p, 18)) // token='|'
12996 &&
12997 (b = bitwise_xor_rule(p)) // bitwise_xor
12998 )
12999 {
13000 D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor"));
13001 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13002 if (_token == NULL) {
13003 p->level--;
13004 return NULL;
13005 }
13006 int _end_lineno = _token->end_lineno;
13007 UNUSED(_end_lineno); // Only used by EXTRA macro
13008 int _end_col_offset = _token->end_col_offset;
13009 UNUSED(_end_col_offset); // Only used by EXTRA macro
13010 _res = _PyAST_BinOp ( a , BitOr , b , EXTRA );
13011 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13012 p->error_indicator = 1;
13013 p->level--;
13014 return NULL;
13015 }
13016 goto done;
13017 }
13018 p->mark = _mark;
13019 D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
13020 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or '|' bitwise_xor"));
13021 }
13022 { // bitwise_xor
13023 if (p->error_indicator) {
13024 p->level--;
13025 return NULL;
13026 }
13027 D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));
13028 expr_ty bitwise_xor_var;
13029 if (
13030 (bitwise_xor_var = bitwise_xor_rule(p)) // bitwise_xor
13031 )
13032 {
13033 D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));
13034 _res = bitwise_xor_var;
13035 goto done;
13036 }
13037 p->mark = _mark;
13038 D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
13039 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor"));
13040 }
13041 _res = NULL;
13042 done:
13043 p->level--;
13044 return _res;
13045 }
13046
13047 // Left-recursive
13048 // bitwise_xor: bitwise_xor '^' bitwise_and | bitwise_and
13049 static expr_ty bitwise_xor_raw(Parser *);
13050 static expr_ty
13051 bitwise_xor_rule(Parser *p)
13052 {
13053 if (p->level++ == MAXSTACK) {
13054 _Pypegen_stack_overflow(p);
13055 }
13056 expr_ty _res = NULL;
13057 if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) {
13058 p->level--;
13059 return _res;
13060 }
13061 int _mark = p->mark;
13062 int _resmark = p->mark;
13063 while (1) {
13064 int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res);
13065 if (tmpvar_3) {
13066 p->level--;
13067 return _res;
13068 }
13069 p->mark = _mark;
13070 void *_raw = bitwise_xor_raw(p);
13071 if (p->error_indicator) {
13072 p->level--;
13073 return NULL;
13074 }
13075 if (_raw == NULL || p->mark <= _resmark)
13076 break;
13077 _resmark = p->mark;
13078 _res = _raw;
13079 }
13080 p->mark = _resmark;
13081 p->level--;
13082 return _res;
13083 }
13084 static expr_ty
13085 bitwise_xor_raw(Parser *p)
13086 {
13087 if (p->level++ == MAXSTACK) {
13088 _Pypegen_stack_overflow(p);
13089 }
13090 if (p->error_indicator) {
13091 p->level--;
13092 return NULL;
13093 }
13094 expr_ty _res = NULL;
13095 int _mark = p->mark;
13096 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13097 p->error_indicator = 1;
13098 p->level--;
13099 return NULL;
13100 }
13101 int _start_lineno = p->tokens[_mark]->lineno;
13102 UNUSED(_start_lineno); // Only used by EXTRA macro
13103 int _start_col_offset = p->tokens[_mark]->col_offset;
13104 UNUSED(_start_col_offset); // Only used by EXTRA macro
13105 { // bitwise_xor '^' bitwise_and
13106 if (p->error_indicator) {
13107 p->level--;
13108 return NULL;
13109 }
13110 D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and"));
13111 Token * _literal;
13112 expr_ty a;
13113 expr_ty b;
13114 if (
13115 (a = bitwise_xor_rule(p)) // bitwise_xor
13116 &&
13117 (_literal = _PyPegen_expect_token(p, 32)) // token='^'
13118 &&
13119 (b = bitwise_and_rule(p)) // bitwise_and
13120 )
13121 {
13122 D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and"));
13123 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13124 if (_token == NULL) {
13125 p->level--;
13126 return NULL;
13127 }
13128 int _end_lineno = _token->end_lineno;
13129 UNUSED(_end_lineno); // Only used by EXTRA macro
13130 int _end_col_offset = _token->end_col_offset;
13131 UNUSED(_end_col_offset); // Only used by EXTRA macro
13132 _res = _PyAST_BinOp ( a , BitXor , b , EXTRA );
13133 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13134 p->error_indicator = 1;
13135 p->level--;
13136 return NULL;
13137 }
13138 goto done;
13139 }
13140 p->mark = _mark;
13141 D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ',
13142 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor '^' bitwise_and"));
13143 }
13144 { // bitwise_and
13145 if (p->error_indicator) {
13146 p->level--;
13147 return NULL;
13148 }
13149 D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and"));
13150 expr_ty bitwise_and_var;
13151 if (
13152 (bitwise_and_var = bitwise_and_rule(p)) // bitwise_and
13153 )
13154 {
13155 D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and"));
13156 _res = bitwise_and_var;
13157 goto done;
13158 }
13159 p->mark = _mark;
13160 D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ',
13161 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and"));
13162 }
13163 _res = NULL;
13164 done:
13165 p->level--;
13166 return _res;
13167 }
13168
13169 // Left-recursive
13170 // bitwise_and: bitwise_and '&' shift_expr | shift_expr
13171 static expr_ty bitwise_and_raw(Parser *);
13172 static expr_ty
13173 bitwise_and_rule(Parser *p)
13174 {
13175 if (p->level++ == MAXSTACK) {
13176 _Pypegen_stack_overflow(p);
13177 }
13178 expr_ty _res = NULL;
13179 if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) {
13180 p->level--;
13181 return _res;
13182 }
13183 int _mark = p->mark;
13184 int _resmark = p->mark;
13185 while (1) {
13186 int tmpvar_4 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res);
13187 if (tmpvar_4) {
13188 p->level--;
13189 return _res;
13190 }
13191 p->mark = _mark;
13192 void *_raw = bitwise_and_raw(p);
13193 if (p->error_indicator) {
13194 p->level--;
13195 return NULL;
13196 }
13197 if (_raw == NULL || p->mark <= _resmark)
13198 break;
13199 _resmark = p->mark;
13200 _res = _raw;
13201 }
13202 p->mark = _resmark;
13203 p->level--;
13204 return _res;
13205 }
13206 static expr_ty
13207 bitwise_and_raw(Parser *p)
13208 {
13209 if (p->level++ == MAXSTACK) {
13210 _Pypegen_stack_overflow(p);
13211 }
13212 if (p->error_indicator) {
13213 p->level--;
13214 return NULL;
13215 }
13216 expr_ty _res = NULL;
13217 int _mark = p->mark;
13218 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13219 p->error_indicator = 1;
13220 p->level--;
13221 return NULL;
13222 }
13223 int _start_lineno = p->tokens[_mark]->lineno;
13224 UNUSED(_start_lineno); // Only used by EXTRA macro
13225 int _start_col_offset = p->tokens[_mark]->col_offset;
13226 UNUSED(_start_col_offset); // Only used by EXTRA macro
13227 { // bitwise_and '&' shift_expr
13228 if (p->error_indicator) {
13229 p->level--;
13230 return NULL;
13231 }
13232 D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr"));
13233 Token * _literal;
13234 expr_ty a;
13235 expr_ty b;
13236 if (
13237 (a = bitwise_and_rule(p)) // bitwise_and
13238 &&
13239 (_literal = _PyPegen_expect_token(p, 19)) // token='&'
13240 &&
13241 (b = shift_expr_rule(p)) // shift_expr
13242 )
13243 {
13244 D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr"));
13245 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13246 if (_token == NULL) {
13247 p->level--;
13248 return NULL;
13249 }
13250 int _end_lineno = _token->end_lineno;
13251 UNUSED(_end_lineno); // Only used by EXTRA macro
13252 int _end_col_offset = _token->end_col_offset;
13253 UNUSED(_end_col_offset); // Only used by EXTRA macro
13254 _res = _PyAST_BinOp ( a , BitAnd , b , EXTRA );
13255 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13256 p->error_indicator = 1;
13257 p->level--;
13258 return NULL;
13259 }
13260 goto done;
13261 }
13262 p->mark = _mark;
13263 D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ',
13264 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and '&' shift_expr"));
13265 }
13266 { // shift_expr
13267 if (p->error_indicator) {
13268 p->level--;
13269 return NULL;
13270 }
13271 D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr"));
13272 expr_ty shift_expr_var;
13273 if (
13274 (shift_expr_var = shift_expr_rule(p)) // shift_expr
13275 )
13276 {
13277 D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr"));
13278 _res = shift_expr_var;
13279 goto done;
13280 }
13281 p->mark = _mark;
13282 D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ',
13283 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr"));
13284 }
13285 _res = NULL;
13286 done:
13287 p->level--;
13288 return _res;
13289 }
13290
13291 // Left-recursive
13292 // shift_expr: shift_expr '<<' sum | shift_expr '>>' sum | invalid_arithmetic | sum
13293 static expr_ty shift_expr_raw(Parser *);
13294 static expr_ty
13295 shift_expr_rule(Parser *p)
13296 {
13297 if (p->level++ == MAXSTACK) {
13298 _Pypegen_stack_overflow(p);
13299 }
13300 expr_ty _res = NULL;
13301 if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) {
13302 p->level--;
13303 return _res;
13304 }
13305 int _mark = p->mark;
13306 int _resmark = p->mark;
13307 while (1) {
13308 int tmpvar_5 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res);
13309 if (tmpvar_5) {
13310 p->level--;
13311 return _res;
13312 }
13313 p->mark = _mark;
13314 void *_raw = shift_expr_raw(p);
13315 if (p->error_indicator) {
13316 p->level--;
13317 return NULL;
13318 }
13319 if (_raw == NULL || p->mark <= _resmark)
13320 break;
13321 _resmark = p->mark;
13322 _res = _raw;
13323 }
13324 p->mark = _resmark;
13325 p->level--;
13326 return _res;
13327 }
13328 static expr_ty
13329 shift_expr_raw(Parser *p)
13330 {
13331 if (p->level++ == MAXSTACK) {
13332 _Pypegen_stack_overflow(p);
13333 }
13334 if (p->error_indicator) {
13335 p->level--;
13336 return NULL;
13337 }
13338 expr_ty _res = NULL;
13339 int _mark = p->mark;
13340 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13341 p->error_indicator = 1;
13342 p->level--;
13343 return NULL;
13344 }
13345 int _start_lineno = p->tokens[_mark]->lineno;
13346 UNUSED(_start_lineno); // Only used by EXTRA macro
13347 int _start_col_offset = p->tokens[_mark]->col_offset;
13348 UNUSED(_start_col_offset); // Only used by EXTRA macro
13349 { // shift_expr '<<' sum
13350 if (p->error_indicator) {
13351 p->level--;
13352 return NULL;
13353 }
13354 D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum"));
13355 Token * _literal;
13356 expr_ty a;
13357 expr_ty b;
13358 if (
13359 (a = shift_expr_rule(p)) // shift_expr
13360 &&
13361 (_literal = _PyPegen_expect_token(p, 33)) // token='<<'
13362 &&
13363 (b = sum_rule(p)) // sum
13364 )
13365 {
13366 D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum"));
13367 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13368 if (_token == NULL) {
13369 p->level--;
13370 return NULL;
13371 }
13372 int _end_lineno = _token->end_lineno;
13373 UNUSED(_end_lineno); // Only used by EXTRA macro
13374 int _end_col_offset = _token->end_col_offset;
13375 UNUSED(_end_col_offset); // Only used by EXTRA macro
13376 _res = _PyAST_BinOp ( a , LShift , b , EXTRA );
13377 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13378 p->error_indicator = 1;
13379 p->level--;
13380 return NULL;
13381 }
13382 goto done;
13383 }
13384 p->mark = _mark;
13385 D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',
13386 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '<<' sum"));
13387 }
13388 { // shift_expr '>>' sum
13389 if (p->error_indicator) {
13390 p->level--;
13391 return NULL;
13392 }
13393 D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum"));
13394 Token * _literal;
13395 expr_ty a;
13396 expr_ty b;
13397 if (
13398 (a = shift_expr_rule(p)) // shift_expr
13399 &&
13400 (_literal = _PyPegen_expect_token(p, 34)) // token='>>'
13401 &&
13402 (b = sum_rule(p)) // sum
13403 )
13404 {
13405 D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum"));
13406 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13407 if (_token == NULL) {
13408 p->level--;
13409 return NULL;
13410 }
13411 int _end_lineno = _token->end_lineno;
13412 UNUSED(_end_lineno); // Only used by EXTRA macro
13413 int _end_col_offset = _token->end_col_offset;
13414 UNUSED(_end_col_offset); // Only used by EXTRA macro
13415 _res = _PyAST_BinOp ( a , RShift , b , EXTRA );
13416 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13417 p->error_indicator = 1;
13418 p->level--;
13419 return NULL;
13420 }
13421 goto done;
13422 }
13423 p->mark = _mark;
13424 D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',
13425 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '>>' sum"));
13426 }
13427 if (p->call_invalid_rules) { // invalid_arithmetic
13428 if (p->error_indicator) {
13429 p->level--;
13430 return NULL;
13431 }
13432 D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_arithmetic"));
13433 void *invalid_arithmetic_var;
13434 if (
13435 (invalid_arithmetic_var = invalid_arithmetic_rule(p)) // invalid_arithmetic
13436 )
13437 {
13438 D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_arithmetic"));
13439 _res = invalid_arithmetic_var;
13440 goto done;
13441 }
13442 p->mark = _mark;
13443 D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',
13444 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_arithmetic"));
13445 }
13446 { // sum
13447 if (p->error_indicator) {
13448 p->level--;
13449 return NULL;
13450 }
13451 D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum"));
13452 expr_ty sum_var;
13453 if (
13454 (sum_var = sum_rule(p)) // sum
13455 )
13456 {
13457 D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum"));
13458 _res = sum_var;
13459 goto done;
13460 }
13461 p->mark = _mark;
13462 D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',
13463 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum"));
13464 }
13465 _res = NULL;
13466 done:
13467 p->level--;
13468 return _res;
13469 }
13470
13471 // Left-recursive
13472 // sum: sum '+' term | sum '-' term | term
13473 static expr_ty sum_raw(Parser *);
13474 static expr_ty
13475 sum_rule(Parser *p)
13476 {
13477 if (p->level++ == MAXSTACK) {
13478 _Pypegen_stack_overflow(p);
13479 }
13480 expr_ty _res = NULL;
13481 if (_PyPegen_is_memoized(p, sum_type, &_res)) {
13482 p->level--;
13483 return _res;
13484 }
13485 int _mark = p->mark;
13486 int _resmark = p->mark;
13487 while (1) {
13488 int tmpvar_6 = _PyPegen_update_memo(p, _mark, sum_type, _res);
13489 if (tmpvar_6) {
13490 p->level--;
13491 return _res;
13492 }
13493 p->mark = _mark;
13494 void *_raw = sum_raw(p);
13495 if (p->error_indicator) {
13496 p->level--;
13497 return NULL;
13498 }
13499 if (_raw == NULL || p->mark <= _resmark)
13500 break;
13501 _resmark = p->mark;
13502 _res = _raw;
13503 }
13504 p->mark = _resmark;
13505 p->level--;
13506 return _res;
13507 }
13508 static expr_ty
13509 sum_raw(Parser *p)
13510 {
13511 if (p->level++ == MAXSTACK) {
13512 _Pypegen_stack_overflow(p);
13513 }
13514 if (p->error_indicator) {
13515 p->level--;
13516 return NULL;
13517 }
13518 expr_ty _res = NULL;
13519 int _mark = p->mark;
13520 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13521 p->error_indicator = 1;
13522 p->level--;
13523 return NULL;
13524 }
13525 int _start_lineno = p->tokens[_mark]->lineno;
13526 UNUSED(_start_lineno); // Only used by EXTRA macro
13527 int _start_col_offset = p->tokens[_mark]->col_offset;
13528 UNUSED(_start_col_offset); // Only used by EXTRA macro
13529 { // sum '+' term
13530 if (p->error_indicator) {
13531 p->level--;
13532 return NULL;
13533 }
13534 D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '+' term"));
13535 Token * _literal;
13536 expr_ty a;
13537 expr_ty b;
13538 if (
13539 (a = sum_rule(p)) // sum
13540 &&
13541 (_literal = _PyPegen_expect_token(p, 14)) // token='+'
13542 &&
13543 (b = term_rule(p)) // term
13544 )
13545 {
13546 D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term"));
13547 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13548 if (_token == NULL) {
13549 p->level--;
13550 return NULL;
13551 }
13552 int _end_lineno = _token->end_lineno;
13553 UNUSED(_end_lineno); // Only used by EXTRA macro
13554 int _end_col_offset = _token->end_col_offset;
13555 UNUSED(_end_col_offset); // Only used by EXTRA macro
13556 _res = _PyAST_BinOp ( a , Add , b , EXTRA );
13557 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13558 p->error_indicator = 1;
13559 p->level--;
13560 return NULL;
13561 }
13562 goto done;
13563 }
13564 p->mark = _mark;
13565 D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',
13566 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '+' term"));
13567 }
13568 { // sum '-' term
13569 if (p->error_indicator) {
13570 p->level--;
13571 return NULL;
13572 }
13573 D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '-' term"));
13574 Token * _literal;
13575 expr_ty a;
13576 expr_ty b;
13577 if (
13578 (a = sum_rule(p)) // sum
13579 &&
13580 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
13581 &&
13582 (b = term_rule(p)) // term
13583 )
13584 {
13585 D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term"));
13586 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13587 if (_token == NULL) {
13588 p->level--;
13589 return NULL;
13590 }
13591 int _end_lineno = _token->end_lineno;
13592 UNUSED(_end_lineno); // Only used by EXTRA macro
13593 int _end_col_offset = _token->end_col_offset;
13594 UNUSED(_end_col_offset); // Only used by EXTRA macro
13595 _res = _PyAST_BinOp ( a , Sub , b , EXTRA );
13596 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13597 p->error_indicator = 1;
13598 p->level--;
13599 return NULL;
13600 }
13601 goto done;
13602 }
13603 p->mark = _mark;
13604 D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',
13605 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '-' term"));
13606 }
13607 { // term
13608 if (p->error_indicator) {
13609 p->level--;
13610 return NULL;
13611 }
13612 D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term"));
13613 expr_ty term_var;
13614 if (
13615 (term_var = term_rule(p)) // term
13616 )
13617 {
13618 D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term"));
13619 _res = term_var;
13620 goto done;
13621 }
13622 p->mark = _mark;
13623 D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',
13624 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term"));
13625 }
13626 _res = NULL;
13627 done:
13628 p->level--;
13629 return _res;
13630 }
13631
13632 // Left-recursive
13633 // term:
13634 // | term '*' factor
13635 // | term '/' factor
13636 // | term '//' factor
13637 // | term '%' factor
13638 // | term '@' factor
13639 // | invalid_factor
13640 // | factor
13641 static expr_ty term_raw(Parser *);
13642 static expr_ty
13643 term_rule(Parser *p)
13644 {
13645 if (p->level++ == MAXSTACK) {
13646 _Pypegen_stack_overflow(p);
13647 }
13648 expr_ty _res = NULL;
13649 if (_PyPegen_is_memoized(p, term_type, &_res)) {
13650 p->level--;
13651 return _res;
13652 }
13653 int _mark = p->mark;
13654 int _resmark = p->mark;
13655 while (1) {
13656 int tmpvar_7 = _PyPegen_update_memo(p, _mark, term_type, _res);
13657 if (tmpvar_7) {
13658 p->level--;
13659 return _res;
13660 }
13661 p->mark = _mark;
13662 void *_raw = term_raw(p);
13663 if (p->error_indicator) {
13664 p->level--;
13665 return NULL;
13666 }
13667 if (_raw == NULL || p->mark <= _resmark)
13668 break;
13669 _resmark = p->mark;
13670 _res = _raw;
13671 }
13672 p->mark = _resmark;
13673 p->level--;
13674 return _res;
13675 }
13676 static expr_ty
13677 term_raw(Parser *p)
13678 {
13679 if (p->level++ == MAXSTACK) {
13680 _Pypegen_stack_overflow(p);
13681 }
13682 if (p->error_indicator) {
13683 p->level--;
13684 return NULL;
13685 }
13686 expr_ty _res = NULL;
13687 int _mark = p->mark;
13688 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13689 p->error_indicator = 1;
13690 p->level--;
13691 return NULL;
13692 }
13693 int _start_lineno = p->tokens[_mark]->lineno;
13694 UNUSED(_start_lineno); // Only used by EXTRA macro
13695 int _start_col_offset = p->tokens[_mark]->col_offset;
13696 UNUSED(_start_col_offset); // Only used by EXTRA macro
13697 { // term '*' factor
13698 if (p->error_indicator) {
13699 p->level--;
13700 return NULL;
13701 }
13702 D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '*' factor"));
13703 Token * _literal;
13704 expr_ty a;
13705 expr_ty b;
13706 if (
13707 (a = term_rule(p)) // term
13708 &&
13709 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
13710 &&
13711 (b = factor_rule(p)) // factor
13712 )
13713 {
13714 D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' factor"));
13715 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13716 if (_token == NULL) {
13717 p->level--;
13718 return NULL;
13719 }
13720 int _end_lineno = _token->end_lineno;
13721 UNUSED(_end_lineno); // Only used by EXTRA macro
13722 int _end_col_offset = _token->end_col_offset;
13723 UNUSED(_end_col_offset); // Only used by EXTRA macro
13724 _res = _PyAST_BinOp ( a , Mult , b , EXTRA );
13725 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13726 p->error_indicator = 1;
13727 p->level--;
13728 return NULL;
13729 }
13730 goto done;
13731 }
13732 p->mark = _mark;
13733 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
13734 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '*' factor"));
13735 }
13736 { // term '/' factor
13737 if (p->error_indicator) {
13738 p->level--;
13739 return NULL;
13740 }
13741 D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '/' factor"));
13742 Token * _literal;
13743 expr_ty a;
13744 expr_ty b;
13745 if (
13746 (a = term_rule(p)) // term
13747 &&
13748 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
13749 &&
13750 (b = factor_rule(p)) // factor
13751 )
13752 {
13753 D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' factor"));
13754 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13755 if (_token == NULL) {
13756 p->level--;
13757 return NULL;
13758 }
13759 int _end_lineno = _token->end_lineno;
13760 UNUSED(_end_lineno); // Only used by EXTRA macro
13761 int _end_col_offset = _token->end_col_offset;
13762 UNUSED(_end_col_offset); // Only used by EXTRA macro
13763 _res = _PyAST_BinOp ( a , Div , b , EXTRA );
13764 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13765 p->error_indicator = 1;
13766 p->level--;
13767 return NULL;
13768 }
13769 goto done;
13770 }
13771 p->mark = _mark;
13772 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
13773 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '/' factor"));
13774 }
13775 { // term '//' factor
13776 if (p->error_indicator) {
13777 p->level--;
13778 return NULL;
13779 }
13780 D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '//' factor"));
13781 Token * _literal;
13782 expr_ty a;
13783 expr_ty b;
13784 if (
13785 (a = term_rule(p)) // term
13786 &&
13787 (_literal = _PyPegen_expect_token(p, 47)) // token='//'
13788 &&
13789 (b = factor_rule(p)) // factor
13790 )
13791 {
13792 D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' factor"));
13793 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13794 if (_token == NULL) {
13795 p->level--;
13796 return NULL;
13797 }
13798 int _end_lineno = _token->end_lineno;
13799 UNUSED(_end_lineno); // Only used by EXTRA macro
13800 int _end_col_offset = _token->end_col_offset;
13801 UNUSED(_end_col_offset); // Only used by EXTRA macro
13802 _res = _PyAST_BinOp ( a , FloorDiv , b , EXTRA );
13803 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13804 p->error_indicator = 1;
13805 p->level--;
13806 return NULL;
13807 }
13808 goto done;
13809 }
13810 p->mark = _mark;
13811 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
13812 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '//' factor"));
13813 }
13814 { // term '%' factor
13815 if (p->error_indicator) {
13816 p->level--;
13817 return NULL;
13818 }
13819 D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '%' factor"));
13820 Token * _literal;
13821 expr_ty a;
13822 expr_ty b;
13823 if (
13824 (a = term_rule(p)) // term
13825 &&
13826 (_literal = _PyPegen_expect_token(p, 24)) // token='%'
13827 &&
13828 (b = factor_rule(p)) // factor
13829 )
13830 {
13831 D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' factor"));
13832 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13833 if (_token == NULL) {
13834 p->level--;
13835 return NULL;
13836 }
13837 int _end_lineno = _token->end_lineno;
13838 UNUSED(_end_lineno); // Only used by EXTRA macro
13839 int _end_col_offset = _token->end_col_offset;
13840 UNUSED(_end_col_offset); // Only used by EXTRA macro
13841 _res = _PyAST_BinOp ( a , Mod , b , EXTRA );
13842 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13843 p->error_indicator = 1;
13844 p->level--;
13845 return NULL;
13846 }
13847 goto done;
13848 }
13849 p->mark = _mark;
13850 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
13851 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '%' factor"));
13852 }
13853 { // term '@' factor
13854 if (p->error_indicator) {
13855 p->level--;
13856 return NULL;
13857 }
13858 D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '@' factor"));
13859 Token * _literal;
13860 expr_ty a;
13861 expr_ty b;
13862 if (
13863 (a = term_rule(p)) // term
13864 &&
13865 (_literal = _PyPegen_expect_token(p, 49)) // token='@'
13866 &&
13867 (b = factor_rule(p)) // factor
13868 )
13869 {
13870 D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '@' factor"));
13871 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13872 if (_token == NULL) {
13873 p->level--;
13874 return NULL;
13875 }
13876 int _end_lineno = _token->end_lineno;
13877 UNUSED(_end_lineno); // Only used by EXTRA macro
13878 int _end_col_offset = _token->end_col_offset;
13879 UNUSED(_end_col_offset); // Only used by EXTRA macro
13880 _res = CHECK_VERSION ( expr_ty , 5 , "The '@' operator is" , _PyAST_BinOp ( a , MatMult , b , EXTRA ) );
13881 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13882 p->error_indicator = 1;
13883 p->level--;
13884 return NULL;
13885 }
13886 goto done;
13887 }
13888 p->mark = _mark;
13889 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
13890 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '@' factor"));
13891 }
13892 if (p->call_invalid_rules) { // invalid_factor
13893 if (p->error_indicator) {
13894 p->level--;
13895 return NULL;
13896 }
13897 D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_factor"));
13898 void *invalid_factor_var;
13899 if (
13900 (invalid_factor_var = invalid_factor_rule(p)) // invalid_factor
13901 )
13902 {
13903 D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_factor"));
13904 _res = invalid_factor_var;
13905 goto done;
13906 }
13907 p->mark = _mark;
13908 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
13909 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_factor"));
13910 }
13911 { // factor
13912 if (p->error_indicator) {
13913 p->level--;
13914 return NULL;
13915 }
13916 D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "factor"));
13917 expr_ty factor_var;
13918 if (
13919 (factor_var = factor_rule(p)) // factor
13920 )
13921 {
13922 D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "factor"));
13923 _res = factor_var;
13924 goto done;
13925 }
13926 p->mark = _mark;
13927 D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
13928 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "factor"));
13929 }
13930 _res = NULL;
13931 done:
13932 p->level--;
13933 return _res;
13934 }
13935
13936 // factor: '+' factor | '-' factor | '~' factor | power
13937 static expr_ty
13938 factor_rule(Parser *p)
13939 {
13940 if (p->level++ == MAXSTACK) {
13941 _Pypegen_stack_overflow(p);
13942 }
13943 if (p->error_indicator) {
13944 p->level--;
13945 return NULL;
13946 }
13947 expr_ty _res = NULL;
13948 if (_PyPegen_is_memoized(p, factor_type, &_res)) {
13949 p->level--;
13950 return _res;
13951 }
13952 int _mark = p->mark;
13953 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
13954 p->error_indicator = 1;
13955 p->level--;
13956 return NULL;
13957 }
13958 int _start_lineno = p->tokens[_mark]->lineno;
13959 UNUSED(_start_lineno); // Only used by EXTRA macro
13960 int _start_col_offset = p->tokens[_mark]->col_offset;
13961 UNUSED(_start_col_offset); // Only used by EXTRA macro
13962 { // '+' factor
13963 if (p->error_indicator) {
13964 p->level--;
13965 return NULL;
13966 }
13967 D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+' factor"));
13968 Token * _literal;
13969 expr_ty a;
13970 if (
13971 (_literal = _PyPegen_expect_token(p, 14)) // token='+'
13972 &&
13973 (a = factor_rule(p)) // factor
13974 )
13975 {
13976 D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' factor"));
13977 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
13978 if (_token == NULL) {
13979 p->level--;
13980 return NULL;
13981 }
13982 int _end_lineno = _token->end_lineno;
13983 UNUSED(_end_lineno); // Only used by EXTRA macro
13984 int _end_col_offset = _token->end_col_offset;
13985 UNUSED(_end_col_offset); // Only used by EXTRA macro
13986 _res = _PyAST_UnaryOp ( UAdd , a , EXTRA );
13987 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
13988 p->error_indicator = 1;
13989 p->level--;
13990 return NULL;
13991 }
13992 goto done;
13993 }
13994 p->mark = _mark;
13995 D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
13996 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' factor"));
13997 }
13998 { // '-' factor
13999 if (p->error_indicator) {
14000 p->level--;
14001 return NULL;
14002 }
14003 D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' factor"));
14004 Token * _literal;
14005 expr_ty a;
14006 if (
14007 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
14008 &&
14009 (a = factor_rule(p)) // factor
14010 )
14011 {
14012 D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' factor"));
14013 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14014 if (_token == NULL) {
14015 p->level--;
14016 return NULL;
14017 }
14018 int _end_lineno = _token->end_lineno;
14019 UNUSED(_end_lineno); // Only used by EXTRA macro
14020 int _end_col_offset = _token->end_col_offset;
14021 UNUSED(_end_col_offset); // Only used by EXTRA macro
14022 _res = _PyAST_UnaryOp ( USub , a , EXTRA );
14023 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14024 p->error_indicator = 1;
14025 p->level--;
14026 return NULL;
14027 }
14028 goto done;
14029 }
14030 p->mark = _mark;
14031 D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
14032 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' factor"));
14033 }
14034 { // '~' factor
14035 if (p->error_indicator) {
14036 p->level--;
14037 return NULL;
14038 }
14039 D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~' factor"));
14040 Token * _literal;
14041 expr_ty a;
14042 if (
14043 (_literal = _PyPegen_expect_token(p, 31)) // token='~'
14044 &&
14045 (a = factor_rule(p)) // factor
14046 )
14047 {
14048 D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' factor"));
14049 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14050 if (_token == NULL) {
14051 p->level--;
14052 return NULL;
14053 }
14054 int _end_lineno = _token->end_lineno;
14055 UNUSED(_end_lineno); // Only used by EXTRA macro
14056 int _end_col_offset = _token->end_col_offset;
14057 UNUSED(_end_col_offset); // Only used by EXTRA macro
14058 _res = _PyAST_UnaryOp ( Invert , a , EXTRA );
14059 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14060 p->error_indicator = 1;
14061 p->level--;
14062 return NULL;
14063 }
14064 goto done;
14065 }
14066 p->mark = _mark;
14067 D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
14068 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~' factor"));
14069 }
14070 { // power
14071 if (p->error_indicator) {
14072 p->level--;
14073 return NULL;
14074 }
14075 D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "power"));
14076 expr_ty power_var;
14077 if (
14078 (power_var = power_rule(p)) // power
14079 )
14080 {
14081 D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "power"));
14082 _res = power_var;
14083 goto done;
14084 }
14085 p->mark = _mark;
14086 D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
14087 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power"));
14088 }
14089 _res = NULL;
14090 done:
14091 _PyPegen_insert_memo(p, _mark, factor_type, _res);
14092 p->level--;
14093 return _res;
14094 }
14095
14096 // power: await_primary '**' factor | await_primary
14097 static expr_ty
14098 power_rule(Parser *p)
14099 {
14100 if (p->level++ == MAXSTACK) {
14101 _Pypegen_stack_overflow(p);
14102 }
14103 if (p->error_indicator) {
14104 p->level--;
14105 return NULL;
14106 }
14107 expr_ty _res = NULL;
14108 int _mark = p->mark;
14109 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14110 p->error_indicator = 1;
14111 p->level--;
14112 return NULL;
14113 }
14114 int _start_lineno = p->tokens[_mark]->lineno;
14115 UNUSED(_start_lineno); // Only used by EXTRA macro
14116 int _start_col_offset = p->tokens[_mark]->col_offset;
14117 UNUSED(_start_col_offset); // Only used by EXTRA macro
14118 { // await_primary '**' factor
14119 if (p->error_indicator) {
14120 p->level--;
14121 return NULL;
14122 }
14123 D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor"));
14124 Token * _literal;
14125 expr_ty a;
14126 expr_ty b;
14127 if (
14128 (a = await_primary_rule(p)) // await_primary
14129 &&
14130 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
14131 &&
14132 (b = factor_rule(p)) // factor
14133 )
14134 {
14135 D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor"));
14136 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14137 if (_token == NULL) {
14138 p->level--;
14139 return NULL;
14140 }
14141 int _end_lineno = _token->end_lineno;
14142 UNUSED(_end_lineno); // Only used by EXTRA macro
14143 int _end_col_offset = _token->end_col_offset;
14144 UNUSED(_end_col_offset); // Only used by EXTRA macro
14145 _res = _PyAST_BinOp ( a , Pow , b , EXTRA );
14146 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14147 p->error_indicator = 1;
14148 p->level--;
14149 return NULL;
14150 }
14151 goto done;
14152 }
14153 p->mark = _mark;
14154 D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ',
14155 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary '**' factor"));
14156 }
14157 { // await_primary
14158 if (p->error_indicator) {
14159 p->level--;
14160 return NULL;
14161 }
14162 D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary"));
14163 expr_ty await_primary_var;
14164 if (
14165 (await_primary_var = await_primary_rule(p)) // await_primary
14166 )
14167 {
14168 D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary"));
14169 _res = await_primary_var;
14170 goto done;
14171 }
14172 p->mark = _mark;
14173 D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ',
14174 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary"));
14175 }
14176 _res = NULL;
14177 done:
14178 p->level--;
14179 return _res;
14180 }
14181
14182 // await_primary: 'await' primary | primary
14183 static expr_ty
14184 await_primary_rule(Parser *p)
14185 {
14186 if (p->level++ == MAXSTACK) {
14187 _Pypegen_stack_overflow(p);
14188 }
14189 if (p->error_indicator) {
14190 p->level--;
14191 return NULL;
14192 }
14193 expr_ty _res = NULL;
14194 if (_PyPegen_is_memoized(p, await_primary_type, &_res)) {
14195 p->level--;
14196 return _res;
14197 }
14198 int _mark = p->mark;
14199 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14200 p->error_indicator = 1;
14201 p->level--;
14202 return NULL;
14203 }
14204 int _start_lineno = p->tokens[_mark]->lineno;
14205 UNUSED(_start_lineno); // Only used by EXTRA macro
14206 int _start_col_offset = p->tokens[_mark]->col_offset;
14207 UNUSED(_start_col_offset); // Only used by EXTRA macro
14208 { // 'await' primary
14209 if (p->error_indicator) {
14210 p->level--;
14211 return NULL;
14212 }
14213 D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'await' primary"));
14214 Token * _keyword;
14215 expr_ty a;
14216 if (
14217 (_keyword = _PyPegen_expect_token(p, 590)) // token='await'
14218 &&
14219 (a = primary_rule(p)) // primary
14220 )
14221 {
14222 D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'await' primary"));
14223 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14224 if (_token == NULL) {
14225 p->level--;
14226 return NULL;
14227 }
14228 int _end_lineno = _token->end_lineno;
14229 UNUSED(_end_lineno); // Only used by EXTRA macro
14230 int _end_col_offset = _token->end_col_offset;
14231 UNUSED(_end_col_offset); // Only used by EXTRA macro
14232 _res = CHECK_VERSION ( expr_ty , 5 , "Await expressions are" , _PyAST_Await ( a , EXTRA ) );
14233 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14234 p->error_indicator = 1;
14235 p->level--;
14236 return NULL;
14237 }
14238 goto done;
14239 }
14240 p->mark = _mark;
14241 D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ',
14242 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'await' primary"));
14243 }
14244 { // primary
14245 if (p->error_indicator) {
14246 p->level--;
14247 return NULL;
14248 }
14249 D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary"));
14250 expr_ty primary_var;
14251 if (
14252 (primary_var = primary_rule(p)) // primary
14253 )
14254 {
14255 D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary"));
14256 _res = primary_var;
14257 goto done;
14258 }
14259 p->mark = _mark;
14260 D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ',
14261 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary"));
14262 }
14263 _res = NULL;
14264 done:
14265 _PyPegen_insert_memo(p, _mark, await_primary_type, _res);
14266 p->level--;
14267 return _res;
14268 }
14269
14270 // Left-recursive
14271 // primary:
14272 // | primary '.' NAME
14273 // | primary genexp
14274 // | primary '(' arguments? ')'
14275 // | primary '[' slices ']'
14276 // | atom
14277 static expr_ty primary_raw(Parser *);
14278 static expr_ty
14279 primary_rule(Parser *p)
14280 {
14281 if (p->level++ == MAXSTACK) {
14282 _Pypegen_stack_overflow(p);
14283 }
14284 expr_ty _res = NULL;
14285 if (_PyPegen_is_memoized(p, primary_type, &_res)) {
14286 p->level--;
14287 return _res;
14288 }
14289 int _mark = p->mark;
14290 int _resmark = p->mark;
14291 while (1) {
14292 int tmpvar_8 = _PyPegen_update_memo(p, _mark, primary_type, _res);
14293 if (tmpvar_8) {
14294 p->level--;
14295 return _res;
14296 }
14297 p->mark = _mark;
14298 void *_raw = primary_raw(p);
14299 if (p->error_indicator) {
14300 p->level--;
14301 return NULL;
14302 }
14303 if (_raw == NULL || p->mark <= _resmark)
14304 break;
14305 _resmark = p->mark;
14306 _res = _raw;
14307 }
14308 p->mark = _resmark;
14309 p->level--;
14310 return _res;
14311 }
14312 static expr_ty
14313 primary_raw(Parser *p)
14314 {
14315 if (p->level++ == MAXSTACK) {
14316 _Pypegen_stack_overflow(p);
14317 }
14318 if (p->error_indicator) {
14319 p->level--;
14320 return NULL;
14321 }
14322 expr_ty _res = NULL;
14323 int _mark = p->mark;
14324 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14325 p->error_indicator = 1;
14326 p->level--;
14327 return NULL;
14328 }
14329 int _start_lineno = p->tokens[_mark]->lineno;
14330 UNUSED(_start_lineno); // Only used by EXTRA macro
14331 int _start_col_offset = p->tokens[_mark]->col_offset;
14332 UNUSED(_start_col_offset); // Only used by EXTRA macro
14333 { // primary '.' NAME
14334 if (p->error_indicator) {
14335 p->level--;
14336 return NULL;
14337 }
14338 D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));
14339 Token * _literal;
14340 expr_ty a;
14341 expr_ty b;
14342 if (
14343 (a = primary_rule(p)) // primary
14344 &&
14345 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
14346 &&
14347 (b = _PyPegen_name_token(p)) // NAME
14348 )
14349 {
14350 D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));
14351 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14352 if (_token == NULL) {
14353 p->level--;
14354 return NULL;
14355 }
14356 int _end_lineno = _token->end_lineno;
14357 UNUSED(_end_lineno); // Only used by EXTRA macro
14358 int _end_col_offset = _token->end_col_offset;
14359 UNUSED(_end_col_offset); // Only used by EXTRA macro
14360 _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA );
14361 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14362 p->error_indicator = 1;
14363 p->level--;
14364 return NULL;
14365 }
14366 goto done;
14367 }
14368 p->mark = _mark;
14369 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
14370 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '.' NAME"));
14371 }
14372 { // primary genexp
14373 if (p->error_indicator) {
14374 p->level--;
14375 return NULL;
14376 }
14377 D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary genexp"));
14378 expr_ty a;
14379 expr_ty b;
14380 if (
14381 (a = primary_rule(p)) // primary
14382 &&
14383 (b = genexp_rule(p)) // genexp
14384 )
14385 {
14386 D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary genexp"));
14387 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14388 if (_token == NULL) {
14389 p->level--;
14390 return NULL;
14391 }
14392 int _end_lineno = _token->end_lineno;
14393 UNUSED(_end_lineno); // Only used by EXTRA macro
14394 int _end_col_offset = _token->end_col_offset;
14395 UNUSED(_end_col_offset); // Only used by EXTRA macro
14396 _res = _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
14397 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14398 p->error_indicator = 1;
14399 p->level--;
14400 return NULL;
14401 }
14402 goto done;
14403 }
14404 p->mark = _mark;
14405 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
14406 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary genexp"));
14407 }
14408 { // primary '(' arguments? ')'
14409 if (p->error_indicator) {
14410 p->level--;
14411 return NULL;
14412 }
14413 D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'"));
14414 Token * _literal;
14415 Token * _literal_1;
14416 expr_ty a;
14417 void *b;
14418 if (
14419 (a = primary_rule(p)) // primary
14420 &&
14421 (_literal = _PyPegen_expect_token(p, 7)) // token='('
14422 &&
14423 (b = arguments_rule(p), !p->error_indicator) // arguments?
14424 &&
14425 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
14426 )
14427 {
14428 D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'"));
14429 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14430 if (_token == NULL) {
14431 p->level--;
14432 return NULL;
14433 }
14434 int _end_lineno = _token->end_lineno;
14435 UNUSED(_end_lineno); // Only used by EXTRA macro
14436 int _end_col_offset = _token->end_col_offset;
14437 UNUSED(_end_col_offset); // Only used by EXTRA macro
14438 _res = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
14439 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14440 p->error_indicator = 1;
14441 p->level--;
14442 return NULL;
14443 }
14444 goto done;
14445 }
14446 p->mark = _mark;
14447 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
14448 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '(' arguments? ')'"));
14449 }
14450 { // primary '[' slices ']'
14451 if (p->error_indicator) {
14452 p->level--;
14453 return NULL;
14454 }
14455 D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'"));
14456 Token * _literal;
14457 Token * _literal_1;
14458 expr_ty a;
14459 expr_ty b;
14460 if (
14461 (a = primary_rule(p)) // primary
14462 &&
14463 (_literal = _PyPegen_expect_token(p, 9)) // token='['
14464 &&
14465 (b = slices_rule(p)) // slices
14466 &&
14467 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
14468 )
14469 {
14470 D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'"));
14471 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14472 if (_token == NULL) {
14473 p->level--;
14474 return NULL;
14475 }
14476 int _end_lineno = _token->end_lineno;
14477 UNUSED(_end_lineno); // Only used by EXTRA macro
14478 int _end_col_offset = _token->end_col_offset;
14479 UNUSED(_end_col_offset); // Only used by EXTRA macro
14480 _res = _PyAST_Subscript ( a , b , Load , EXTRA );
14481 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14482 p->error_indicator = 1;
14483 p->level--;
14484 return NULL;
14485 }
14486 goto done;
14487 }
14488 p->mark = _mark;
14489 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
14490 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '[' slices ']'"));
14491 }
14492 { // atom
14493 if (p->error_indicator) {
14494 p->level--;
14495 return NULL;
14496 }
14497 D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom"));
14498 expr_ty atom_var;
14499 if (
14500 (atom_var = atom_rule(p)) // atom
14501 )
14502 {
14503 D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom"));
14504 _res = atom_var;
14505 goto done;
14506 }
14507 p->mark = _mark;
14508 D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
14509 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom"));
14510 }
14511 _res = NULL;
14512 done:
14513 p->level--;
14514 return _res;
14515 }
14516
14517 // slices: slice !',' | ','.(slice | starred_expression)+ ','?
14518 static expr_ty
14519 slices_rule(Parser *p)
14520 {
14521 if (p->level++ == MAXSTACK) {
14522 _Pypegen_stack_overflow(p);
14523 }
14524 if (p->error_indicator) {
14525 p->level--;
14526 return NULL;
14527 }
14528 expr_ty _res = NULL;
14529 int _mark = p->mark;
14530 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14531 p->error_indicator = 1;
14532 p->level--;
14533 return NULL;
14534 }
14535 int _start_lineno = p->tokens[_mark]->lineno;
14536 UNUSED(_start_lineno); // Only used by EXTRA macro
14537 int _start_col_offset = p->tokens[_mark]->col_offset;
14538 UNUSED(_start_col_offset); // Only used by EXTRA macro
14539 { // slice !','
14540 if (p->error_indicator) {
14541 p->level--;
14542 return NULL;
14543 }
14544 D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','"));
14545 expr_ty a;
14546 if (
14547 (a = slice_rule(p)) // slice
14548 &&
14549 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
14550 )
14551 {
14552 D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice !','"));
14553 _res = a;
14554 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14555 p->error_indicator = 1;
14556 p->level--;
14557 return NULL;
14558 }
14559 goto done;
14560 }
14561 p->mark = _mark;
14562 D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ',
14563 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice !','"));
14564 }
14565 { // ','.(slice | starred_expression)+ ','?
14566 if (p->error_indicator) {
14567 p->level--;
14568 return NULL;
14569 }
14570 D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(slice | starred_expression)+ ','?"));
14571 void *_opt_var;
14572 UNUSED(_opt_var); // Silence compiler warnings
14573 asdl_expr_seq* a;
14574 if (
14575 (a = (asdl_expr_seq*)_gather_90_rule(p)) // ','.(slice | starred_expression)+
14576 &&
14577 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
14578 )
14579 {
14580 D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(slice | starred_expression)+ ','?"));
14581 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14582 if (_token == NULL) {
14583 p->level--;
14584 return NULL;
14585 }
14586 int _end_lineno = _token->end_lineno;
14587 UNUSED(_end_lineno); // Only used by EXTRA macro
14588 int _end_col_offset = _token->end_col_offset;
14589 UNUSED(_end_col_offset); // Only used by EXTRA macro
14590 _res = _PyAST_Tuple ( a , Load , EXTRA );
14591 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14592 p->error_indicator = 1;
14593 p->level--;
14594 return NULL;
14595 }
14596 goto done;
14597 }
14598 p->mark = _mark;
14599 D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ',
14600 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(slice | starred_expression)+ ','?"));
14601 }
14602 _res = NULL;
14603 done:
14604 p->level--;
14605 return _res;
14606 }
14607
14608 // slice: expression? ':' expression? [':' expression?] | named_expression
14609 static expr_ty
14610 slice_rule(Parser *p)
14611 {
14612 if (p->level++ == MAXSTACK) {
14613 _Pypegen_stack_overflow(p);
14614 }
14615 if (p->error_indicator) {
14616 p->level--;
14617 return NULL;
14618 }
14619 expr_ty _res = NULL;
14620 int _mark = p->mark;
14621 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14622 p->error_indicator = 1;
14623 p->level--;
14624 return NULL;
14625 }
14626 int _start_lineno = p->tokens[_mark]->lineno;
14627 UNUSED(_start_lineno); // Only used by EXTRA macro
14628 int _start_col_offset = p->tokens[_mark]->col_offset;
14629 UNUSED(_start_col_offset); // Only used by EXTRA macro
14630 { // expression? ':' expression? [':' expression?]
14631 if (p->error_indicator) {
14632 p->level--;
14633 return NULL;
14634 }
14635 D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]"));
14636 Token * _literal;
14637 void *a;
14638 void *b;
14639 void *c;
14640 if (
14641 (a = expression_rule(p), !p->error_indicator) // expression?
14642 &&
14643 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
14644 &&
14645 (b = expression_rule(p), !p->error_indicator) // expression?
14646 &&
14647 (c = _tmp_92_rule(p), !p->error_indicator) // [':' expression?]
14648 )
14649 {
14650 D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]"));
14651 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14652 if (_token == NULL) {
14653 p->level--;
14654 return NULL;
14655 }
14656 int _end_lineno = _token->end_lineno;
14657 UNUSED(_end_lineno); // Only used by EXTRA macro
14658 int _end_col_offset = _token->end_col_offset;
14659 UNUSED(_end_col_offset); // Only used by EXTRA macro
14660 _res = _PyAST_Slice ( a , b , c , EXTRA );
14661 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14662 p->error_indicator = 1;
14663 p->level--;
14664 return NULL;
14665 }
14666 goto done;
14667 }
14668 p->mark = _mark;
14669 D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',
14670 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?]"));
14671 }
14672 { // named_expression
14673 if (p->error_indicator) {
14674 p->level--;
14675 return NULL;
14676 }
14677 D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
14678 expr_ty a;
14679 if (
14680 (a = named_expression_rule(p)) // named_expression
14681 )
14682 {
14683 D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
14684 _res = a;
14685 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14686 p->error_indicator = 1;
14687 p->level--;
14688 return NULL;
14689 }
14690 goto done;
14691 }
14692 p->mark = _mark;
14693 D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',
14694 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
14695 }
14696 _res = NULL;
14697 done:
14698 p->level--;
14699 return _res;
14700 }
14701
14702 // atom:
14703 // | NAME
14704 // | 'True'
14705 // | 'False'
14706 // | 'None'
14707 // | &(STRING | FSTRING_START) strings
14708 // | NUMBER
14709 // | &'(' (tuple | group | genexp)
14710 // | &'[' (list | listcomp)
14711 // | &'{' (dict | set | dictcomp | setcomp)
14712 // | '...'
14713 static expr_ty
14714 atom_rule(Parser *p)
14715 {
14716 if (p->level++ == MAXSTACK) {
14717 _Pypegen_stack_overflow(p);
14718 }
14719 if (p->error_indicator) {
14720 p->level--;
14721 return NULL;
14722 }
14723 expr_ty _res = NULL;
14724 int _mark = p->mark;
14725 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
14726 p->error_indicator = 1;
14727 p->level--;
14728 return NULL;
14729 }
14730 int _start_lineno = p->tokens[_mark]->lineno;
14731 UNUSED(_start_lineno); // Only used by EXTRA macro
14732 int _start_col_offset = p->tokens[_mark]->col_offset;
14733 UNUSED(_start_col_offset); // Only used by EXTRA macro
14734 { // NAME
14735 if (p->error_indicator) {
14736 p->level--;
14737 return NULL;
14738 }
14739 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
14740 expr_ty name_var;
14741 if (
14742 (name_var = _PyPegen_name_token(p)) // NAME
14743 )
14744 {
14745 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
14746 _res = name_var;
14747 goto done;
14748 }
14749 p->mark = _mark;
14750 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14751 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
14752 }
14753 { // 'True'
14754 if (p->error_indicator) {
14755 p->level--;
14756 return NULL;
14757 }
14758 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
14759 Token * _keyword;
14760 if (
14761 (_keyword = _PyPegen_expect_token(p, 613)) // token='True'
14762 )
14763 {
14764 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
14765 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14766 if (_token == NULL) {
14767 p->level--;
14768 return NULL;
14769 }
14770 int _end_lineno = _token->end_lineno;
14771 UNUSED(_end_lineno); // Only used by EXTRA macro
14772 int _end_col_offset = _token->end_col_offset;
14773 UNUSED(_end_col_offset); // Only used by EXTRA macro
14774 _res = _PyAST_Constant ( Py_True , NULL , EXTRA );
14775 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14776 p->error_indicator = 1;
14777 p->level--;
14778 return NULL;
14779 }
14780 goto done;
14781 }
14782 p->mark = _mark;
14783 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14784 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
14785 }
14786 { // 'False'
14787 if (p->error_indicator) {
14788 p->level--;
14789 return NULL;
14790 }
14791 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
14792 Token * _keyword;
14793 if (
14794 (_keyword = _PyPegen_expect_token(p, 615)) // token='False'
14795 )
14796 {
14797 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
14798 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14799 if (_token == NULL) {
14800 p->level--;
14801 return NULL;
14802 }
14803 int _end_lineno = _token->end_lineno;
14804 UNUSED(_end_lineno); // Only used by EXTRA macro
14805 int _end_col_offset = _token->end_col_offset;
14806 UNUSED(_end_col_offset); // Only used by EXTRA macro
14807 _res = _PyAST_Constant ( Py_False , NULL , EXTRA );
14808 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14809 p->error_indicator = 1;
14810 p->level--;
14811 return NULL;
14812 }
14813 goto done;
14814 }
14815 p->mark = _mark;
14816 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14817 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));
14818 }
14819 { // 'None'
14820 if (p->error_indicator) {
14821 p->level--;
14822 return NULL;
14823 }
14824 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
14825 Token * _keyword;
14826 if (
14827 (_keyword = _PyPegen_expect_token(p, 614)) // token='None'
14828 )
14829 {
14830 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
14831 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14832 if (_token == NULL) {
14833 p->level--;
14834 return NULL;
14835 }
14836 int _end_lineno = _token->end_lineno;
14837 UNUSED(_end_lineno); // Only used by EXTRA macro
14838 int _end_col_offset = _token->end_col_offset;
14839 UNUSED(_end_col_offset); // Only used by EXTRA macro
14840 _res = _PyAST_Constant ( Py_None , NULL , EXTRA );
14841 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14842 p->error_indicator = 1;
14843 p->level--;
14844 return NULL;
14845 }
14846 goto done;
14847 }
14848 p->mark = _mark;
14849 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14850 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
14851 }
14852 { // &(STRING | FSTRING_START) strings
14853 if (p->error_indicator) {
14854 p->level--;
14855 return NULL;
14856 }
14857 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings"));
14858 expr_ty strings_var;
14859 if (
14860 _PyPegen_lookahead(1, _tmp_93_rule, p)
14861 &&
14862 (strings_var = strings_rule(p)) // strings
14863 )
14864 {
14865 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&(STRING | FSTRING_START) strings"));
14866 _res = strings_var;
14867 goto done;
14868 }
14869 p->mark = _mark;
14870 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14871 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START) strings"));
14872 }
14873 { // NUMBER
14874 if (p->error_indicator) {
14875 p->level--;
14876 return NULL;
14877 }
14878 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
14879 expr_ty number_var;
14880 if (
14881 (number_var = _PyPegen_number_token(p)) // NUMBER
14882 )
14883 {
14884 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
14885 _res = number_var;
14886 goto done;
14887 }
14888 p->mark = _mark;
14889 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14890 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));
14891 }
14892 { // &'(' (tuple | group | genexp)
14893 if (p->error_indicator) {
14894 p->level--;
14895 return NULL;
14896 }
14897 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)"));
14898 void *_tmp_94_var;
14899 if (
14900 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='('
14901 &&
14902 (_tmp_94_var = _tmp_94_rule(p)) // tuple | group | genexp
14903 )
14904 {
14905 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)"));
14906 _res = _tmp_94_var;
14907 goto done;
14908 }
14909 p->mark = _mark;
14910 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14911 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (tuple | group | genexp)"));
14912 }
14913 { // &'[' (list | listcomp)
14914 if (p->error_indicator) {
14915 p->level--;
14916 return NULL;
14917 }
14918 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)"));
14919 void *_tmp_95_var;
14920 if (
14921 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='['
14922 &&
14923 (_tmp_95_var = _tmp_95_rule(p)) // list | listcomp
14924 )
14925 {
14926 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)"));
14927 _res = _tmp_95_var;
14928 goto done;
14929 }
14930 p->mark = _mark;
14931 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14932 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (list | listcomp)"));
14933 }
14934 { // &'{' (dict | set | dictcomp | setcomp)
14935 if (p->error_indicator) {
14936 p->level--;
14937 return NULL;
14938 }
14939 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
14940 void *_tmp_96_var;
14941 if (
14942 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{'
14943 &&
14944 (_tmp_96_var = _tmp_96_rule(p)) // dict | set | dictcomp | setcomp
14945 )
14946 {
14947 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
14948 _res = _tmp_96_var;
14949 goto done;
14950 }
14951 p->mark = _mark;
14952 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14953 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
14954 }
14955 { // '...'
14956 if (p->error_indicator) {
14957 p->level--;
14958 return NULL;
14959 }
14960 D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
14961 Token * _literal;
14962 if (
14963 (_literal = _PyPegen_expect_token(p, 52)) // token='...'
14964 )
14965 {
14966 D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
14967 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
14968 if (_token == NULL) {
14969 p->level--;
14970 return NULL;
14971 }
14972 int _end_lineno = _token->end_lineno;
14973 UNUSED(_end_lineno); // Only used by EXTRA macro
14974 int _end_col_offset = _token->end_col_offset;
14975 UNUSED(_end_col_offset); // Only used by EXTRA macro
14976 _res = _PyAST_Constant ( Py_Ellipsis , NULL , EXTRA );
14977 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
14978 p->error_indicator = 1;
14979 p->level--;
14980 return NULL;
14981 }
14982 goto done;
14983 }
14984 p->mark = _mark;
14985 D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
14986 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
14987 }
14988 _res = NULL;
14989 done:
14990 p->level--;
14991 return _res;
14992 }
14993
14994 // group: '(' (yield_expr | named_expression) ')' | invalid_group
14995 static expr_ty
14996 group_rule(Parser *p)
14997 {
14998 if (p->level++ == MAXSTACK) {
14999 _Pypegen_stack_overflow(p);
15000 }
15001 if (p->error_indicator) {
15002 p->level--;
15003 return NULL;
15004 }
15005 expr_ty _res = NULL;
15006 int _mark = p->mark;
15007 { // '(' (yield_expr | named_expression) ')'
15008 if (p->error_indicator) {
15009 p->level--;
15010 return NULL;
15011 }
15012 D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
15013 Token * _literal;
15014 Token * _literal_1;
15015 void *a;
15016 if (
15017 (_literal = _PyPegen_expect_token(p, 7)) // token='('
15018 &&
15019 (a = _tmp_97_rule(p)) // yield_expr | named_expression
15020 &&
15021 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
15022 )
15023 {
15024 D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
15025 _res = a;
15026 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15027 p->error_indicator = 1;
15028 p->level--;
15029 return NULL;
15030 }
15031 goto done;
15032 }
15033 p->mark = _mark;
15034 D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ',
15035 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
15036 }
15037 if (p->call_invalid_rules) { // invalid_group
15038 if (p->error_indicator) {
15039 p->level--;
15040 return NULL;
15041 }
15042 D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_group"));
15043 void *invalid_group_var;
15044 if (
15045 (invalid_group_var = invalid_group_rule(p)) // invalid_group
15046 )
15047 {
15048 D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_group"));
15049 _res = invalid_group_var;
15050 goto done;
15051 }
15052 p->mark = _mark;
15053 D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ',
15054 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_group"));
15055 }
15056 _res = NULL;
15057 done:
15058 p->level--;
15059 return _res;
15060 }
15061
15062 // lambdef: 'lambda' lambda_params? ':' expression
15063 static expr_ty
15064 lambdef_rule(Parser *p)
15065 {
15066 if (p->level++ == MAXSTACK) {
15067 _Pypegen_stack_overflow(p);
15068 }
15069 if (p->error_indicator) {
15070 p->level--;
15071 return NULL;
15072 }
15073 expr_ty _res = NULL;
15074 int _mark = p->mark;
15075 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
15076 p->error_indicator = 1;
15077 p->level--;
15078 return NULL;
15079 }
15080 int _start_lineno = p->tokens[_mark]->lineno;
15081 UNUSED(_start_lineno); // Only used by EXTRA macro
15082 int _start_col_offset = p->tokens[_mark]->col_offset;
15083 UNUSED(_start_col_offset); // Only used by EXTRA macro
15084 { // 'lambda' lambda_params? ':' expression
15085 if (p->error_indicator) {
15086 p->level--;
15087 return NULL;
15088 }
15089 D(fprintf(stderr, "%*c> lambdef[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression"));
15090 Token * _keyword;
15091 Token * _literal;
15092 void *a;
15093 expr_ty b;
15094 if (
15095 (_keyword = _PyPegen_expect_token(p, 612)) // token='lambda'
15096 &&
15097 (a = lambda_params_rule(p), !p->error_indicator) // lambda_params?
15098 &&
15099 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
15100 &&
15101 (b = expression_rule(p)) // expression
15102 )
15103 {
15104 D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression"));
15105 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15106 if (_token == NULL) {
15107 p->level--;
15108 return NULL;
15109 }
15110 int _end_lineno = _token->end_lineno;
15111 UNUSED(_end_lineno); // Only used by EXTRA macro
15112 int _end_col_offset = _token->end_col_offset;
15113 UNUSED(_end_col_offset); // Only used by EXTRA macro
15114 _res = _PyAST_Lambda ( ( a ) ? a : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , EXTRA );
15115 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15116 p->error_indicator = 1;
15117 p->level--;
15118 return NULL;
15119 }
15120 goto done;
15121 }
15122 p->mark = _mark;
15123 D(fprintf(stderr, "%*c%s lambdef[%d-%d]: %s failed!\n", p->level, ' ',
15124 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' expression"));
15125 }
15126 _res = NULL;
15127 done:
15128 p->level--;
15129 return _res;
15130 }
15131
15132 // lambda_params: invalid_lambda_parameters | lambda_parameters
15133 static arguments_ty
15134 lambda_params_rule(Parser *p)
15135 {
15136 if (p->level++ == MAXSTACK) {
15137 _Pypegen_stack_overflow(p);
15138 }
15139 if (p->error_indicator) {
15140 p->level--;
15141 return NULL;
15142 }
15143 arguments_ty _res = NULL;
15144 int _mark = p->mark;
15145 if (p->call_invalid_rules) { // invalid_lambda_parameters
15146 if (p->error_indicator) {
15147 p->level--;
15148 return NULL;
15149 }
15150 D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters"));
15151 void *invalid_lambda_parameters_var;
15152 if (
15153 (invalid_lambda_parameters_var = invalid_lambda_parameters_rule(p)) // invalid_lambda_parameters
15154 )
15155 {
15156 D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters"));
15157 _res = invalid_lambda_parameters_var;
15158 goto done;
15159 }
15160 p->mark = _mark;
15161 D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ',
15162 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_parameters"));
15163 }
15164 { // lambda_parameters
15165 if (p->error_indicator) {
15166 p->level--;
15167 return NULL;
15168 }
15169 D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_parameters"));
15170 arguments_ty lambda_parameters_var;
15171 if (
15172 (lambda_parameters_var = lambda_parameters_rule(p)) // lambda_parameters
15173 )
15174 {
15175 D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_parameters"));
15176 _res = lambda_parameters_var;
15177 goto done;
15178 }
15179 p->mark = _mark;
15180 D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ',
15181 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_parameters"));
15182 }
15183 _res = NULL;
15184 done:
15185 p->level--;
15186 return _res;
15187 }
15188
15189 // lambda_parameters:
15190 // | lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
15191 // | lambda_slash_with_default lambda_param_with_default* lambda_star_etc?
15192 // | lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?
15193 // | lambda_param_with_default+ lambda_star_etc?
15194 // | lambda_star_etc
15195 static arguments_ty
15196 lambda_parameters_rule(Parser *p)
15197 {
15198 if (p->level++ == MAXSTACK) {
15199 _Pypegen_stack_overflow(p);
15200 }
15201 if (p->error_indicator) {
15202 p->level--;
15203 return NULL;
15204 }
15205 arguments_ty _res = NULL;
15206 int _mark = p->mark;
15207 { // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
15208 if (p->error_indicator) {
15209 p->level--;
15210 return NULL;
15211 }
15212 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?"));
15213 asdl_arg_seq* a;
15214 asdl_arg_seq* b;
15215 asdl_seq * c;
15216 void *d;
15217 if (
15218 (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default
15219 &&
15220 (b = (asdl_arg_seq*)_loop0_98_rule(p)) // lambda_param_no_default*
15221 &&
15222 (c = _loop0_99_rule(p)) // lambda_param_with_default*
15223 &&
15224 (d = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc?
15225 )
15226 {
15227 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?"));
15228 _res = CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , a , NULL , b , c , d ) );
15229 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15230 p->error_indicator = 1;
15231 p->level--;
15232 return NULL;
15233 }
15234 goto done;
15235 }
15236 p->mark = _mark;
15237 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
15238 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?"));
15239 }
15240 { // lambda_slash_with_default lambda_param_with_default* lambda_star_etc?
15241 if (p->error_indicator) {
15242 p->level--;
15243 return NULL;
15244 }
15245 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?"));
15246 SlashWithDefault* a;
15247 asdl_seq * b;
15248 void *c;
15249 if (
15250 (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default
15251 &&
15252 (b = _loop0_100_rule(p)) // lambda_param_with_default*
15253 &&
15254 (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc?
15255 )
15256 {
15257 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?"));
15258 _res = CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ) );
15259 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15260 p->error_indicator = 1;
15261 p->level--;
15262 return NULL;
15263 }
15264 goto done;
15265 }
15266 p->mark = _mark;
15267 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
15268 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?"));
15269 }
15270 { // lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?
15271 if (p->error_indicator) {
15272 p->level--;
15273 return NULL;
15274 }
15275 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?"));
15276 asdl_arg_seq* a;
15277 asdl_seq * b;
15278 void *c;
15279 if (
15280 (a = (asdl_arg_seq*)_loop1_101_rule(p)) // lambda_param_no_default+
15281 &&
15282 (b = _loop0_102_rule(p)) // lambda_param_with_default*
15283 &&
15284 (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc?
15285 )
15286 {
15287 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?"));
15288 _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
15289 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15290 p->error_indicator = 1;
15291 p->level--;
15292 return NULL;
15293 }
15294 goto done;
15295 }
15296 p->mark = _mark;
15297 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
15298 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?"));
15299 }
15300 { // lambda_param_with_default+ lambda_star_etc?
15301 if (p->error_indicator) {
15302 p->level--;
15303 return NULL;
15304 }
15305 D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"));
15306 asdl_seq * a;
15307 void *b;
15308 if (
15309 (a = _loop1_103_rule(p)) // lambda_param_with_default+
15310 &&
15311 (b = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc?
15312 )
15313 {
15314 D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"));
15315 _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
15316 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15317 p->error_indicator = 1;
15318 p->level--;
15319 return NULL;
15320 }
15321 goto done;
15322 }
15323 p->mark = _mark;
15324 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
15325 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"));
15326 }
15327 { // lambda_star_etc
15328 if (p->error_indicator) {
15329 p->level--;
15330 return NULL;
15331 }
15332 D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_star_etc"));
15333 StarEtc* a;
15334 if (
15335 (a = lambda_star_etc_rule(p)) // lambda_star_etc
15336 )
15337 {
15338 D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_star_etc"));
15339 _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
15340 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15341 p->error_indicator = 1;
15342 p->level--;
15343 return NULL;
15344 }
15345 goto done;
15346 }
15347 p->mark = _mark;
15348 D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
15349 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_star_etc"));
15350 }
15351 _res = NULL;
15352 done:
15353 p->level--;
15354 return _res;
15355 }
15356
15357 // lambda_slash_no_default:
15358 // | lambda_param_no_default+ '/' ','
15359 // | lambda_param_no_default+ '/' &':'
15360 static asdl_arg_seq*
15361 lambda_slash_no_default_rule(Parser *p)
15362 {
15363 if (p->level++ == MAXSTACK) {
15364 _Pypegen_stack_overflow(p);
15365 }
15366 if (p->error_indicator) {
15367 p->level--;
15368 return NULL;
15369 }
15370 asdl_arg_seq* _res = NULL;
15371 int _mark = p->mark;
15372 { // lambda_param_no_default+ '/' ','
15373 if (p->error_indicator) {
15374 p->level--;
15375 return NULL;
15376 }
15377 D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','"));
15378 Token * _literal;
15379 Token * _literal_1;
15380 asdl_arg_seq* a;
15381 if (
15382 (a = (asdl_arg_seq*)_loop1_104_rule(p)) // lambda_param_no_default+
15383 &&
15384 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
15385 &&
15386 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
15387 )
15388 {
15389 D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','"));
15390 _res = a;
15391 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15392 p->error_indicator = 1;
15393 p->level--;
15394 return NULL;
15395 }
15396 goto done;
15397 }
15398 p->mark = _mark;
15399 D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',
15400 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' ','"));
15401 }
15402 { // lambda_param_no_default+ '/' &':'
15403 if (p->error_indicator) {
15404 p->level--;
15405 return NULL;
15406 }
15407 D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'"));
15408 Token * _literal;
15409 asdl_arg_seq* a;
15410 if (
15411 (a = (asdl_arg_seq*)_loop1_105_rule(p)) // lambda_param_no_default+
15412 &&
15413 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
15414 &&
15415 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':'
15416 )
15417 {
15418 D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'"));
15419 _res = a;
15420 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15421 p->error_indicator = 1;
15422 p->level--;
15423 return NULL;
15424 }
15425 goto done;
15426 }
15427 p->mark = _mark;
15428 D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',
15429 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' &':'"));
15430 }
15431 _res = NULL;
15432 done:
15433 p->level--;
15434 return _res;
15435 }
15436
15437 // lambda_slash_with_default:
15438 // | lambda_param_no_default* lambda_param_with_default+ '/' ','
15439 // | lambda_param_no_default* lambda_param_with_default+ '/' &':'
15440 static SlashWithDefault*
15441 lambda_slash_with_default_rule(Parser *p)
15442 {
15443 if (p->level++ == MAXSTACK) {
15444 _Pypegen_stack_overflow(p);
15445 }
15446 if (p->error_indicator) {
15447 p->level--;
15448 return NULL;
15449 }
15450 SlashWithDefault* _res = NULL;
15451 int _mark = p->mark;
15452 { // lambda_param_no_default* lambda_param_with_default+ '/' ','
15453 if (p->error_indicator) {
15454 p->level--;
15455 return NULL;
15456 }
15457 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+ '/' ','"));
15458 Token * _literal;
15459 Token * _literal_1;
15460 asdl_seq * a;
15461 asdl_seq * b;
15462 if (
15463 (a = _loop0_106_rule(p)) // lambda_param_no_default*
15464 &&
15465 (b = _loop1_107_rule(p)) // lambda_param_with_default+
15466 &&
15467 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
15468 &&
15469 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
15470 )
15471 {
15472 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+ '/' ','"));
15473 _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
15474 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15475 p->error_indicator = 1;
15476 p->level--;
15477 return NULL;
15478 }
15479 goto done;
15480 }
15481 p->mark = _mark;
15482 D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',
15483 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','"));
15484 }
15485 { // lambda_param_no_default* lambda_param_with_default+ '/' &':'
15486 if (p->error_indicator) {
15487 p->level--;
15488 return NULL;
15489 }
15490 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+ '/' &':'"));
15491 Token * _literal;
15492 asdl_seq * a;
15493 asdl_seq * b;
15494 if (
15495 (a = _loop0_108_rule(p)) // lambda_param_no_default*
15496 &&
15497 (b = _loop1_109_rule(p)) // lambda_param_with_default+
15498 &&
15499 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
15500 &&
15501 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':'
15502 )
15503 {
15504 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+ '/' &':'"));
15505 _res = _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b );
15506 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15507 p->error_indicator = 1;
15508 p->level--;
15509 return NULL;
15510 }
15511 goto done;
15512 }
15513 p->mark = _mark;
15514 D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',
15515 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'"));
15516 }
15517 _res = NULL;
15518 done:
15519 p->level--;
15520 return _res;
15521 }
15522
15523 // lambda_star_etc:
15524 // | invalid_lambda_star_etc
15525 // | '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?
15526 // | '*' ',' lambda_param_maybe_default+ lambda_kwds?
15527 // | lambda_kwds
15528 static StarEtc*
15529 lambda_star_etc_rule(Parser *p)
15530 {
15531 if (p->level++ == MAXSTACK) {
15532 _Pypegen_stack_overflow(p);
15533 }
15534 if (p->error_indicator) {
15535 p->level--;
15536 return NULL;
15537 }
15538 StarEtc* _res = NULL;
15539 int _mark = p->mark;
15540 if (p->call_invalid_rules) { // invalid_lambda_star_etc
15541 if (p->error_indicator) {
15542 p->level--;
15543 return NULL;
15544 }
15545 D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc"));
15546 void *invalid_lambda_star_etc_var;
15547 if (
15548 (invalid_lambda_star_etc_var = invalid_lambda_star_etc_rule(p)) // invalid_lambda_star_etc
15549 )
15550 {
15551 D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc"));
15552 _res = invalid_lambda_star_etc_var;
15553 goto done;
15554 }
15555 p->mark = _mark;
15556 D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
15557 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_star_etc"));
15558 }
15559 { // '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?
15560 if (p->error_indicator) {
15561 p->level--;
15562 return NULL;
15563 }
15564 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?"));
15565 Token * _literal;
15566 arg_ty a;
15567 asdl_seq * b;
15568 void *c;
15569 if (
15570 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
15571 &&
15572 (a = lambda_param_no_default_rule(p)) // lambda_param_no_default
15573 &&
15574 (b = _loop0_110_rule(p)) // lambda_param_maybe_default*
15575 &&
15576 (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds?
15577 )
15578 {
15579 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?"));
15580 _res = _PyPegen_star_etc ( p , a , b , c );
15581 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15582 p->error_indicator = 1;
15583 p->level--;
15584 return NULL;
15585 }
15586 goto done;
15587 }
15588 p->mark = _mark;
15589 D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
15590 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?"));
15591 }
15592 { // '*' ',' lambda_param_maybe_default+ lambda_kwds?
15593 if (p->error_indicator) {
15594 p->level--;
15595 return NULL;
15596 }
15597 D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?"));
15598 Token * _literal;
15599 Token * _literal_1;
15600 asdl_seq * b;
15601 void *c;
15602 if (
15603 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
15604 &&
15605 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
15606 &&
15607 (b = _loop1_111_rule(p)) // lambda_param_maybe_default+
15608 &&
15609 (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds?
15610 )
15611 {
15612 D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?"));
15613 _res = _PyPegen_star_etc ( p , NULL , b , c );
15614 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15615 p->error_indicator = 1;
15616 p->level--;
15617 return NULL;
15618 }
15619 goto done;
15620 }
15621 p->mark = _mark;
15622 D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
15623 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?"));
15624 }
15625 { // lambda_kwds
15626 if (p->error_indicator) {
15627 p->level--;
15628 return NULL;
15629 }
15630 D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_kwds"));
15631 arg_ty a;
15632 if (
15633 (a = lambda_kwds_rule(p)) // lambda_kwds
15634 )
15635 {
15636 D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_kwds"));
15637 _res = _PyPegen_star_etc ( p , NULL , NULL , a );
15638 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15639 p->error_indicator = 1;
15640 p->level--;
15641 return NULL;
15642 }
15643 goto done;
15644 }
15645 p->mark = _mark;
15646 D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
15647 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_kwds"));
15648 }
15649 _res = NULL;
15650 done:
15651 p->level--;
15652 return _res;
15653 }
15654
15655 // lambda_kwds: invalid_lambda_kwds | '**' lambda_param_no_default
15656 static arg_ty
15657 lambda_kwds_rule(Parser *p)
15658 {
15659 if (p->level++ == MAXSTACK) {
15660 _Pypegen_stack_overflow(p);
15661 }
15662 if (p->error_indicator) {
15663 p->level--;
15664 return NULL;
15665 }
15666 arg_ty _res = NULL;
15667 int _mark = p->mark;
15668 if (p->call_invalid_rules) { // invalid_lambda_kwds
15669 if (p->error_indicator) {
15670 p->level--;
15671 return NULL;
15672 }
15673 D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_kwds"));
15674 void *invalid_lambda_kwds_var;
15675 if (
15676 (invalid_lambda_kwds_var = invalid_lambda_kwds_rule(p)) // invalid_lambda_kwds
15677 )
15678 {
15679 D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_kwds"));
15680 _res = invalid_lambda_kwds_var;
15681 goto done;
15682 }
15683 p->mark = _mark;
15684 D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ',
15685 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_kwds"));
15686 }
15687 { // '**' lambda_param_no_default
15688 if (p->error_indicator) {
15689 p->level--;
15690 return NULL;
15691 }
15692 D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default"));
15693 Token * _literal;
15694 arg_ty a;
15695 if (
15696 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
15697 &&
15698 (a = lambda_param_no_default_rule(p)) // lambda_param_no_default
15699 )
15700 {
15701 D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default"));
15702 _res = a;
15703 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15704 p->error_indicator = 1;
15705 p->level--;
15706 return NULL;
15707 }
15708 goto done;
15709 }
15710 p->mark = _mark;
15711 D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ',
15712 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param_no_default"));
15713 }
15714 _res = NULL;
15715 done:
15716 p->level--;
15717 return _res;
15718 }
15719
15720 // lambda_param_no_default: lambda_param ',' | lambda_param &':'
15721 static arg_ty
15722 lambda_param_no_default_rule(Parser *p)
15723 {
15724 if (p->level++ == MAXSTACK) {
15725 _Pypegen_stack_overflow(p);
15726 }
15727 if (p->error_indicator) {
15728 p->level--;
15729 return NULL;
15730 }
15731 arg_ty _res = NULL;
15732 int _mark = p->mark;
15733 { // lambda_param ','
15734 if (p->error_indicator) {
15735 p->level--;
15736 return NULL;
15737 }
15738 D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param ','"));
15739 Token * _literal;
15740 arg_ty a;
15741 if (
15742 (a = lambda_param_rule(p)) // lambda_param
15743 &&
15744 (_literal = _PyPegen_expect_token(p, 12)) // token=','
15745 )
15746 {
15747 D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param ','"));
15748 _res = a;
15749 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15750 p->error_indicator = 1;
15751 p->level--;
15752 return NULL;
15753 }
15754 goto done;
15755 }
15756 p->mark = _mark;
15757 D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ',
15758 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param ','"));
15759 }
15760 { // lambda_param &':'
15761 if (p->error_indicator) {
15762 p->level--;
15763 return NULL;
15764 }
15765 D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param &':'"));
15766 arg_ty a;
15767 if (
15768 (a = lambda_param_rule(p)) // lambda_param
15769 &&
15770 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':'
15771 )
15772 {
15773 D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param &':'"));
15774 _res = a;
15775 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15776 p->error_indicator = 1;
15777 p->level--;
15778 return NULL;
15779 }
15780 goto done;
15781 }
15782 p->mark = _mark;
15783 D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ',
15784 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param &':'"));
15785 }
15786 _res = NULL;
15787 done:
15788 p->level--;
15789 return _res;
15790 }
15791
15792 // lambda_param_with_default: lambda_param default ',' | lambda_param default &':'
15793 static NameDefaultPair*
15794 lambda_param_with_default_rule(Parser *p)
15795 {
15796 if (p->level++ == MAXSTACK) {
15797 _Pypegen_stack_overflow(p);
15798 }
15799 if (p->error_indicator) {
15800 p->level--;
15801 return NULL;
15802 }
15803 NameDefaultPair* _res = NULL;
15804 int _mark = p->mark;
15805 { // lambda_param default ','
15806 if (p->error_indicator) {
15807 p->level--;
15808 return NULL;
15809 }
15810 D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default ','"));
15811 Token * _literal;
15812 arg_ty a;
15813 expr_ty c;
15814 if (
15815 (a = lambda_param_rule(p)) // lambda_param
15816 &&
15817 (c = default_rule(p)) // default
15818 &&
15819 (_literal = _PyPegen_expect_token(p, 12)) // token=','
15820 )
15821 {
15822 D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default ','"));
15823 _res = _PyPegen_name_default_pair ( p , a , c , NULL );
15824 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15825 p->error_indicator = 1;
15826 p->level--;
15827 return NULL;
15828 }
15829 goto done;
15830 }
15831 p->mark = _mark;
15832 D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ',
15833 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default ','"));
15834 }
15835 { // lambda_param default &':'
15836 if (p->error_indicator) {
15837 p->level--;
15838 return NULL;
15839 }
15840 D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'"));
15841 arg_ty a;
15842 expr_ty c;
15843 if (
15844 (a = lambda_param_rule(p)) // lambda_param
15845 &&
15846 (c = default_rule(p)) // default
15847 &&
15848 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':'
15849 )
15850 {
15851 D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'"));
15852 _res = _PyPegen_name_default_pair ( p , a , c , NULL );
15853 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15854 p->error_indicator = 1;
15855 p->level--;
15856 return NULL;
15857 }
15858 goto done;
15859 }
15860 p->mark = _mark;
15861 D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ',
15862 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default &':'"));
15863 }
15864 _res = NULL;
15865 done:
15866 p->level--;
15867 return _res;
15868 }
15869
15870 // lambda_param_maybe_default: lambda_param default? ',' | lambda_param default? &':'
15871 static NameDefaultPair*
15872 lambda_param_maybe_default_rule(Parser *p)
15873 {
15874 if (p->level++ == MAXSTACK) {
15875 _Pypegen_stack_overflow(p);
15876 }
15877 if (p->error_indicator) {
15878 p->level--;
15879 return NULL;
15880 }
15881 NameDefaultPair* _res = NULL;
15882 int _mark = p->mark;
15883 { // lambda_param default? ','
15884 if (p->error_indicator) {
15885 p->level--;
15886 return NULL;
15887 }
15888 D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','"));
15889 Token * _literal;
15890 arg_ty a;
15891 void *c;
15892 if (
15893 (a = lambda_param_rule(p)) // lambda_param
15894 &&
15895 (c = default_rule(p), !p->error_indicator) // default?
15896 &&
15897 (_literal = _PyPegen_expect_token(p, 12)) // token=','
15898 )
15899 {
15900 D(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','"));
15901 _res = _PyPegen_name_default_pair ( p , a , c , NULL );
15902 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15903 p->error_indicator = 1;
15904 p->level--;
15905 return NULL;
15906 }
15907 goto done;
15908 }
15909 p->mark = _mark;
15910 D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',
15911 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? ','"));
15912 }
15913 { // lambda_param default? &':'
15914 if (p->error_indicator) {
15915 p->level--;
15916 return NULL;
15917 }
15918 D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'"));
15919 arg_ty a;
15920 void *c;
15921 if (
15922 (a = lambda_param_rule(p)) // lambda_param
15923 &&
15924 (c = default_rule(p), !p->error_indicator) // default?
15925 &&
15926 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11) // token=':'
15927 )
15928 {
15929 D(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'"));
15930 _res = _PyPegen_name_default_pair ( p , a , c , NULL );
15931 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15932 p->error_indicator = 1;
15933 p->level--;
15934 return NULL;
15935 }
15936 goto done;
15937 }
15938 p->mark = _mark;
15939 D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',
15940 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? &':'"));
15941 }
15942 _res = NULL;
15943 done:
15944 p->level--;
15945 return _res;
15946 }
15947
15948 // lambda_param: NAME
15949 static arg_ty
15950 lambda_param_rule(Parser *p)
15951 {
15952 if (p->level++ == MAXSTACK) {
15953 _Pypegen_stack_overflow(p);
15954 }
15955 if (p->error_indicator) {
15956 p->level--;
15957 return NULL;
15958 }
15959 arg_ty _res = NULL;
15960 int _mark = p->mark;
15961 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
15962 p->error_indicator = 1;
15963 p->level--;
15964 return NULL;
15965 }
15966 int _start_lineno = p->tokens[_mark]->lineno;
15967 UNUSED(_start_lineno); // Only used by EXTRA macro
15968 int _start_col_offset = p->tokens[_mark]->col_offset;
15969 UNUSED(_start_col_offset); // Only used by EXTRA macro
15970 { // NAME
15971 if (p->error_indicator) {
15972 p->level--;
15973 return NULL;
15974 }
15975 D(fprintf(stderr, "%*c> lambda_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
15976 expr_ty a;
15977 if (
15978 (a = _PyPegen_name_token(p)) // NAME
15979 )
15980 {
15981 D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
15982 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
15983 if (_token == NULL) {
15984 p->level--;
15985 return NULL;
15986 }
15987 int _end_lineno = _token->end_lineno;
15988 UNUSED(_end_lineno); // Only used by EXTRA macro
15989 int _end_col_offset = _token->end_col_offset;
15990 UNUSED(_end_col_offset); // Only used by EXTRA macro
15991 _res = _PyAST_arg ( a -> v . Name . id , NULL , NULL , EXTRA );
15992 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
15993 p->error_indicator = 1;
15994 p->level--;
15995 return NULL;
15996 }
15997 goto done;
15998 }
15999 p->mark = _mark;
16000 D(fprintf(stderr, "%*c%s lambda_param[%d-%d]: %s failed!\n", p->level, ' ',
16001 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
16002 }
16003 _res = NULL;
16004 done:
16005 p->level--;
16006 return _res;
16007 }
16008
16009 // fstring_middle: fstring_replacement_field | FSTRING_MIDDLE
16010 static expr_ty
16011 fstring_middle_rule(Parser *p)
16012 {
16013 if (p->level++ == MAXSTACK) {
16014 _Pypegen_stack_overflow(p);
16015 }
16016 if (p->error_indicator) {
16017 p->level--;
16018 return NULL;
16019 }
16020 expr_ty _res = NULL;
16021 int _mark = p->mark;
16022 { // fstring_replacement_field
16023 if (p->error_indicator) {
16024 p->level--;
16025 return NULL;
16026 }
16027 D(fprintf(stderr, "%*c> fstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_replacement_field"));
16028 expr_ty fstring_replacement_field_var;
16029 if (
16030 (fstring_replacement_field_var = fstring_replacement_field_rule(p)) // fstring_replacement_field
16031 )
16032 {
16033 D(fprintf(stderr, "%*c+ fstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring_replacement_field"));
16034 _res = fstring_replacement_field_var;
16035 goto done;
16036 }
16037 p->mark = _mark;
16038 D(fprintf(stderr, "%*c%s fstring_middle[%d-%d]: %s failed!\n", p->level, ' ',
16039 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_replacement_field"));
16040 }
16041 { // FSTRING_MIDDLE
16042 if (p->error_indicator) {
16043 p->level--;
16044 return NULL;
16045 }
16046 D(fprintf(stderr, "%*c> fstring_middle[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE"));
16047 Token * t;
16048 if (
16049 (t = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE'
16050 )
16051 {
16052 D(fprintf(stderr, "%*c+ fstring_middle[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE"));
16053 _res = _PyPegen_constant_from_token ( p , t );
16054 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16055 p->error_indicator = 1;
16056 p->level--;
16057 return NULL;
16058 }
16059 goto done;
16060 }
16061 p->mark = _mark;
16062 D(fprintf(stderr, "%*c%s fstring_middle[%d-%d]: %s failed!\n", p->level, ' ',
16063 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE"));
16064 }
16065 _res = NULL;
16066 done:
16067 p->level--;
16068 return _res;
16069 }
16070
16071 // fstring_replacement_field:
16072 // | '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'
16073 // | invalid_replacement_field
16074 static expr_ty
16075 fstring_replacement_field_rule(Parser *p)
16076 {
16077 if (p->level++ == MAXSTACK) {
16078 _Pypegen_stack_overflow(p);
16079 }
16080 if (p->error_indicator) {
16081 p->level--;
16082 return NULL;
16083 }
16084 expr_ty _res = NULL;
16085 int _mark = p->mark;
16086 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16087 p->error_indicator = 1;
16088 p->level--;
16089 return NULL;
16090 }
16091 int _start_lineno = p->tokens[_mark]->lineno;
16092 UNUSED(_start_lineno); // Only used by EXTRA macro
16093 int _start_col_offset = p->tokens[_mark]->col_offset;
16094 UNUSED(_start_col_offset); // Only used by EXTRA macro
16095 { // '{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'
16096 if (p->error_indicator) {
16097 p->level--;
16098 return NULL;
16099 }
16100 D(fprintf(stderr, "%*c> fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'"));
16101 Token * _literal;
16102 expr_ty a;
16103 void *conversion;
16104 void *debug_expr;
16105 void *format;
16106 Token * rbrace;
16107 if (
16108 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
16109 &&
16110 (a = annotated_rhs_rule(p)) // annotated_rhs
16111 &&
16112 (debug_expr = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='?
16113 &&
16114 (conversion = fstring_conversion_rule(p), !p->error_indicator) // fstring_conversion?
16115 &&
16116 (format = fstring_full_format_spec_rule(p), !p->error_indicator) // fstring_full_format_spec?
16117 &&
16118 (rbrace = _PyPegen_expect_token(p, 26)) // token='}'
16119 )
16120 {
16121 D(fprintf(stderr, "%*c+ fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'"));
16122 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16123 if (_token == NULL) {
16124 p->level--;
16125 return NULL;
16126 }
16127 int _end_lineno = _token->end_lineno;
16128 UNUSED(_end_lineno); // Only used by EXTRA macro
16129 int _end_col_offset = _token->end_col_offset;
16130 UNUSED(_end_col_offset); // Only used by EXTRA macro
16131 _res = _PyPegen_formatted_value ( p , a , debug_expr , conversion , format , rbrace , EXTRA );
16132 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16133 p->error_indicator = 1;
16134 p->level--;
16135 return NULL;
16136 }
16137 goto done;
16138 }
16139 p->mark = _mark;
16140 D(fprintf(stderr, "%*c%s fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
16141 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? fstring_conversion? fstring_full_format_spec? '}'"));
16142 }
16143 if (p->call_invalid_rules) { // invalid_replacement_field
16144 if (p->error_indicator) {
16145 p->level--;
16146 return NULL;
16147 }
16148 D(fprintf(stderr, "%*c> fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field"));
16149 void *invalid_replacement_field_var;
16150 if (
16151 (invalid_replacement_field_var = invalid_replacement_field_rule(p)) // invalid_replacement_field
16152 )
16153 {
16154 D(fprintf(stderr, "%*c+ fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_replacement_field"));
16155 _res = invalid_replacement_field_var;
16156 goto done;
16157 }
16158 p->mark = _mark;
16159 D(fprintf(stderr, "%*c%s fstring_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
16160 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_replacement_field"));
16161 }
16162 _res = NULL;
16163 done:
16164 p->level--;
16165 return _res;
16166 }
16167
16168 // fstring_conversion: "!" NAME
16169 static ResultTokenWithMetadata*
16170 fstring_conversion_rule(Parser *p)
16171 {
16172 if (p->level++ == MAXSTACK) {
16173 _Pypegen_stack_overflow(p);
16174 }
16175 if (p->error_indicator) {
16176 p->level--;
16177 return NULL;
16178 }
16179 ResultTokenWithMetadata* _res = NULL;
16180 int _mark = p->mark;
16181 { // "!" NAME
16182 if (p->error_indicator) {
16183 p->level--;
16184 return NULL;
16185 }
16186 D(fprintf(stderr, "%*c> fstring_conversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"!\" NAME"));
16187 expr_ty conv;
16188 Token * conv_token;
16189 if (
16190 (conv_token = _PyPegen_expect_token(p, 54)) // token='!'
16191 &&
16192 (conv = _PyPegen_name_token(p)) // NAME
16193 )
16194 {
16195 D(fprintf(stderr, "%*c+ fstring_conversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"!\" NAME"));
16196 _res = _PyPegen_check_fstring_conversion ( p , conv_token , conv );
16197 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16198 p->error_indicator = 1;
16199 p->level--;
16200 return NULL;
16201 }
16202 goto done;
16203 }
16204 p->mark = _mark;
16205 D(fprintf(stderr, "%*c%s fstring_conversion[%d-%d]: %s failed!\n", p->level, ' ',
16206 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"!\" NAME"));
16207 }
16208 _res = NULL;
16209 done:
16210 p->level--;
16211 return _res;
16212 }
16213
16214 // fstring_full_format_spec: ':' fstring_format_spec*
16215 static ResultTokenWithMetadata*
16216 fstring_full_format_spec_rule(Parser *p)
16217 {
16218 if (p->level++ == MAXSTACK) {
16219 _Pypegen_stack_overflow(p);
16220 }
16221 if (p->error_indicator) {
16222 p->level--;
16223 return NULL;
16224 }
16225 ResultTokenWithMetadata* _res = NULL;
16226 int _mark = p->mark;
16227 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16228 p->error_indicator = 1;
16229 p->level--;
16230 return NULL;
16231 }
16232 int _start_lineno = p->tokens[_mark]->lineno;
16233 UNUSED(_start_lineno); // Only used by EXTRA macro
16234 int _start_col_offset = p->tokens[_mark]->col_offset;
16235 UNUSED(_start_col_offset); // Only used by EXTRA macro
16236 { // ':' fstring_format_spec*
16237 if (p->error_indicator) {
16238 p->level--;
16239 return NULL;
16240 }
16241 D(fprintf(stderr, "%*c> fstring_full_format_spec[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' fstring_format_spec*"));
16242 Token * colon;
16243 asdl_seq * spec;
16244 if (
16245 (colon = _PyPegen_expect_token(p, 11)) // token=':'
16246 &&
16247 (spec = _loop0_112_rule(p)) // fstring_format_spec*
16248 )
16249 {
16250 D(fprintf(stderr, "%*c+ fstring_full_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' fstring_format_spec*"));
16251 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16252 if (_token == NULL) {
16253 p->level--;
16254 return NULL;
16255 }
16256 int _end_lineno = _token->end_lineno;
16257 UNUSED(_end_lineno); // Only used by EXTRA macro
16258 int _end_col_offset = _token->end_col_offset;
16259 UNUSED(_end_col_offset); // Only used by EXTRA macro
16260 _res = _PyPegen_setup_full_format_spec ( p , colon , ( asdl_expr_seq* ) spec , EXTRA );
16261 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16262 p->error_indicator = 1;
16263 p->level--;
16264 return NULL;
16265 }
16266 goto done;
16267 }
16268 p->mark = _mark;
16269 D(fprintf(stderr, "%*c%s fstring_full_format_spec[%d-%d]: %s failed!\n", p->level, ' ',
16270 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' fstring_format_spec*"));
16271 }
16272 _res = NULL;
16273 done:
16274 p->level--;
16275 return _res;
16276 }
16277
16278 // fstring_format_spec: FSTRING_MIDDLE | fstring_replacement_field
16279 static expr_ty
16280 fstring_format_spec_rule(Parser *p)
16281 {
16282 if (p->level++ == MAXSTACK) {
16283 _Pypegen_stack_overflow(p);
16284 }
16285 if (p->error_indicator) {
16286 p->level--;
16287 return NULL;
16288 }
16289 expr_ty _res = NULL;
16290 int _mark = p->mark;
16291 { // FSTRING_MIDDLE
16292 if (p->error_indicator) {
16293 p->level--;
16294 return NULL;
16295 }
16296 D(fprintf(stderr, "%*c> fstring_format_spec[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE"));
16297 Token * t;
16298 if (
16299 (t = _PyPegen_expect_token(p, FSTRING_MIDDLE)) // token='FSTRING_MIDDLE'
16300 )
16301 {
16302 D(fprintf(stderr, "%*c+ fstring_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_MIDDLE"));
16303 _res = _PyPegen_decoded_constant_from_token ( p , t );
16304 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16305 p->error_indicator = 1;
16306 p->level--;
16307 return NULL;
16308 }
16309 goto done;
16310 }
16311 p->mark = _mark;
16312 D(fprintf(stderr, "%*c%s fstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ',
16313 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE"));
16314 }
16315 { // fstring_replacement_field
16316 if (p->error_indicator) {
16317 p->level--;
16318 return NULL;
16319 }
16320 D(fprintf(stderr, "%*c> fstring_format_spec[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_replacement_field"));
16321 expr_ty fstring_replacement_field_var;
16322 if (
16323 (fstring_replacement_field_var = fstring_replacement_field_rule(p)) // fstring_replacement_field
16324 )
16325 {
16326 D(fprintf(stderr, "%*c+ fstring_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring_replacement_field"));
16327 _res = fstring_replacement_field_var;
16328 goto done;
16329 }
16330 p->mark = _mark;
16331 D(fprintf(stderr, "%*c%s fstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ',
16332 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_replacement_field"));
16333 }
16334 _res = NULL;
16335 done:
16336 p->level--;
16337 return _res;
16338 }
16339
16340 // fstring: FSTRING_START fstring_middle* FSTRING_END
16341 static expr_ty
16342 fstring_rule(Parser *p)
16343 {
16344 if (p->level++ == MAXSTACK) {
16345 _Pypegen_stack_overflow(p);
16346 }
16347 if (p->error_indicator) {
16348 p->level--;
16349 return NULL;
16350 }
16351 expr_ty _res = NULL;
16352 int _mark = p->mark;
16353 { // FSTRING_START fstring_middle* FSTRING_END
16354 if (p->error_indicator) {
16355 p->level--;
16356 return NULL;
16357 }
16358 D(fprintf(stderr, "%*c> fstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_START fstring_middle* FSTRING_END"));
16359 Token * a;
16360 asdl_seq * b;
16361 Token * c;
16362 if (
16363 (a = _PyPegen_expect_token(p, FSTRING_START)) // token='FSTRING_START'
16364 &&
16365 (b = _loop0_113_rule(p)) // fstring_middle*
16366 &&
16367 (c = _PyPegen_expect_token(p, FSTRING_END)) // token='FSTRING_END'
16368 )
16369 {
16370 D(fprintf(stderr, "%*c+ fstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_START fstring_middle* FSTRING_END"));
16371 _res = _PyPegen_joined_str ( p , a , ( asdl_expr_seq* ) b , c );
16372 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16373 p->error_indicator = 1;
16374 p->level--;
16375 return NULL;
16376 }
16377 goto done;
16378 }
16379 p->mark = _mark;
16380 D(fprintf(stderr, "%*c%s fstring[%d-%d]: %s failed!\n", p->level, ' ',
16381 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_START fstring_middle* FSTRING_END"));
16382 }
16383 _res = NULL;
16384 done:
16385 p->level--;
16386 return _res;
16387 }
16388
16389 // string: STRING
16390 static expr_ty
16391 string_rule(Parser *p)
16392 {
16393 if (p->level++ == MAXSTACK) {
16394 _Pypegen_stack_overflow(p);
16395 }
16396 if (p->error_indicator) {
16397 p->level--;
16398 return NULL;
16399 }
16400 expr_ty _res = NULL;
16401 int _mark = p->mark;
16402 { // STRING
16403 if (p->error_indicator) {
16404 p->level--;
16405 return NULL;
16406 }
16407 D(fprintf(stderr, "%*c> string[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING"));
16408 Token* s;
16409 if (
16410 (s = (Token*)_PyPegen_string_token(p)) // STRING
16411 )
16412 {
16413 D(fprintf(stderr, "%*c+ string[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING"));
16414 _res = _PyPegen_constant_from_string ( p , s );
16415 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16416 p->error_indicator = 1;
16417 p->level--;
16418 return NULL;
16419 }
16420 goto done;
16421 }
16422 p->mark = _mark;
16423 D(fprintf(stderr, "%*c%s string[%d-%d]: %s failed!\n", p->level, ' ',
16424 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING"));
16425 }
16426 _res = NULL;
16427 done:
16428 p->level--;
16429 return _res;
16430 }
16431
16432 // strings: ((fstring | string))+
16433 static expr_ty
16434 strings_rule(Parser *p)
16435 {
16436 if (p->level++ == MAXSTACK) {
16437 _Pypegen_stack_overflow(p);
16438 }
16439 if (p->error_indicator) {
16440 p->level--;
16441 return NULL;
16442 }
16443 expr_ty _res = NULL;
16444 if (_PyPegen_is_memoized(p, strings_type, &_res)) {
16445 p->level--;
16446 return _res;
16447 }
16448 int _mark = p->mark;
16449 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16450 p->error_indicator = 1;
16451 p->level--;
16452 return NULL;
16453 }
16454 int _start_lineno = p->tokens[_mark]->lineno;
16455 UNUSED(_start_lineno); // Only used by EXTRA macro
16456 int _start_col_offset = p->tokens[_mark]->col_offset;
16457 UNUSED(_start_col_offset); // Only used by EXTRA macro
16458 { // ((fstring | string))+
16459 if (p->error_indicator) {
16460 p->level--;
16461 return NULL;
16462 }
16463 D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((fstring | string))+"));
16464 asdl_expr_seq* a;
16465 if (
16466 (a = (asdl_expr_seq*)_loop1_114_rule(p)) // ((fstring | string))+
16467 )
16468 {
16469 D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string))+"));
16470 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16471 if (_token == NULL) {
16472 p->level--;
16473 return NULL;
16474 }
16475 int _end_lineno = _token->end_lineno;
16476 UNUSED(_end_lineno); // Only used by EXTRA macro
16477 int _end_col_offset = _token->end_col_offset;
16478 UNUSED(_end_col_offset); // Only used by EXTRA macro
16479 _res = _PyPegen_concatenate_strings ( p , a , EXTRA );
16480 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16481 p->error_indicator = 1;
16482 p->level--;
16483 return NULL;
16484 }
16485 goto done;
16486 }
16487 p->mark = _mark;
16488 D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ',
16489 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((fstring | string))+"));
16490 }
16491 _res = NULL;
16492 done:
16493 _PyPegen_insert_memo(p, _mark, strings_type, _res);
16494 p->level--;
16495 return _res;
16496 }
16497
16498 // list: '[' star_named_expressions? ']'
16499 static expr_ty
16500 list_rule(Parser *p)
16501 {
16502 if (p->level++ == MAXSTACK) {
16503 _Pypegen_stack_overflow(p);
16504 }
16505 if (p->error_indicator) {
16506 p->level--;
16507 return NULL;
16508 }
16509 expr_ty _res = NULL;
16510 int _mark = p->mark;
16511 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16512 p->error_indicator = 1;
16513 p->level--;
16514 return NULL;
16515 }
16516 int _start_lineno = p->tokens[_mark]->lineno;
16517 UNUSED(_start_lineno); // Only used by EXTRA macro
16518 int _start_col_offset = p->tokens[_mark]->col_offset;
16519 UNUSED(_start_col_offset); // Only used by EXTRA macro
16520 { // '[' star_named_expressions? ']'
16521 if (p->error_indicator) {
16522 p->level--;
16523 return NULL;
16524 }
16525 D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'"));
16526 Token * _literal;
16527 Token * _literal_1;
16528 void *a;
16529 if (
16530 (_literal = _PyPegen_expect_token(p, 9)) // token='['
16531 &&
16532 (a = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions?
16533 &&
16534 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
16535 )
16536 {
16537 D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'"));
16538 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16539 if (_token == NULL) {
16540 p->level--;
16541 return NULL;
16542 }
16543 int _end_lineno = _token->end_lineno;
16544 UNUSED(_end_lineno); // Only used by EXTRA macro
16545 int _end_col_offset = _token->end_col_offset;
16546 UNUSED(_end_col_offset); // Only used by EXTRA macro
16547 _res = _PyAST_List ( a , Load , EXTRA );
16548 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16549 p->error_indicator = 1;
16550 p->level--;
16551 return NULL;
16552 }
16553 goto done;
16554 }
16555 p->mark = _mark;
16556 D(fprintf(stderr, "%*c%s list[%d-%d]: %s failed!\n", p->level, ' ',
16557 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expressions? ']'"));
16558 }
16559 _res = NULL;
16560 done:
16561 p->level--;
16562 return _res;
16563 }
16564
16565 // tuple: '(' [star_named_expression ',' star_named_expressions?] ')'
16566 static expr_ty
16567 tuple_rule(Parser *p)
16568 {
16569 if (p->level++ == MAXSTACK) {
16570 _Pypegen_stack_overflow(p);
16571 }
16572 if (p->error_indicator) {
16573 p->level--;
16574 return NULL;
16575 }
16576 expr_ty _res = NULL;
16577 int _mark = p->mark;
16578 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16579 p->error_indicator = 1;
16580 p->level--;
16581 return NULL;
16582 }
16583 int _start_lineno = p->tokens[_mark]->lineno;
16584 UNUSED(_start_lineno); // Only used by EXTRA macro
16585 int _start_col_offset = p->tokens[_mark]->col_offset;
16586 UNUSED(_start_col_offset); // Only used by EXTRA macro
16587 { // '(' [star_named_expression ',' star_named_expressions?] ')'
16588 if (p->error_indicator) {
16589 p->level--;
16590 return NULL;
16591 }
16592 D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
16593 Token * _literal;
16594 Token * _literal_1;
16595 void *a;
16596 if (
16597 (_literal = _PyPegen_expect_token(p, 7)) // token='('
16598 &&
16599 (a = _tmp_115_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?]
16600 &&
16601 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
16602 )
16603 {
16604 D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
16605 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16606 if (_token == NULL) {
16607 p->level--;
16608 return NULL;
16609 }
16610 int _end_lineno = _token->end_lineno;
16611 UNUSED(_end_lineno); // Only used by EXTRA macro
16612 int _end_col_offset = _token->end_col_offset;
16613 UNUSED(_end_col_offset); // Only used by EXTRA macro
16614 _res = _PyAST_Tuple ( a , Load , EXTRA );
16615 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16616 p->error_indicator = 1;
16617 p->level--;
16618 return NULL;
16619 }
16620 goto done;
16621 }
16622 p->mark = _mark;
16623 D(fprintf(stderr, "%*c%s tuple[%d-%d]: %s failed!\n", p->level, ' ',
16624 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
16625 }
16626 _res = NULL;
16627 done:
16628 p->level--;
16629 return _res;
16630 }
16631
16632 // set: '{' star_named_expressions '}'
16633 static expr_ty
16634 set_rule(Parser *p)
16635 {
16636 if (p->level++ == MAXSTACK) {
16637 _Pypegen_stack_overflow(p);
16638 }
16639 if (p->error_indicator) {
16640 p->level--;
16641 return NULL;
16642 }
16643 expr_ty _res = NULL;
16644 int _mark = p->mark;
16645 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16646 p->error_indicator = 1;
16647 p->level--;
16648 return NULL;
16649 }
16650 int _start_lineno = p->tokens[_mark]->lineno;
16651 UNUSED(_start_lineno); // Only used by EXTRA macro
16652 int _start_col_offset = p->tokens[_mark]->col_offset;
16653 UNUSED(_start_col_offset); // Only used by EXTRA macro
16654 { // '{' star_named_expressions '}'
16655 if (p->error_indicator) {
16656 p->level--;
16657 return NULL;
16658 }
16659 D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'"));
16660 Token * _literal;
16661 Token * _literal_1;
16662 asdl_expr_seq* a;
16663 if (
16664 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
16665 &&
16666 (a = star_named_expressions_rule(p)) // star_named_expressions
16667 &&
16668 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
16669 )
16670 {
16671 D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'"));
16672 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16673 if (_token == NULL) {
16674 p->level--;
16675 return NULL;
16676 }
16677 int _end_lineno = _token->end_lineno;
16678 UNUSED(_end_lineno); // Only used by EXTRA macro
16679 int _end_col_offset = _token->end_col_offset;
16680 UNUSED(_end_col_offset); // Only used by EXTRA macro
16681 _res = _PyAST_Set ( a , EXTRA );
16682 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16683 p->error_indicator = 1;
16684 p->level--;
16685 return NULL;
16686 }
16687 goto done;
16688 }
16689 p->mark = _mark;
16690 D(fprintf(stderr, "%*c%s set[%d-%d]: %s failed!\n", p->level, ' ',
16691 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expressions '}'"));
16692 }
16693 _res = NULL;
16694 done:
16695 p->level--;
16696 return _res;
16697 }
16698
16699 // dict: '{' double_starred_kvpairs? '}' | '{' invalid_double_starred_kvpairs '}'
16700 static expr_ty
16701 dict_rule(Parser *p)
16702 {
16703 if (p->level++ == MAXSTACK) {
16704 _Pypegen_stack_overflow(p);
16705 }
16706 if (p->error_indicator) {
16707 p->level--;
16708 return NULL;
16709 }
16710 expr_ty _res = NULL;
16711 int _mark = p->mark;
16712 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
16713 p->error_indicator = 1;
16714 p->level--;
16715 return NULL;
16716 }
16717 int _start_lineno = p->tokens[_mark]->lineno;
16718 UNUSED(_start_lineno); // Only used by EXTRA macro
16719 int _start_col_offset = p->tokens[_mark]->col_offset;
16720 UNUSED(_start_col_offset); // Only used by EXTRA macro
16721 { // '{' double_starred_kvpairs? '}'
16722 if (p->error_indicator) {
16723 p->level--;
16724 return NULL;
16725 }
16726 D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
16727 Token * _literal;
16728 Token * _literal_1;
16729 void *a;
16730 if (
16731 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
16732 &&
16733 (a = double_starred_kvpairs_rule(p), !p->error_indicator) // double_starred_kvpairs?
16734 &&
16735 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
16736 )
16737 {
16738 D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
16739 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
16740 if (_token == NULL) {
16741 p->level--;
16742 return NULL;
16743 }
16744 int _end_lineno = _token->end_lineno;
16745 UNUSED(_end_lineno); // Only used by EXTRA macro
16746 int _end_col_offset = _token->end_col_offset;
16747 UNUSED(_end_col_offset); // Only used by EXTRA macro
16748 _res = _PyAST_Dict ( CHECK ( asdl_expr_seq* , _PyPegen_get_keys ( p , a ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_values ( p , a ) ) , EXTRA );
16749 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16750 p->error_indicator = 1;
16751 p->level--;
16752 return NULL;
16753 }
16754 goto done;
16755 }
16756 p->mark = _mark;
16757 D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ',
16758 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
16759 }
16760 { // '{' invalid_double_starred_kvpairs '}'
16761 if (p->error_indicator) {
16762 p->level--;
16763 return NULL;
16764 }
16765 D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'"));
16766 Token * _literal;
16767 Token * _literal_1;
16768 void *invalid_double_starred_kvpairs_var;
16769 if (
16770 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
16771 &&
16772 (invalid_double_starred_kvpairs_var = invalid_double_starred_kvpairs_rule(p)) // invalid_double_starred_kvpairs
16773 &&
16774 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
16775 )
16776 {
16777 D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'"));
16778 _res = _PyPegen_dummy_name(p, _literal, invalid_double_starred_kvpairs_var, _literal_1);
16779 goto done;
16780 }
16781 p->mark = _mark;
16782 D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ',
16783 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' invalid_double_starred_kvpairs '}'"));
16784 }
16785 _res = NULL;
16786 done:
16787 p->level--;
16788 return _res;
16789 }
16790
16791 // double_starred_kvpairs: ','.double_starred_kvpair+ ','?
16792 static asdl_seq*
16793 double_starred_kvpairs_rule(Parser *p)
16794 {
16795 if (p->level++ == MAXSTACK) {
16796 _Pypegen_stack_overflow(p);
16797 }
16798 if (p->error_indicator) {
16799 p->level--;
16800 return NULL;
16801 }
16802 asdl_seq* _res = NULL;
16803 int _mark = p->mark;
16804 { // ','.double_starred_kvpair+ ','?
16805 if (p->error_indicator) {
16806 p->level--;
16807 return NULL;
16808 }
16809 D(fprintf(stderr, "%*c> double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?"));
16810 void *_opt_var;
16811 UNUSED(_opt_var); // Silence compiler warnings
16812 asdl_seq * a;
16813 if (
16814 (a = _gather_116_rule(p)) // ','.double_starred_kvpair+
16815 &&
16816 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
16817 )
16818 {
16819 D(fprintf(stderr, "%*c+ double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?"));
16820 _res = a;
16821 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16822 p->error_indicator = 1;
16823 p->level--;
16824 return NULL;
16825 }
16826 goto done;
16827 }
16828 p->mark = _mark;
16829 D(fprintf(stderr, "%*c%s double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',
16830 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ','?"));
16831 }
16832 _res = NULL;
16833 done:
16834 p->level--;
16835 return _res;
16836 }
16837
16838 // double_starred_kvpair: '**' bitwise_or | kvpair
16839 static KeyValuePair*
16840 double_starred_kvpair_rule(Parser *p)
16841 {
16842 if (p->level++ == MAXSTACK) {
16843 _Pypegen_stack_overflow(p);
16844 }
16845 if (p->error_indicator) {
16846 p->level--;
16847 return NULL;
16848 }
16849 KeyValuePair* _res = NULL;
16850 int _mark = p->mark;
16851 { // '**' bitwise_or
16852 if (p->error_indicator) {
16853 p->level--;
16854 return NULL;
16855 }
16856 D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or"));
16857 Token * _literal;
16858 expr_ty a;
16859 if (
16860 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
16861 &&
16862 (a = bitwise_or_rule(p)) // bitwise_or
16863 )
16864 {
16865 D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or"));
16866 _res = _PyPegen_key_value_pair ( p , NULL , a );
16867 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16868 p->error_indicator = 1;
16869 p->level--;
16870 return NULL;
16871 }
16872 goto done;
16873 }
16874 p->mark = _mark;
16875 D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
16876 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or"));
16877 }
16878 { // kvpair
16879 if (p->error_indicator) {
16880 p->level--;
16881 return NULL;
16882 }
16883 D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kvpair"));
16884 KeyValuePair* kvpair_var;
16885 if (
16886 (kvpair_var = kvpair_rule(p)) // kvpair
16887 )
16888 {
16889 D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kvpair"));
16890 _res = kvpair_var;
16891 goto done;
16892 }
16893 p->mark = _mark;
16894 D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
16895 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kvpair"));
16896 }
16897 _res = NULL;
16898 done:
16899 p->level--;
16900 return _res;
16901 }
16902
16903 // kvpair: expression ':' expression
16904 static KeyValuePair*
16905 kvpair_rule(Parser *p)
16906 {
16907 if (p->level++ == MAXSTACK) {
16908 _Pypegen_stack_overflow(p);
16909 }
16910 if (p->error_indicator) {
16911 p->level--;
16912 return NULL;
16913 }
16914 KeyValuePair* _res = NULL;
16915 int _mark = p->mark;
16916 { // expression ':' expression
16917 if (p->error_indicator) {
16918 p->level--;
16919 return NULL;
16920 }
16921 D(fprintf(stderr, "%*c> kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
16922 Token * _literal;
16923 expr_ty a;
16924 expr_ty b;
16925 if (
16926 (a = expression_rule(p)) // expression
16927 &&
16928 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
16929 &&
16930 (b = expression_rule(p)) // expression
16931 )
16932 {
16933 D(fprintf(stderr, "%*c+ kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
16934 _res = _PyPegen_key_value_pair ( p , a , b );
16935 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16936 p->error_indicator = 1;
16937 p->level--;
16938 return NULL;
16939 }
16940 goto done;
16941 }
16942 p->mark = _mark;
16943 D(fprintf(stderr, "%*c%s kvpair[%d-%d]: %s failed!\n", p->level, ' ',
16944 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression"));
16945 }
16946 _res = NULL;
16947 done:
16948 p->level--;
16949 return _res;
16950 }
16951
16952 // for_if_clauses: for_if_clause+
16953 static asdl_comprehension_seq*
16954 for_if_clauses_rule(Parser *p)
16955 {
16956 if (p->level++ == MAXSTACK) {
16957 _Pypegen_stack_overflow(p);
16958 }
16959 if (p->error_indicator) {
16960 p->level--;
16961 return NULL;
16962 }
16963 asdl_comprehension_seq* _res = NULL;
16964 int _mark = p->mark;
16965 { // for_if_clause+
16966 if (p->error_indicator) {
16967 p->level--;
16968 return NULL;
16969 }
16970 D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause+"));
16971 asdl_comprehension_seq* a;
16972 if (
16973 (a = (asdl_comprehension_seq*)_loop1_118_rule(p)) // for_if_clause+
16974 )
16975 {
16976 D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "for_if_clause+"));
16977 _res = a;
16978 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
16979 p->error_indicator = 1;
16980 p->level--;
16981 return NULL;
16982 }
16983 goto done;
16984 }
16985 p->mark = _mark;
16986 D(fprintf(stderr, "%*c%s for_if_clauses[%d-%d]: %s failed!\n", p->level, ' ',
16987 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause+"));
16988 }
16989 _res = NULL;
16990 done:
16991 p->level--;
16992 return _res;
16993 }
16994
16995 // for_if_clause:
16996 // | 'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
16997 // | 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
16998 // | 'async'? 'for' (bitwise_or ((',' bitwise_or))* ','?) !'in'
16999 // | invalid_for_target
17000 static comprehension_ty
17001 for_if_clause_rule(Parser *p)
17002 {
17003 if (p->level++ == MAXSTACK) {
17004 _Pypegen_stack_overflow(p);
17005 }
17006 if (p->error_indicator) {
17007 p->level--;
17008 return NULL;
17009 }
17010 comprehension_ty _res = NULL;
17011 int _mark = p->mark;
17012 { // 'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
17013 if (p->error_indicator) {
17014 p->level--;
17015 return NULL;
17016 }
17017 D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
17018 int _cut_var = 0;
17019 Token * _keyword;
17020 Token * _keyword_1;
17021 Token * _keyword_2;
17022 expr_ty a;
17023 expr_ty b;
17024 asdl_expr_seq* c;
17025 if (
17026 (_keyword = _PyPegen_expect_token(p, 674)) // token='async'
17027 &&
17028 (_keyword_1 = _PyPegen_expect_token(p, 670)) // token='for'
17029 &&
17030 (a = star_targets_rule(p)) // star_targets
17031 &&
17032 (_keyword_2 = _PyPegen_expect_token(p, 671)) // token='in'
17033 &&
17034 (_cut_var = 1)
17035 &&
17036 (b = disjunction_rule(p)) // disjunction
17037 &&
17038 (c = (asdl_expr_seq*)_loop0_119_rule(p)) // (('if' disjunction))*
17039 )
17040 {
17041 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))*"));
17042 _res = CHECK_VERSION ( comprehension_ty , 6 , "Async comprehensions are" , _PyAST_comprehension ( a , b , c , 1 , p -> arena ) );
17043 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17044 p->error_indicator = 1;
17045 p->level--;
17046 return NULL;
17047 }
17048 goto done;
17049 }
17050 p->mark = _mark;
17051 D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
17052 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
17053 if (_cut_var) {
17054 p->level--;
17055 return NULL;
17056 }
17057 }
17058 { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
17059 if (p->error_indicator) {
17060 p->level--;
17061 return NULL;
17062 }
17063 D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
17064 int _cut_var = 0;
17065 Token * _keyword;
17066 Token * _keyword_1;
17067 expr_ty a;
17068 expr_ty b;
17069 asdl_expr_seq* c;
17070 if (
17071 (_keyword = _PyPegen_expect_token(p, 670)) // token='for'
17072 &&
17073 (a = star_targets_rule(p)) // star_targets
17074 &&
17075 (_keyword_1 = _PyPegen_expect_token(p, 671)) // token='in'
17076 &&
17077 (_cut_var = 1)
17078 &&
17079 (b = disjunction_rule(p)) // disjunction
17080 &&
17081 (c = (asdl_expr_seq*)_loop0_120_rule(p)) // (('if' disjunction))*
17082 )
17083 {
17084 D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
17085 _res = _PyAST_comprehension ( a , b , c , 0 , p -> arena );
17086 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17087 p->error_indicator = 1;
17088 p->level--;
17089 return NULL;
17090 }
17091 goto done;
17092 }
17093 p->mark = _mark;
17094 D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
17095 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
17096 if (_cut_var) {
17097 p->level--;
17098 return NULL;
17099 }
17100 }
17101 { // 'async'? 'for' (bitwise_or ((',' bitwise_or))* ','?) !'in'
17102 if (p->error_indicator) {
17103 p->level--;
17104 return NULL;
17105 }
17106 D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'for' (bitwise_or ((',' bitwise_or))* ','?) !'in'"));
17107 Token * _keyword;
17108 void *_opt_var;
17109 UNUSED(_opt_var); // Silence compiler warnings
17110 void *_tmp_121_var;
17111 if (
17112 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
17113 &&
17114 (_keyword = _PyPegen_expect_token(p, 670)) // token='for'
17115 &&
17116 (_tmp_121_var = _tmp_121_rule(p)) // bitwise_or ((',' bitwise_or))* ','?
17117 &&
17118 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 671) // token='in'
17119 )
17120 {
17121 D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'? 'for' (bitwise_or ((',' bitwise_or))* ','?) !'in'"));
17122 _res = RAISE_SYNTAX_ERROR ( "'in' expected after for-loop variables" );
17123 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17124 p->error_indicator = 1;
17125 p->level--;
17126 return NULL;
17127 }
17128 goto done;
17129 }
17130 p->mark = _mark;
17131 D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
17132 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'for' (bitwise_or ((',' bitwise_or))* ','?) !'in'"));
17133 }
17134 if (p->call_invalid_rules) { // invalid_for_target
17135 if (p->error_indicator) {
17136 p->level--;
17137 return NULL;
17138 }
17139 D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
17140 void *invalid_for_target_var;
17141 if (
17142 (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target
17143 )
17144 {
17145 D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
17146 _res = invalid_for_target_var;
17147 goto done;
17148 }
17149 p->mark = _mark;
17150 D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
17151 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target"));
17152 }
17153 _res = NULL;
17154 done:
17155 p->level--;
17156 return _res;
17157 }
17158
17159 // listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension
17160 static expr_ty
17161 listcomp_rule(Parser *p)
17162 {
17163 if (p->level++ == MAXSTACK) {
17164 _Pypegen_stack_overflow(p);
17165 }
17166 if (p->error_indicator) {
17167 p->level--;
17168 return NULL;
17169 }
17170 expr_ty _res = NULL;
17171 int _mark = p->mark;
17172 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17173 p->error_indicator = 1;
17174 p->level--;
17175 return NULL;
17176 }
17177 int _start_lineno = p->tokens[_mark]->lineno;
17178 UNUSED(_start_lineno); // Only used by EXTRA macro
17179 int _start_col_offset = p->tokens[_mark]->col_offset;
17180 UNUSED(_start_col_offset); // Only used by EXTRA macro
17181 { // '[' named_expression for_if_clauses ']'
17182 if (p->error_indicator) {
17183 p->level--;
17184 return NULL;
17185 }
17186 D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' named_expression for_if_clauses ']'"));
17187 Token * _literal;
17188 Token * _literal_1;
17189 expr_ty a;
17190 asdl_comprehension_seq* b;
17191 if (
17192 (_literal = _PyPegen_expect_token(p, 9)) // token='['
17193 &&
17194 (a = named_expression_rule(p)) // named_expression
17195 &&
17196 (b = for_if_clauses_rule(p)) // for_if_clauses
17197 &&
17198 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
17199 )
17200 {
17201 D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' named_expression for_if_clauses ']'"));
17202 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17203 if (_token == NULL) {
17204 p->level--;
17205 return NULL;
17206 }
17207 int _end_lineno = _token->end_lineno;
17208 UNUSED(_end_lineno); // Only used by EXTRA macro
17209 int _end_col_offset = _token->end_col_offset;
17210 UNUSED(_end_col_offset); // Only used by EXTRA macro
17211 _res = _PyAST_ListComp ( a , b , EXTRA );
17212 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17213 p->error_indicator = 1;
17214 p->level--;
17215 return NULL;
17216 }
17217 goto done;
17218 }
17219 p->mark = _mark;
17220 D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ',
17221 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' named_expression for_if_clauses ']'"));
17222 }
17223 if (p->call_invalid_rules) { // invalid_comprehension
17224 if (p->error_indicator) {
17225 p->level--;
17226 return NULL;
17227 }
17228 D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
17229 void *invalid_comprehension_var;
17230 if (
17231 (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension
17232 )
17233 {
17234 D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
17235 _res = invalid_comprehension_var;
17236 goto done;
17237 }
17238 p->mark = _mark;
17239 D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ',
17240 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));
17241 }
17242 _res = NULL;
17243 done:
17244 p->level--;
17245 return _res;
17246 }
17247
17248 // setcomp: '{' named_expression for_if_clauses '}' | invalid_comprehension
17249 static expr_ty
17250 setcomp_rule(Parser *p)
17251 {
17252 if (p->level++ == MAXSTACK) {
17253 _Pypegen_stack_overflow(p);
17254 }
17255 if (p->error_indicator) {
17256 p->level--;
17257 return NULL;
17258 }
17259 expr_ty _res = NULL;
17260 int _mark = p->mark;
17261 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17262 p->error_indicator = 1;
17263 p->level--;
17264 return NULL;
17265 }
17266 int _start_lineno = p->tokens[_mark]->lineno;
17267 UNUSED(_start_lineno); // Only used by EXTRA macro
17268 int _start_col_offset = p->tokens[_mark]->col_offset;
17269 UNUSED(_start_col_offset); // Only used by EXTRA macro
17270 { // '{' named_expression for_if_clauses '}'
17271 if (p->error_indicator) {
17272 p->level--;
17273 return NULL;
17274 }
17275 D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' named_expression for_if_clauses '}'"));
17276 Token * _literal;
17277 Token * _literal_1;
17278 expr_ty a;
17279 asdl_comprehension_seq* b;
17280 if (
17281 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
17282 &&
17283 (a = named_expression_rule(p)) // named_expression
17284 &&
17285 (b = for_if_clauses_rule(p)) // for_if_clauses
17286 &&
17287 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
17288 )
17289 {
17290 D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' named_expression for_if_clauses '}'"));
17291 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17292 if (_token == NULL) {
17293 p->level--;
17294 return NULL;
17295 }
17296 int _end_lineno = _token->end_lineno;
17297 UNUSED(_end_lineno); // Only used by EXTRA macro
17298 int _end_col_offset = _token->end_col_offset;
17299 UNUSED(_end_col_offset); // Only used by EXTRA macro
17300 _res = _PyAST_SetComp ( a , b , EXTRA );
17301 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17302 p->error_indicator = 1;
17303 p->level--;
17304 return NULL;
17305 }
17306 goto done;
17307 }
17308 p->mark = _mark;
17309 D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ',
17310 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' named_expression for_if_clauses '}'"));
17311 }
17312 if (p->call_invalid_rules) { // invalid_comprehension
17313 if (p->error_indicator) {
17314 p->level--;
17315 return NULL;
17316 }
17317 D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
17318 void *invalid_comprehension_var;
17319 if (
17320 (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension
17321 )
17322 {
17323 D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
17324 _res = invalid_comprehension_var;
17325 goto done;
17326 }
17327 p->mark = _mark;
17328 D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ',
17329 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));
17330 }
17331 _res = NULL;
17332 done:
17333 p->level--;
17334 return _res;
17335 }
17336
17337 // genexp:
17338 // | '(' (assignment_expression | expression !':=') for_if_clauses ')'
17339 // | invalid_comprehension
17340 static expr_ty
17341 genexp_rule(Parser *p)
17342 {
17343 if (p->level++ == MAXSTACK) {
17344 _Pypegen_stack_overflow(p);
17345 }
17346 if (p->error_indicator) {
17347 p->level--;
17348 return NULL;
17349 }
17350 expr_ty _res = NULL;
17351 int _mark = p->mark;
17352 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17353 p->error_indicator = 1;
17354 p->level--;
17355 return NULL;
17356 }
17357 int _start_lineno = p->tokens[_mark]->lineno;
17358 UNUSED(_start_lineno); // Only used by EXTRA macro
17359 int _start_col_offset = p->tokens[_mark]->col_offset;
17360 UNUSED(_start_col_offset); // Only used by EXTRA macro
17361 { // '(' (assignment_expression | expression !':=') for_if_clauses ')'
17362 if (p->error_indicator) {
17363 p->level--;
17364 return NULL;
17365 }
17366 D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'"));
17367 Token * _literal;
17368 Token * _literal_1;
17369 void *a;
17370 asdl_comprehension_seq* b;
17371 if (
17372 (_literal = _PyPegen_expect_token(p, 7)) // token='('
17373 &&
17374 (a = _tmp_122_rule(p)) // assignment_expression | expression !':='
17375 &&
17376 (b = for_if_clauses_rule(p)) // for_if_clauses
17377 &&
17378 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
17379 )
17380 {
17381 D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'"));
17382 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17383 if (_token == NULL) {
17384 p->level--;
17385 return NULL;
17386 }
17387 int _end_lineno = _token->end_lineno;
17388 UNUSED(_end_lineno); // Only used by EXTRA macro
17389 int _end_col_offset = _token->end_col_offset;
17390 UNUSED(_end_col_offset); // Only used by EXTRA macro
17391 _res = _PyAST_GeneratorExp ( a , b , EXTRA );
17392 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17393 p->error_indicator = 1;
17394 p->level--;
17395 return NULL;
17396 }
17397 goto done;
17398 }
17399 p->mark = _mark;
17400 D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ',
17401 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'"));
17402 }
17403 if (p->call_invalid_rules) { // invalid_comprehension
17404 if (p->error_indicator) {
17405 p->level--;
17406 return NULL;
17407 }
17408 D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
17409 void *invalid_comprehension_var;
17410 if (
17411 (invalid_comprehension_var = invalid_comprehension_rule(p)) // invalid_comprehension
17412 )
17413 {
17414 D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
17415 _res = invalid_comprehension_var;
17416 goto done;
17417 }
17418 p->mark = _mark;
17419 D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ',
17420 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));
17421 }
17422 _res = NULL;
17423 done:
17424 p->level--;
17425 return _res;
17426 }
17427
17428 // dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension
17429 static expr_ty
17430 dictcomp_rule(Parser *p)
17431 {
17432 if (p->level++ == MAXSTACK) {
17433 _Pypegen_stack_overflow(p);
17434 }
17435 if (p->error_indicator) {
17436 p->level--;
17437 return NULL;
17438 }
17439 expr_ty _res = NULL;
17440 int _mark = p->mark;
17441 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17442 p->error_indicator = 1;
17443 p->level--;
17444 return NULL;
17445 }
17446 int _start_lineno = p->tokens[_mark]->lineno;
17447 UNUSED(_start_lineno); // Only used by EXTRA macro
17448 int _start_col_offset = p->tokens[_mark]->col_offset;
17449 UNUSED(_start_col_offset); // Only used by EXTRA macro
17450 { // '{' kvpair for_if_clauses '}'
17451 if (p->error_indicator) {
17452 p->level--;
17453 return NULL;
17454 }
17455 D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
17456 Token * _literal;
17457 Token * _literal_1;
17458 KeyValuePair* a;
17459 asdl_comprehension_seq* b;
17460 if (
17461 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
17462 &&
17463 (a = kvpair_rule(p)) // kvpair
17464 &&
17465 (b = for_if_clauses_rule(p)) // for_if_clauses
17466 &&
17467 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
17468 )
17469 {
17470 D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
17471 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17472 if (_token == NULL) {
17473 p->level--;
17474 return NULL;
17475 }
17476 int _end_lineno = _token->end_lineno;
17477 UNUSED(_end_lineno); // Only used by EXTRA macro
17478 int _end_col_offset = _token->end_col_offset;
17479 UNUSED(_end_col_offset); // Only used by EXTRA macro
17480 _res = _PyAST_DictComp ( a -> key , a -> value , b , EXTRA );
17481 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17482 p->error_indicator = 1;
17483 p->level--;
17484 return NULL;
17485 }
17486 goto done;
17487 }
17488 p->mark = _mark;
17489 D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ',
17490 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
17491 }
17492 if (p->call_invalid_rules) { // invalid_dict_comprehension
17493 if (p->error_indicator) {
17494 p->level--;
17495 return NULL;
17496 }
17497 D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension"));
17498 void *invalid_dict_comprehension_var;
17499 if (
17500 (invalid_dict_comprehension_var = invalid_dict_comprehension_rule(p)) // invalid_dict_comprehension
17501 )
17502 {
17503 D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension"));
17504 _res = invalid_dict_comprehension_var;
17505 goto done;
17506 }
17507 p->mark = _mark;
17508 D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ',
17509 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_dict_comprehension"));
17510 }
17511 _res = NULL;
17512 done:
17513 p->level--;
17514 return _res;
17515 }
17516
17517 // arguments: args ','? &')' | invalid_arguments
17518 static expr_ty
17519 arguments_rule(Parser *p)
17520 {
17521 if (p->level++ == MAXSTACK) {
17522 _Pypegen_stack_overflow(p);
17523 }
17524 if (p->error_indicator) {
17525 p->level--;
17526 return NULL;
17527 }
17528 expr_ty _res = NULL;
17529 if (_PyPegen_is_memoized(p, arguments_type, &_res)) {
17530 p->level--;
17531 return _res;
17532 }
17533 int _mark = p->mark;
17534 { // args ','? &')'
17535 if (p->error_indicator) {
17536 p->level--;
17537 return NULL;
17538 }
17539 D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','? &')'"));
17540 void *_opt_var;
17541 UNUSED(_opt_var); // Silence compiler warnings
17542 expr_ty a;
17543 if (
17544 (a = args_rule(p)) // args
17545 &&
17546 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
17547 &&
17548 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8) // token=')'
17549 )
17550 {
17551 D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','? &')'"));
17552 _res = a;
17553 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17554 p->error_indicator = 1;
17555 p->level--;
17556 return NULL;
17557 }
17558 goto done;
17559 }
17560 p->mark = _mark;
17561 D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ',
17562 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','? &')'"));
17563 }
17564 if (p->call_invalid_rules) { // invalid_arguments
17565 if (p->error_indicator) {
17566 p->level--;
17567 return NULL;
17568 }
17569 D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_arguments"));
17570 void *invalid_arguments_var;
17571 if (
17572 (invalid_arguments_var = invalid_arguments_rule(p)) // invalid_arguments
17573 )
17574 {
17575 D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_arguments"));
17576 _res = invalid_arguments_var;
17577 goto done;
17578 }
17579 p->mark = _mark;
17580 D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ',
17581 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_arguments"));
17582 }
17583 _res = NULL;
17584 done:
17585 _PyPegen_insert_memo(p, _mark, arguments_type, _res);
17586 p->level--;
17587 return _res;
17588 }
17589
17590 // args:
17591 // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]
17592 // | kwargs
17593 static expr_ty
17594 args_rule(Parser *p)
17595 {
17596 if (p->level++ == MAXSTACK) {
17597 _Pypegen_stack_overflow(p);
17598 }
17599 if (p->error_indicator) {
17600 p->level--;
17601 return NULL;
17602 }
17603 expr_ty _res = NULL;
17604 int _mark = p->mark;
17605 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17606 p->error_indicator = 1;
17607 p->level--;
17608 return NULL;
17609 }
17610 int _start_lineno = p->tokens[_mark]->lineno;
17611 UNUSED(_start_lineno); // Only used by EXTRA macro
17612 int _start_col_offset = p->tokens[_mark]->col_offset;
17613 UNUSED(_start_col_offset); // Only used by EXTRA macro
17614 { // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]
17615 if (p->error_indicator) {
17616 p->level--;
17617 return NULL;
17618 }
17619 D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]"));
17620 asdl_expr_seq* a;
17621 void *b;
17622 if (
17623 (a = (asdl_expr_seq*)_gather_123_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+
17624 &&
17625 (b = _tmp_125_rule(p), !p->error_indicator) // [',' kwargs]
17626 )
17627 {
17628 D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]"));
17629 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17630 if (_token == NULL) {
17631 p->level--;
17632 return NULL;
17633 }
17634 int _end_lineno = _token->end_lineno;
17635 UNUSED(_end_lineno); // Only used by EXTRA macro
17636 int _end_col_offset = _token->end_col_offset;
17637 UNUSED(_end_col_offset); // Only used by EXTRA macro
17638 _res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA );
17639 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17640 p->error_indicator = 1;
17641 p->level--;
17642 return NULL;
17643 }
17644 goto done;
17645 }
17646 p->mark = _mark;
17647 D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ',
17648 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]"));
17649 }
17650 { // kwargs
17651 if (p->error_indicator) {
17652 p->level--;
17653 return NULL;
17654 }
17655 D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs"));
17656 asdl_seq* a;
17657 if (
17658 (a = kwargs_rule(p)) // kwargs
17659 )
17660 {
17661 D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs"));
17662 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17663 if (_token == NULL) {
17664 p->level--;
17665 return NULL;
17666 }
17667 int _end_lineno = _token->end_lineno;
17668 UNUSED(_end_lineno); // Only used by EXTRA macro
17669 int _end_col_offset = _token->end_col_offset;
17670 UNUSED(_end_col_offset); // Only used by EXTRA macro
17671 _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 );
17672 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17673 p->error_indicator = 1;
17674 p->level--;
17675 return NULL;
17676 }
17677 goto done;
17678 }
17679 p->mark = _mark;
17680 D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ',
17681 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs"));
17682 }
17683 _res = NULL;
17684 done:
17685 p->level--;
17686 return _res;
17687 }
17688
17689 // kwargs:
17690 // | ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
17691 // | ','.kwarg_or_starred+
17692 // | ','.kwarg_or_double_starred+
17693 static asdl_seq*
17694 kwargs_rule(Parser *p)
17695 {
17696 if (p->level++ == MAXSTACK) {
17697 _Pypegen_stack_overflow(p);
17698 }
17699 if (p->error_indicator) {
17700 p->level--;
17701 return NULL;
17702 }
17703 asdl_seq* _res = NULL;
17704 int _mark = p->mark;
17705 { // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
17706 if (p->error_indicator) {
17707 p->level--;
17708 return NULL;
17709 }
17710 D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+"));
17711 Token * _literal;
17712 asdl_seq * a;
17713 asdl_seq * b;
17714 if (
17715 (a = _gather_126_rule(p)) // ','.kwarg_or_starred+
17716 &&
17717 (_literal = _PyPegen_expect_token(p, 12)) // token=','
17718 &&
17719 (b = _gather_128_rule(p)) // ','.kwarg_or_double_starred+
17720 )
17721 {
17722 D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+"));
17723 _res = _PyPegen_join_sequences ( p , a , b );
17724 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17725 p->error_indicator = 1;
17726 p->level--;
17727 return NULL;
17728 }
17729 goto done;
17730 }
17731 p->mark = _mark;
17732 D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ',
17733 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+"));
17734 }
17735 { // ','.kwarg_or_starred+
17736 if (p->error_indicator) {
17737 p->level--;
17738 return NULL;
17739 }
17740 D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+"));
17741 asdl_seq * _gather_130_var;
17742 if (
17743 (_gather_130_var = _gather_130_rule(p)) // ','.kwarg_or_starred+
17744 )
17745 {
17746 D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+"));
17747 _res = _gather_130_var;
17748 goto done;
17749 }
17750 p->mark = _mark;
17751 D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ',
17752 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+"));
17753 }
17754 { // ','.kwarg_or_double_starred+
17755 if (p->error_indicator) {
17756 p->level--;
17757 return NULL;
17758 }
17759 D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+"));
17760 asdl_seq * _gather_132_var;
17761 if (
17762 (_gather_132_var = _gather_132_rule(p)) // ','.kwarg_or_double_starred+
17763 )
17764 {
17765 D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+"));
17766 _res = _gather_132_var;
17767 goto done;
17768 }
17769 p->mark = _mark;
17770 D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ',
17771 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_double_starred+"));
17772 }
17773 _res = NULL;
17774 done:
17775 p->level--;
17776 return _res;
17777 }
17778
17779 // starred_expression: invalid_starred_expression | '*' expression | '*'
17780 static expr_ty
17781 starred_expression_rule(Parser *p)
17782 {
17783 if (p->level++ == MAXSTACK) {
17784 _Pypegen_stack_overflow(p);
17785 }
17786 if (p->error_indicator) {
17787 p->level--;
17788 return NULL;
17789 }
17790 expr_ty _res = NULL;
17791 int _mark = p->mark;
17792 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17793 p->error_indicator = 1;
17794 p->level--;
17795 return NULL;
17796 }
17797 int _start_lineno = p->tokens[_mark]->lineno;
17798 UNUSED(_start_lineno); // Only used by EXTRA macro
17799 int _start_col_offset = p->tokens[_mark]->col_offset;
17800 UNUSED(_start_col_offset); // Only used by EXTRA macro
17801 if (p->call_invalid_rules) { // invalid_starred_expression
17802 if (p->error_indicator) {
17803 p->level--;
17804 return NULL;
17805 }
17806 D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_starred_expression"));
17807 void *invalid_starred_expression_var;
17808 if (
17809 (invalid_starred_expression_var = invalid_starred_expression_rule(p)) // invalid_starred_expression
17810 )
17811 {
17812 D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_starred_expression"));
17813 _res = invalid_starred_expression_var;
17814 goto done;
17815 }
17816 p->mark = _mark;
17817 D(fprintf(stderr, "%*c%s starred_expression[%d-%d]: %s failed!\n", p->level, ' ',
17818 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_starred_expression"));
17819 }
17820 { // '*' expression
17821 if (p->error_indicator) {
17822 p->level--;
17823 return NULL;
17824 }
17825 D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression"));
17826 Token * _literal;
17827 expr_ty a;
17828 if (
17829 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
17830 &&
17831 (a = expression_rule(p)) // expression
17832 )
17833 {
17834 D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression"));
17835 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17836 if (_token == NULL) {
17837 p->level--;
17838 return NULL;
17839 }
17840 int _end_lineno = _token->end_lineno;
17841 UNUSED(_end_lineno); // Only used by EXTRA macro
17842 int _end_col_offset = _token->end_col_offset;
17843 UNUSED(_end_col_offset); // Only used by EXTRA macro
17844 _res = _PyAST_Starred ( a , Load , EXTRA );
17845 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17846 p->error_indicator = 1;
17847 p->level--;
17848 return NULL;
17849 }
17850 goto done;
17851 }
17852 p->mark = _mark;
17853 D(fprintf(stderr, "%*c%s starred_expression[%d-%d]: %s failed!\n", p->level, ' ',
17854 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression"));
17855 }
17856 { // '*'
17857 if (p->error_indicator) {
17858 p->level--;
17859 return NULL;
17860 }
17861 D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
17862 Token * _literal;
17863 if (
17864 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
17865 )
17866 {
17867 D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'"));
17868 _res = RAISE_SYNTAX_ERROR ( "Invalid star expression" );
17869 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17870 p->error_indicator = 1;
17871 p->level--;
17872 return NULL;
17873 }
17874 goto done;
17875 }
17876 p->mark = _mark;
17877 D(fprintf(stderr, "%*c%s starred_expression[%d-%d]: %s failed!\n", p->level, ' ',
17878 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));
17879 }
17880 _res = NULL;
17881 done:
17882 p->level--;
17883 return _res;
17884 }
17885
17886 // kwarg_or_starred: invalid_kwarg | NAME '=' expression | starred_expression
17887 static KeywordOrStarred*
17888 kwarg_or_starred_rule(Parser *p)
17889 {
17890 if (p->level++ == MAXSTACK) {
17891 _Pypegen_stack_overflow(p);
17892 }
17893 if (p->error_indicator) {
17894 p->level--;
17895 return NULL;
17896 }
17897 KeywordOrStarred* _res = NULL;
17898 int _mark = p->mark;
17899 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
17900 p->error_indicator = 1;
17901 p->level--;
17902 return NULL;
17903 }
17904 int _start_lineno = p->tokens[_mark]->lineno;
17905 UNUSED(_start_lineno); // Only used by EXTRA macro
17906 int _start_col_offset = p->tokens[_mark]->col_offset;
17907 UNUSED(_start_col_offset); // Only used by EXTRA macro
17908 if (p->call_invalid_rules) { // invalid_kwarg
17909 if (p->error_indicator) {
17910 p->level--;
17911 return NULL;
17912 }
17913 D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
17914 void *invalid_kwarg_var;
17915 if (
17916 (invalid_kwarg_var = invalid_kwarg_rule(p)) // invalid_kwarg
17917 )
17918 {
17919 D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
17920 _res = invalid_kwarg_var;
17921 goto done;
17922 }
17923 p->mark = _mark;
17924 D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',
17925 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg"));
17926 }
17927 { // NAME '=' expression
17928 if (p->error_indicator) {
17929 p->level--;
17930 return NULL;
17931 }
17932 D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
17933 Token * _literal;
17934 expr_ty a;
17935 expr_ty b;
17936 if (
17937 (a = _PyPegen_name_token(p)) // NAME
17938 &&
17939 (_literal = _PyPegen_expect_token(p, 22)) // token='='
17940 &&
17941 (b = expression_rule(p)) // expression
17942 )
17943 {
17944 D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
17945 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
17946 if (_token == NULL) {
17947 p->level--;
17948 return NULL;
17949 }
17950 int _end_lineno = _token->end_lineno;
17951 UNUSED(_end_lineno); // Only used by EXTRA macro
17952 int _end_col_offset = _token->end_col_offset;
17953 UNUSED(_end_col_offset); // Only used by EXTRA macro
17954 _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
17955 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17956 p->error_indicator = 1;
17957 p->level--;
17958 return NULL;
17959 }
17960 goto done;
17961 }
17962 p->mark = _mark;
17963 D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',
17964 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression"));
17965 }
17966 { // starred_expression
17967 if (p->error_indicator) {
17968 p->level--;
17969 return NULL;
17970 }
17971 D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
17972 expr_ty a;
17973 if (
17974 (a = starred_expression_rule(p)) // starred_expression
17975 )
17976 {
17977 D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
17978 _res = _PyPegen_keyword_or_starred ( p , a , 0 );
17979 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
17980 p->error_indicator = 1;
17981 p->level--;
17982 return NULL;
17983 }
17984 goto done;
17985 }
17986 p->mark = _mark;
17987 D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',
17988 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
17989 }
17990 _res = NULL;
17991 done:
17992 p->level--;
17993 return _res;
17994 }
17995
17996 // kwarg_or_double_starred: invalid_kwarg | NAME '=' expression | '**' expression
17997 static KeywordOrStarred*
17998 kwarg_or_double_starred_rule(Parser *p)
17999 {
18000 if (p->level++ == MAXSTACK) {
18001 _Pypegen_stack_overflow(p);
18002 }
18003 if (p->error_indicator) {
18004 p->level--;
18005 return NULL;
18006 }
18007 KeywordOrStarred* _res = NULL;
18008 int _mark = p->mark;
18009 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18010 p->error_indicator = 1;
18011 p->level--;
18012 return NULL;
18013 }
18014 int _start_lineno = p->tokens[_mark]->lineno;
18015 UNUSED(_start_lineno); // Only used by EXTRA macro
18016 int _start_col_offset = p->tokens[_mark]->col_offset;
18017 UNUSED(_start_col_offset); // Only used by EXTRA macro
18018 if (p->call_invalid_rules) { // invalid_kwarg
18019 if (p->error_indicator) {
18020 p->level--;
18021 return NULL;
18022 }
18023 D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
18024 void *invalid_kwarg_var;
18025 if (
18026 (invalid_kwarg_var = invalid_kwarg_rule(p)) // invalid_kwarg
18027 )
18028 {
18029 D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
18030 _res = invalid_kwarg_var;
18031 goto done;
18032 }
18033 p->mark = _mark;
18034 D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',
18035 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg"));
18036 }
18037 { // NAME '=' expression
18038 if (p->error_indicator) {
18039 p->level--;
18040 return NULL;
18041 }
18042 D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
18043 Token * _literal;
18044 expr_ty a;
18045 expr_ty b;
18046 if (
18047 (a = _PyPegen_name_token(p)) // NAME
18048 &&
18049 (_literal = _PyPegen_expect_token(p, 22)) // token='='
18050 &&
18051 (b = expression_rule(p)) // expression
18052 )
18053 {
18054 D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
18055 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18056 if (_token == NULL) {
18057 p->level--;
18058 return NULL;
18059 }
18060 int _end_lineno = _token->end_lineno;
18061 UNUSED(_end_lineno); // Only used by EXTRA macro
18062 int _end_col_offset = _token->end_col_offset;
18063 UNUSED(_end_col_offset); // Only used by EXTRA macro
18064 _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
18065 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18066 p->error_indicator = 1;
18067 p->level--;
18068 return NULL;
18069 }
18070 goto done;
18071 }
18072 p->mark = _mark;
18073 D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',
18074 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression"));
18075 }
18076 { // '**' expression
18077 if (p->error_indicator) {
18078 p->level--;
18079 return NULL;
18080 }
18081 D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression"));
18082 Token * _literal;
18083 expr_ty a;
18084 if (
18085 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
18086 &&
18087 (a = expression_rule(p)) // expression
18088 )
18089 {
18090 D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression"));
18091 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18092 if (_token == NULL) {
18093 p->level--;
18094 return NULL;
18095 }
18096 int _end_lineno = _token->end_lineno;
18097 UNUSED(_end_lineno); // Only used by EXTRA macro
18098 int _end_col_offset = _token->end_col_offset;
18099 UNUSED(_end_col_offset); // Only used by EXTRA macro
18100 _res = _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( NULL , a , EXTRA ) ) , 1 );
18101 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18102 p->error_indicator = 1;
18103 p->level--;
18104 return NULL;
18105 }
18106 goto done;
18107 }
18108 p->mark = _mark;
18109 D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',
18110 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression"));
18111 }
18112 _res = NULL;
18113 done:
18114 p->level--;
18115 return _res;
18116 }
18117
18118 // star_targets: star_target !',' | star_target ((',' star_target))* ','?
18119 static expr_ty
18120 star_targets_rule(Parser *p)
18121 {
18122 if (p->level++ == MAXSTACK) {
18123 _Pypegen_stack_overflow(p);
18124 }
18125 if (p->error_indicator) {
18126 p->level--;
18127 return NULL;
18128 }
18129 expr_ty _res = NULL;
18130 int _mark = p->mark;
18131 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18132 p->error_indicator = 1;
18133 p->level--;
18134 return NULL;
18135 }
18136 int _start_lineno = p->tokens[_mark]->lineno;
18137 UNUSED(_start_lineno); // Only used by EXTRA macro
18138 int _start_col_offset = p->tokens[_mark]->col_offset;
18139 UNUSED(_start_col_offset); // Only used by EXTRA macro
18140 { // star_target !','
18141 if (p->error_indicator) {
18142 p->level--;
18143 return NULL;
18144 }
18145 D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target !','"));
18146 expr_ty a;
18147 if (
18148 (a = star_target_rule(p)) // star_target
18149 &&
18150 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=','
18151 )
18152 {
18153 D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target !','"));
18154 _res = a;
18155 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18156 p->error_indicator = 1;
18157 p->level--;
18158 return NULL;
18159 }
18160 goto done;
18161 }
18162 p->mark = _mark;
18163 D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ',
18164 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target !','"));
18165 }
18166 { // star_target ((',' star_target))* ','?
18167 if (p->error_indicator) {
18168 p->level--;
18169 return NULL;
18170 }
18171 D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?"));
18172 void *_opt_var;
18173 UNUSED(_opt_var); // Silence compiler warnings
18174 expr_ty a;
18175 asdl_seq * b;
18176 if (
18177 (a = star_target_rule(p)) // star_target
18178 &&
18179 (b = _loop0_134_rule(p)) // ((',' star_target))*
18180 &&
18181 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
18182 )
18183 {
18184 D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?"));
18185 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18186 if (_token == NULL) {
18187 p->level--;
18188 return NULL;
18189 }
18190 int _end_lineno = _token->end_lineno;
18191 UNUSED(_end_lineno); // Only used by EXTRA macro
18192 int _end_col_offset = _token->end_col_offset;
18193 UNUSED(_end_col_offset); // Only used by EXTRA macro
18194 _res = _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA );
18195 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18196 p->error_indicator = 1;
18197 p->level--;
18198 return NULL;
18199 }
18200 goto done;
18201 }
18202 p->mark = _mark;
18203 D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ',
18204 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))* ','?"));
18205 }
18206 _res = NULL;
18207 done:
18208 p->level--;
18209 return _res;
18210 }
18211
18212 // star_targets_list_seq: ','.star_target+ ','?
18213 static asdl_expr_seq*
18214 star_targets_list_seq_rule(Parser *p)
18215 {
18216 if (p->level++ == MAXSTACK) {
18217 _Pypegen_stack_overflow(p);
18218 }
18219 if (p->error_indicator) {
18220 p->level--;
18221 return NULL;
18222 }
18223 asdl_expr_seq* _res = NULL;
18224 int _mark = p->mark;
18225 { // ','.star_target+ ','?
18226 if (p->error_indicator) {
18227 p->level--;
18228 return NULL;
18229 }
18230 D(fprintf(stderr, "%*c> star_targets_list_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?"));
18231 void *_opt_var;
18232 UNUSED(_opt_var); // Silence compiler warnings
18233 asdl_expr_seq* a;
18234 if (
18235 (a = (asdl_expr_seq*)_gather_135_rule(p)) // ','.star_target+
18236 &&
18237 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
18238 )
18239 {
18240 D(fprintf(stderr, "%*c+ star_targets_list_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?"));
18241 _res = a;
18242 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18243 p->error_indicator = 1;
18244 p->level--;
18245 return NULL;
18246 }
18247 goto done;
18248 }
18249 p->mark = _mark;
18250 D(fprintf(stderr, "%*c%s star_targets_list_seq[%d-%d]: %s failed!\n", p->level, ' ',
18251 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_target+ ','?"));
18252 }
18253 _res = NULL;
18254 done:
18255 p->level--;
18256 return _res;
18257 }
18258
18259 // star_targets_tuple_seq: star_target ((',' star_target))+ ','? | star_target ','
18260 static asdl_expr_seq*
18261 star_targets_tuple_seq_rule(Parser *p)
18262 {
18263 if (p->level++ == MAXSTACK) {
18264 _Pypegen_stack_overflow(p);
18265 }
18266 if (p->error_indicator) {
18267 p->level--;
18268 return NULL;
18269 }
18270 asdl_expr_seq* _res = NULL;
18271 int _mark = p->mark;
18272 { // star_target ((',' star_target))+ ','?
18273 if (p->error_indicator) {
18274 p->level--;
18275 return NULL;
18276 }
18277 D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?"));
18278 void *_opt_var;
18279 UNUSED(_opt_var); // Silence compiler warnings
18280 expr_ty a;
18281 asdl_seq * b;
18282 if (
18283 (a = star_target_rule(p)) // star_target
18284 &&
18285 (b = _loop1_137_rule(p)) // ((',' star_target))+
18286 &&
18287 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
18288 )
18289 {
18290 D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?"));
18291 _res = ( asdl_expr_seq* ) _PyPegen_seq_insert_in_front ( p , a , b );
18292 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18293 p->error_indicator = 1;
18294 p->level--;
18295 return NULL;
18296 }
18297 goto done;
18298 }
18299 p->mark = _mark;
18300 D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ',
18301 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))+ ','?"));
18302 }
18303 { // star_target ','
18304 if (p->error_indicator) {
18305 p->level--;
18306 return NULL;
18307 }
18308 D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ','"));
18309 Token * _literal;
18310 expr_ty a;
18311 if (
18312 (a = star_target_rule(p)) // star_target
18313 &&
18314 (_literal = _PyPegen_expect_token(p, 12)) // token=','
18315 )
18316 {
18317 D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ','"));
18318 _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a );
18319 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18320 p->error_indicator = 1;
18321 p->level--;
18322 return NULL;
18323 }
18324 goto done;
18325 }
18326 p->mark = _mark;
18327 D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ',
18328 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ','"));
18329 }
18330 _res = NULL;
18331 done:
18332 p->level--;
18333 return _res;
18334 }
18335
18336 // star_target: '*' (!'*' star_target) | target_with_star_atom
18337 static expr_ty
18338 star_target_rule(Parser *p)
18339 {
18340 if (p->level++ == MAXSTACK) {
18341 _Pypegen_stack_overflow(p);
18342 }
18343 if (p->error_indicator) {
18344 p->level--;
18345 return NULL;
18346 }
18347 expr_ty _res = NULL;
18348 if (_PyPegen_is_memoized(p, star_target_type, &_res)) {
18349 p->level--;
18350 return _res;
18351 }
18352 int _mark = p->mark;
18353 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18354 p->error_indicator = 1;
18355 p->level--;
18356 return NULL;
18357 }
18358 int _start_lineno = p->tokens[_mark]->lineno;
18359 UNUSED(_start_lineno); // Only used by EXTRA macro
18360 int _start_col_offset = p->tokens[_mark]->col_offset;
18361 UNUSED(_start_col_offset); // Only used by EXTRA macro
18362 { // '*' (!'*' star_target)
18363 if (p->error_indicator) {
18364 p->level--;
18365 return NULL;
18366 }
18367 D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
18368 Token * _literal;
18369 void *a;
18370 if (
18371 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
18372 &&
18373 (a = _tmp_138_rule(p)) // !'*' star_target
18374 )
18375 {
18376 D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
18377 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18378 if (_token == NULL) {
18379 p->level--;
18380 return NULL;
18381 }
18382 int _end_lineno = _token->end_lineno;
18383 UNUSED(_end_lineno); // Only used by EXTRA macro
18384 int _end_col_offset = _token->end_col_offset;
18385 UNUSED(_end_col_offset); // Only used by EXTRA macro
18386 _res = _PyAST_Starred ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA );
18387 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18388 p->error_indicator = 1;
18389 p->level--;
18390 return NULL;
18391 }
18392 goto done;
18393 }
18394 p->mark = _mark;
18395 D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ',
18396 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (!'*' star_target)"));
18397 }
18398 { // target_with_star_atom
18399 if (p->error_indicator) {
18400 p->level--;
18401 return NULL;
18402 }
18403 D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "target_with_star_atom"));
18404 expr_ty target_with_star_atom_var;
18405 if (
18406 (target_with_star_atom_var = target_with_star_atom_rule(p)) // target_with_star_atom
18407 )
18408 {
18409 D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "target_with_star_atom"));
18410 _res = target_with_star_atom_var;
18411 goto done;
18412 }
18413 p->mark = _mark;
18414 D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ',
18415 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "target_with_star_atom"));
18416 }
18417 _res = NULL;
18418 done:
18419 _PyPegen_insert_memo(p, _mark, star_target_type, _res);
18420 p->level--;
18421 return _res;
18422 }
18423
18424 // target_with_star_atom:
18425 // | t_primary '.' NAME !t_lookahead
18426 // | t_primary '[' slices ']' !t_lookahead
18427 // | star_atom
18428 static expr_ty
18429 target_with_star_atom_rule(Parser *p)
18430 {
18431 if (p->level++ == MAXSTACK) {
18432 _Pypegen_stack_overflow(p);
18433 }
18434 if (p->error_indicator) {
18435 p->level--;
18436 return NULL;
18437 }
18438 expr_ty _res = NULL;
18439 if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) {
18440 p->level--;
18441 return _res;
18442 }
18443 int _mark = p->mark;
18444 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18445 p->error_indicator = 1;
18446 p->level--;
18447 return NULL;
18448 }
18449 int _start_lineno = p->tokens[_mark]->lineno;
18450 UNUSED(_start_lineno); // Only used by EXTRA macro
18451 int _start_col_offset = p->tokens[_mark]->col_offset;
18452 UNUSED(_start_col_offset); // Only used by EXTRA macro
18453 { // t_primary '.' NAME !t_lookahead
18454 if (p->error_indicator) {
18455 p->level--;
18456 return NULL;
18457 }
18458 D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
18459 Token * _literal;
18460 expr_ty a;
18461 expr_ty b;
18462 if (
18463 (a = t_primary_rule(p)) // t_primary
18464 &&
18465 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
18466 &&
18467 (b = _PyPegen_name_token(p)) // NAME
18468 &&
18469 _PyPegen_lookahead(0, t_lookahead_rule, p)
18470 )
18471 {
18472 D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
18473 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18474 if (_token == NULL) {
18475 p->level--;
18476 return NULL;
18477 }
18478 int _end_lineno = _token->end_lineno;
18479 UNUSED(_end_lineno); // Only used by EXTRA macro
18480 int _end_col_offset = _token->end_col_offset;
18481 UNUSED(_end_col_offset); // Only used by EXTRA macro
18482 _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA );
18483 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18484 p->error_indicator = 1;
18485 p->level--;
18486 return NULL;
18487 }
18488 goto done;
18489 }
18490 p->mark = _mark;
18491 D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',
18492 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
18493 }
18494 { // t_primary '[' slices ']' !t_lookahead
18495 if (p->error_indicator) {
18496 p->level--;
18497 return NULL;
18498 }
18499 D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
18500 Token * _literal;
18501 Token * _literal_1;
18502 expr_ty a;
18503 expr_ty b;
18504 if (
18505 (a = t_primary_rule(p)) // t_primary
18506 &&
18507 (_literal = _PyPegen_expect_token(p, 9)) // token='['
18508 &&
18509 (b = slices_rule(p)) // slices
18510 &&
18511 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
18512 &&
18513 _PyPegen_lookahead(0, t_lookahead_rule, p)
18514 )
18515 {
18516 D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
18517 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18518 if (_token == NULL) {
18519 p->level--;
18520 return NULL;
18521 }
18522 int _end_lineno = _token->end_lineno;
18523 UNUSED(_end_lineno); // Only used by EXTRA macro
18524 int _end_col_offset = _token->end_col_offset;
18525 UNUSED(_end_col_offset); // Only used by EXTRA macro
18526 _res = _PyAST_Subscript ( a , b , Store , EXTRA );
18527 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18528 p->error_indicator = 1;
18529 p->level--;
18530 return NULL;
18531 }
18532 goto done;
18533 }
18534 p->mark = _mark;
18535 D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',
18536 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
18537 }
18538 { // star_atom
18539 if (p->error_indicator) {
18540 p->level--;
18541 return NULL;
18542 }
18543 D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_atom"));
18544 expr_ty star_atom_var;
18545 if (
18546 (star_atom_var = star_atom_rule(p)) // star_atom
18547 )
18548 {
18549 D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_atom"));
18550 _res = star_atom_var;
18551 goto done;
18552 }
18553 p->mark = _mark;
18554 D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',
18555 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_atom"));
18556 }
18557 _res = NULL;
18558 done:
18559 _PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res);
18560 p->level--;
18561 return _res;
18562 }
18563
18564 // star_atom:
18565 // | NAME
18566 // | '(' target_with_star_atom ')'
18567 // | '(' star_targets_tuple_seq? ')'
18568 // | '[' star_targets_list_seq? ']'
18569 static expr_ty
18570 star_atom_rule(Parser *p)
18571 {
18572 if (p->level++ == MAXSTACK) {
18573 _Pypegen_stack_overflow(p);
18574 }
18575 if (p->error_indicator) {
18576 p->level--;
18577 return NULL;
18578 }
18579 expr_ty _res = NULL;
18580 int _mark = p->mark;
18581 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18582 p->error_indicator = 1;
18583 p->level--;
18584 return NULL;
18585 }
18586 int _start_lineno = p->tokens[_mark]->lineno;
18587 UNUSED(_start_lineno); // Only used by EXTRA macro
18588 int _start_col_offset = p->tokens[_mark]->col_offset;
18589 UNUSED(_start_col_offset); // Only used by EXTRA macro
18590 { // NAME
18591 if (p->error_indicator) {
18592 p->level--;
18593 return NULL;
18594 }
18595 D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
18596 expr_ty a;
18597 if (
18598 (a = _PyPegen_name_token(p)) // NAME
18599 )
18600 {
18601 D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
18602 _res = _PyPegen_set_expr_context ( p , a , Store );
18603 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18604 p->error_indicator = 1;
18605 p->level--;
18606 return NULL;
18607 }
18608 goto done;
18609 }
18610 p->mark = _mark;
18611 D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',
18612 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
18613 }
18614 { // '(' target_with_star_atom ')'
18615 if (p->error_indicator) {
18616 p->level--;
18617 return NULL;
18618 }
18619 D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'"));
18620 Token * _literal;
18621 Token * _literal_1;
18622 expr_ty a;
18623 if (
18624 (_literal = _PyPegen_expect_token(p, 7)) // token='('
18625 &&
18626 (a = target_with_star_atom_rule(p)) // target_with_star_atom
18627 &&
18628 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
18629 )
18630 {
18631 D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'"));
18632 _res = _PyPegen_set_expr_context ( p , a , Store );
18633 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18634 p->error_indicator = 1;
18635 p->level--;
18636 return NULL;
18637 }
18638 goto done;
18639 }
18640 p->mark = _mark;
18641 D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',
18642 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' target_with_star_atom ')'"));
18643 }
18644 { // '(' star_targets_tuple_seq? ')'
18645 if (p->error_indicator) {
18646 p->level--;
18647 return NULL;
18648 }
18649 D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
18650 Token * _literal;
18651 Token * _literal_1;
18652 void *a;
18653 if (
18654 (_literal = _PyPegen_expect_token(p, 7)) // token='('
18655 &&
18656 (a = star_targets_tuple_seq_rule(p), !p->error_indicator) // star_targets_tuple_seq?
18657 &&
18658 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
18659 )
18660 {
18661 D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
18662 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18663 if (_token == NULL) {
18664 p->level--;
18665 return NULL;
18666 }
18667 int _end_lineno = _token->end_lineno;
18668 UNUSED(_end_lineno); // Only used by EXTRA macro
18669 int _end_col_offset = _token->end_col_offset;
18670 UNUSED(_end_col_offset); // Only used by EXTRA macro
18671 _res = _PyAST_Tuple ( a , Store , EXTRA );
18672 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18673 p->error_indicator = 1;
18674 p->level--;
18675 return NULL;
18676 }
18677 goto done;
18678 }
18679 p->mark = _mark;
18680 D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',
18681 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
18682 }
18683 { // '[' star_targets_list_seq? ']'
18684 if (p->error_indicator) {
18685 p->level--;
18686 return NULL;
18687 }
18688 D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'"));
18689 Token * _literal;
18690 Token * _literal_1;
18691 void *a;
18692 if (
18693 (_literal = _PyPegen_expect_token(p, 9)) // token='['
18694 &&
18695 (a = star_targets_list_seq_rule(p), !p->error_indicator) // star_targets_list_seq?
18696 &&
18697 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
18698 )
18699 {
18700 D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'"));
18701 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18702 if (_token == NULL) {
18703 p->level--;
18704 return NULL;
18705 }
18706 int _end_lineno = _token->end_lineno;
18707 UNUSED(_end_lineno); // Only used by EXTRA macro
18708 int _end_col_offset = _token->end_col_offset;
18709 UNUSED(_end_col_offset); // Only used by EXTRA macro
18710 _res = _PyAST_List ( a , Store , EXTRA );
18711 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18712 p->error_indicator = 1;
18713 p->level--;
18714 return NULL;
18715 }
18716 goto done;
18717 }
18718 p->mark = _mark;
18719 D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',
18720 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_targets_list_seq? ']'"));
18721 }
18722 _res = NULL;
18723 done:
18724 p->level--;
18725 return _res;
18726 }
18727
18728 // single_target: single_subscript_attribute_target | NAME | '(' single_target ')'
18729 static expr_ty
18730 single_target_rule(Parser *p)
18731 {
18732 if (p->level++ == MAXSTACK) {
18733 _Pypegen_stack_overflow(p);
18734 }
18735 if (p->error_indicator) {
18736 p->level--;
18737 return NULL;
18738 }
18739 expr_ty _res = NULL;
18740 int _mark = p->mark;
18741 { // single_subscript_attribute_target
18742 if (p->error_indicator) {
18743 p->level--;
18744 return NULL;
18745 }
18746 D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
18747 expr_ty single_subscript_attribute_target_var;
18748 if (
18749 (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target
18750 )
18751 {
18752 D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
18753 _res = single_subscript_attribute_target_var;
18754 goto done;
18755 }
18756 p->mark = _mark;
18757 D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',
18758 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target"));
18759 }
18760 { // NAME
18761 if (p->error_indicator) {
18762 p->level--;
18763 return NULL;
18764 }
18765 D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
18766 expr_ty a;
18767 if (
18768 (a = _PyPegen_name_token(p)) // NAME
18769 )
18770 {
18771 D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
18772 _res = _PyPegen_set_expr_context ( p , a , Store );
18773 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18774 p->error_indicator = 1;
18775 p->level--;
18776 return NULL;
18777 }
18778 goto done;
18779 }
18780 p->mark = _mark;
18781 D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',
18782 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
18783 }
18784 { // '(' single_target ')'
18785 if (p->error_indicator) {
18786 p->level--;
18787 return NULL;
18788 }
18789 D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
18790 Token * _literal;
18791 Token * _literal_1;
18792 expr_ty a;
18793 if (
18794 (_literal = _PyPegen_expect_token(p, 7)) // token='('
18795 &&
18796 (a = single_target_rule(p)) // single_target
18797 &&
18798 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
18799 )
18800 {
18801 D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
18802 _res = a;
18803 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18804 p->error_indicator = 1;
18805 p->level--;
18806 return NULL;
18807 }
18808 goto done;
18809 }
18810 p->mark = _mark;
18811 D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',
18812 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'"));
18813 }
18814 _res = NULL;
18815 done:
18816 p->level--;
18817 return _res;
18818 }
18819
18820 // single_subscript_attribute_target:
18821 // | t_primary '.' NAME !t_lookahead
18822 // | t_primary '[' slices ']' !t_lookahead
18823 static expr_ty
18824 single_subscript_attribute_target_rule(Parser *p)
18825 {
18826 if (p->level++ == MAXSTACK) {
18827 _Pypegen_stack_overflow(p);
18828 }
18829 if (p->error_indicator) {
18830 p->level--;
18831 return NULL;
18832 }
18833 expr_ty _res = NULL;
18834 int _mark = p->mark;
18835 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18836 p->error_indicator = 1;
18837 p->level--;
18838 return NULL;
18839 }
18840 int _start_lineno = p->tokens[_mark]->lineno;
18841 UNUSED(_start_lineno); // Only used by EXTRA macro
18842 int _start_col_offset = p->tokens[_mark]->col_offset;
18843 UNUSED(_start_col_offset); // Only used by EXTRA macro
18844 { // t_primary '.' NAME !t_lookahead
18845 if (p->error_indicator) {
18846 p->level--;
18847 return NULL;
18848 }
18849 D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
18850 Token * _literal;
18851 expr_ty a;
18852 expr_ty b;
18853 if (
18854 (a = t_primary_rule(p)) // t_primary
18855 &&
18856 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
18857 &&
18858 (b = _PyPegen_name_token(p)) // NAME
18859 &&
18860 _PyPegen_lookahead(0, t_lookahead_rule, p)
18861 )
18862 {
18863 D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
18864 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18865 if (_token == NULL) {
18866 p->level--;
18867 return NULL;
18868 }
18869 int _end_lineno = _token->end_lineno;
18870 UNUSED(_end_lineno); // Only used by EXTRA macro
18871 int _end_col_offset = _token->end_col_offset;
18872 UNUSED(_end_col_offset); // Only used by EXTRA macro
18873 _res = _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA );
18874 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18875 p->error_indicator = 1;
18876 p->level--;
18877 return NULL;
18878 }
18879 goto done;
18880 }
18881 p->mark = _mark;
18882 D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ',
18883 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
18884 }
18885 { // t_primary '[' slices ']' !t_lookahead
18886 if (p->error_indicator) {
18887 p->level--;
18888 return NULL;
18889 }
18890 D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
18891 Token * _literal;
18892 Token * _literal_1;
18893 expr_ty a;
18894 expr_ty b;
18895 if (
18896 (a = t_primary_rule(p)) // t_primary
18897 &&
18898 (_literal = _PyPegen_expect_token(p, 9)) // token='['
18899 &&
18900 (b = slices_rule(p)) // slices
18901 &&
18902 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
18903 &&
18904 _PyPegen_lookahead(0, t_lookahead_rule, p)
18905 )
18906 {
18907 D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
18908 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
18909 if (_token == NULL) {
18910 p->level--;
18911 return NULL;
18912 }
18913 int _end_lineno = _token->end_lineno;
18914 UNUSED(_end_lineno); // Only used by EXTRA macro
18915 int _end_col_offset = _token->end_col_offset;
18916 UNUSED(_end_col_offset); // Only used by EXTRA macro
18917 _res = _PyAST_Subscript ( a , b , Store , EXTRA );
18918 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
18919 p->error_indicator = 1;
18920 p->level--;
18921 return NULL;
18922 }
18923 goto done;
18924 }
18925 p->mark = _mark;
18926 D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ',
18927 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
18928 }
18929 _res = NULL;
18930 done:
18931 p->level--;
18932 return _res;
18933 }
18934
18935 // Left-recursive
18936 // t_primary:
18937 // | t_primary '.' NAME &t_lookahead
18938 // | t_primary '[' slices ']' &t_lookahead
18939 // | t_primary genexp &t_lookahead
18940 // | t_primary '(' arguments? ')' &t_lookahead
18941 // | atom &t_lookahead
18942 static expr_ty t_primary_raw(Parser *);
18943 static expr_ty
18944 t_primary_rule(Parser *p)
18945 {
18946 if (p->level++ == MAXSTACK) {
18947 _Pypegen_stack_overflow(p);
18948 }
18949 expr_ty _res = NULL;
18950 if (_PyPegen_is_memoized(p, t_primary_type, &_res)) {
18951 p->level--;
18952 return _res;
18953 }
18954 int _mark = p->mark;
18955 int _resmark = p->mark;
18956 while (1) {
18957 int tmpvar_9 = _PyPegen_update_memo(p, _mark, t_primary_type, _res);
18958 if (tmpvar_9) {
18959 p->level--;
18960 return _res;
18961 }
18962 p->mark = _mark;
18963 void *_raw = t_primary_raw(p);
18964 if (p->error_indicator) {
18965 p->level--;
18966 return NULL;
18967 }
18968 if (_raw == NULL || p->mark <= _resmark)
18969 break;
18970 _resmark = p->mark;
18971 _res = _raw;
18972 }
18973 p->mark = _resmark;
18974 p->level--;
18975 return _res;
18976 }
18977 static expr_ty
18978 t_primary_raw(Parser *p)
18979 {
18980 if (p->level++ == MAXSTACK) {
18981 _Pypegen_stack_overflow(p);
18982 }
18983 if (p->error_indicator) {
18984 p->level--;
18985 return NULL;
18986 }
18987 expr_ty _res = NULL;
18988 int _mark = p->mark;
18989 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
18990 p->error_indicator = 1;
18991 p->level--;
18992 return NULL;
18993 }
18994 int _start_lineno = p->tokens[_mark]->lineno;
18995 UNUSED(_start_lineno); // Only used by EXTRA macro
18996 int _start_col_offset = p->tokens[_mark]->col_offset;
18997 UNUSED(_start_col_offset); // Only used by EXTRA macro
18998 { // t_primary '.' NAME &t_lookahead
18999 if (p->error_indicator) {
19000 p->level--;
19001 return NULL;
19002 }
19003 D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
19004 Token * _literal;
19005 expr_ty a;
19006 expr_ty b;
19007 if (
19008 (a = t_primary_rule(p)) // t_primary
19009 &&
19010 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
19011 &&
19012 (b = _PyPegen_name_token(p)) // NAME
19013 &&
19014 _PyPegen_lookahead(1, t_lookahead_rule, p)
19015 )
19016 {
19017 D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
19018 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19019 if (_token == NULL) {
19020 p->level--;
19021 return NULL;
19022 }
19023 int _end_lineno = _token->end_lineno;
19024 UNUSED(_end_lineno); // Only used by EXTRA macro
19025 int _end_col_offset = _token->end_col_offset;
19026 UNUSED(_end_col_offset); // Only used by EXTRA macro
19027 _res = _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA );
19028 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19029 p->error_indicator = 1;
19030 p->level--;
19031 return NULL;
19032 }
19033 goto done;
19034 }
19035 p->mark = _mark;
19036 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
19037 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
19038 }
19039 { // t_primary '[' slices ']' &t_lookahead
19040 if (p->error_indicator) {
19041 p->level--;
19042 return NULL;
19043 }
19044 D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
19045 Token * _literal;
19046 Token * _literal_1;
19047 expr_ty a;
19048 expr_ty b;
19049 if (
19050 (a = t_primary_rule(p)) // t_primary
19051 &&
19052 (_literal = _PyPegen_expect_token(p, 9)) // token='['
19053 &&
19054 (b = slices_rule(p)) // slices
19055 &&
19056 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
19057 &&
19058 _PyPegen_lookahead(1, t_lookahead_rule, p)
19059 )
19060 {
19061 D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
19062 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19063 if (_token == NULL) {
19064 p->level--;
19065 return NULL;
19066 }
19067 int _end_lineno = _token->end_lineno;
19068 UNUSED(_end_lineno); // Only used by EXTRA macro
19069 int _end_col_offset = _token->end_col_offset;
19070 UNUSED(_end_col_offset); // Only used by EXTRA macro
19071 _res = _PyAST_Subscript ( a , b , Load , EXTRA );
19072 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19073 p->error_indicator = 1;
19074 p->level--;
19075 return NULL;
19076 }
19077 goto done;
19078 }
19079 p->mark = _mark;
19080 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
19081 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
19082 }
19083 { // t_primary genexp &t_lookahead
19084 if (p->error_indicator) {
19085 p->level--;
19086 return NULL;
19087 }
19088 D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead"));
19089 expr_ty a;
19090 expr_ty b;
19091 if (
19092 (a = t_primary_rule(p)) // t_primary
19093 &&
19094 (b = genexp_rule(p)) // genexp
19095 &&
19096 _PyPegen_lookahead(1, t_lookahead_rule, p)
19097 )
19098 {
19099 D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead"));
19100 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19101 if (_token == NULL) {
19102 p->level--;
19103 return NULL;
19104 }
19105 int _end_lineno = _token->end_lineno;
19106 UNUSED(_end_lineno); // Only used by EXTRA macro
19107 int _end_col_offset = _token->end_col_offset;
19108 UNUSED(_end_col_offset); // Only used by EXTRA macro
19109 _res = _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
19110 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19111 p->error_indicator = 1;
19112 p->level--;
19113 return NULL;
19114 }
19115 goto done;
19116 }
19117 p->mark = _mark;
19118 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
19119 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary genexp &t_lookahead"));
19120 }
19121 { // t_primary '(' arguments? ')' &t_lookahead
19122 if (p->error_indicator) {
19123 p->level--;
19124 return NULL;
19125 }
19126 D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
19127 Token * _literal;
19128 Token * _literal_1;
19129 expr_ty a;
19130 void *b;
19131 if (
19132 (a = t_primary_rule(p)) // t_primary
19133 &&
19134 (_literal = _PyPegen_expect_token(p, 7)) // token='('
19135 &&
19136 (b = arguments_rule(p), !p->error_indicator) // arguments?
19137 &&
19138 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
19139 &&
19140 _PyPegen_lookahead(1, t_lookahead_rule, p)
19141 )
19142 {
19143 D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
19144 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19145 if (_token == NULL) {
19146 p->level--;
19147 return NULL;
19148 }
19149 int _end_lineno = _token->end_lineno;
19150 UNUSED(_end_lineno); // Only used by EXTRA macro
19151 int _end_col_offset = _token->end_col_offset;
19152 UNUSED(_end_col_offset); // Only used by EXTRA macro
19153 _res = _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
19154 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19155 p->error_indicator = 1;
19156 p->level--;
19157 return NULL;
19158 }
19159 goto done;
19160 }
19161 p->mark = _mark;
19162 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
19163 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
19164 }
19165 { // atom &t_lookahead
19166 if (p->error_indicator) {
19167 p->level--;
19168 return NULL;
19169 }
19170 D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead"));
19171 expr_ty a;
19172 if (
19173 (a = atom_rule(p)) // atom
19174 &&
19175 _PyPegen_lookahead(1, t_lookahead_rule, p)
19176 )
19177 {
19178 D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead"));
19179 _res = a;
19180 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19181 p->error_indicator = 1;
19182 p->level--;
19183 return NULL;
19184 }
19185 goto done;
19186 }
19187 p->mark = _mark;
19188 D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
19189 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom &t_lookahead"));
19190 }
19191 _res = NULL;
19192 done:
19193 p->level--;
19194 return _res;
19195 }
19196
19197 // t_lookahead: '(' | '[' | '.'
19198 static void *
19199 t_lookahead_rule(Parser *p)
19200 {
19201 if (p->level++ == MAXSTACK) {
19202 _Pypegen_stack_overflow(p);
19203 }
19204 if (p->error_indicator) {
19205 p->level--;
19206 return NULL;
19207 }
19208 void * _res = NULL;
19209 int _mark = p->mark;
19210 { // '('
19211 if (p->error_indicator) {
19212 p->level--;
19213 return NULL;
19214 }
19215 D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
19216 Token * _literal;
19217 if (
19218 (_literal = _PyPegen_expect_token(p, 7)) // token='('
19219 )
19220 {
19221 D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
19222 _res = _literal;
19223 goto done;
19224 }
19225 p->mark = _mark;
19226 D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',
19227 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));
19228 }
19229 { // '['
19230 if (p->error_indicator) {
19231 p->level--;
19232 return NULL;
19233 }
19234 D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
19235 Token * _literal;
19236 if (
19237 (_literal = _PyPegen_expect_token(p, 9)) // token='['
19238 )
19239 {
19240 D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
19241 _res = _literal;
19242 goto done;
19243 }
19244 p->mark = _mark;
19245 D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',
19246 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));
19247 }
19248 { // '.'
19249 if (p->error_indicator) {
19250 p->level--;
19251 return NULL;
19252 }
19253 D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
19254 Token * _literal;
19255 if (
19256 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
19257 )
19258 {
19259 D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
19260 _res = _literal;
19261 goto done;
19262 }
19263 p->mark = _mark;
19264 D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',
19265 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
19266 }
19267 _res = NULL;
19268 done:
19269 p->level--;
19270 return _res;
19271 }
19272
19273 // del_targets: ','.del_target+ ','?
19274 static asdl_expr_seq*
19275 del_targets_rule(Parser *p)
19276 {
19277 if (p->level++ == MAXSTACK) {
19278 _Pypegen_stack_overflow(p);
19279 }
19280 if (p->error_indicator) {
19281 p->level--;
19282 return NULL;
19283 }
19284 asdl_expr_seq* _res = NULL;
19285 int _mark = p->mark;
19286 { // ','.del_target+ ','?
19287 if (p->error_indicator) {
19288 p->level--;
19289 return NULL;
19290 }
19291 D(fprintf(stderr, "%*c> del_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?"));
19292 void *_opt_var;
19293 UNUSED(_opt_var); // Silence compiler warnings
19294 asdl_expr_seq* a;
19295 if (
19296 (a = (asdl_expr_seq*)_gather_139_rule(p)) // ','.del_target+
19297 &&
19298 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
19299 )
19300 {
19301 D(fprintf(stderr, "%*c+ del_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?"));
19302 _res = a;
19303 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19304 p->error_indicator = 1;
19305 p->level--;
19306 return NULL;
19307 }
19308 goto done;
19309 }
19310 p->mark = _mark;
19311 D(fprintf(stderr, "%*c%s del_targets[%d-%d]: %s failed!\n", p->level, ' ',
19312 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.del_target+ ','?"));
19313 }
19314 _res = NULL;
19315 done:
19316 p->level--;
19317 return _res;
19318 }
19319
19320 // del_target:
19321 // | t_primary '.' NAME !t_lookahead
19322 // | t_primary '[' slices ']' !t_lookahead
19323 // | del_t_atom
19324 static expr_ty
19325 del_target_rule(Parser *p)
19326 {
19327 if (p->level++ == MAXSTACK) {
19328 _Pypegen_stack_overflow(p);
19329 }
19330 if (p->error_indicator) {
19331 p->level--;
19332 return NULL;
19333 }
19334 expr_ty _res = NULL;
19335 if (_PyPegen_is_memoized(p, del_target_type, &_res)) {
19336 p->level--;
19337 return _res;
19338 }
19339 int _mark = p->mark;
19340 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
19341 p->error_indicator = 1;
19342 p->level--;
19343 return NULL;
19344 }
19345 int _start_lineno = p->tokens[_mark]->lineno;
19346 UNUSED(_start_lineno); // Only used by EXTRA macro
19347 int _start_col_offset = p->tokens[_mark]->col_offset;
19348 UNUSED(_start_col_offset); // Only used by EXTRA macro
19349 { // t_primary '.' NAME !t_lookahead
19350 if (p->error_indicator) {
19351 p->level--;
19352 return NULL;
19353 }
19354 D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
19355 Token * _literal;
19356 expr_ty a;
19357 expr_ty b;
19358 if (
19359 (a = t_primary_rule(p)) // t_primary
19360 &&
19361 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
19362 &&
19363 (b = _PyPegen_name_token(p)) // NAME
19364 &&
19365 _PyPegen_lookahead(0, t_lookahead_rule, p)
19366 )
19367 {
19368 D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
19369 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19370 if (_token == NULL) {
19371 p->level--;
19372 return NULL;
19373 }
19374 int _end_lineno = _token->end_lineno;
19375 UNUSED(_end_lineno); // Only used by EXTRA macro
19376 int _end_col_offset = _token->end_col_offset;
19377 UNUSED(_end_col_offset); // Only used by EXTRA macro
19378 _res = _PyAST_Attribute ( a , b -> v . Name . id , Del , EXTRA );
19379 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19380 p->error_indicator = 1;
19381 p->level--;
19382 return NULL;
19383 }
19384 goto done;
19385 }
19386 p->mark = _mark;
19387 D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',
19388 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
19389 }
19390 { // t_primary '[' slices ']' !t_lookahead
19391 if (p->error_indicator) {
19392 p->level--;
19393 return NULL;
19394 }
19395 D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
19396 Token * _literal;
19397 Token * _literal_1;
19398 expr_ty a;
19399 expr_ty b;
19400 if (
19401 (a = t_primary_rule(p)) // t_primary
19402 &&
19403 (_literal = _PyPegen_expect_token(p, 9)) // token='['
19404 &&
19405 (b = slices_rule(p)) // slices
19406 &&
19407 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
19408 &&
19409 _PyPegen_lookahead(0, t_lookahead_rule, p)
19410 )
19411 {
19412 D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
19413 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19414 if (_token == NULL) {
19415 p->level--;
19416 return NULL;
19417 }
19418 int _end_lineno = _token->end_lineno;
19419 UNUSED(_end_lineno); // Only used by EXTRA macro
19420 int _end_col_offset = _token->end_col_offset;
19421 UNUSED(_end_col_offset); // Only used by EXTRA macro
19422 _res = _PyAST_Subscript ( a , b , Del , EXTRA );
19423 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19424 p->error_indicator = 1;
19425 p->level--;
19426 return NULL;
19427 }
19428 goto done;
19429 }
19430 p->mark = _mark;
19431 D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',
19432 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
19433 }
19434 { // del_t_atom
19435 if (p->error_indicator) {
19436 p->level--;
19437 return NULL;
19438 }
19439 D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_t_atom"));
19440 expr_ty del_t_atom_var;
19441 if (
19442 (del_t_atom_var = del_t_atom_rule(p)) // del_t_atom
19443 )
19444 {
19445 D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_t_atom"));
19446 _res = del_t_atom_var;
19447 goto done;
19448 }
19449 p->mark = _mark;
19450 D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',
19451 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_t_atom"));
19452 }
19453 _res = NULL;
19454 done:
19455 _PyPegen_insert_memo(p, _mark, del_target_type, _res);
19456 p->level--;
19457 return _res;
19458 }
19459
19460 // del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']'
19461 static expr_ty
19462 del_t_atom_rule(Parser *p)
19463 {
19464 if (p->level++ == MAXSTACK) {
19465 _Pypegen_stack_overflow(p);
19466 }
19467 if (p->error_indicator) {
19468 p->level--;
19469 return NULL;
19470 }
19471 expr_ty _res = NULL;
19472 int _mark = p->mark;
19473 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
19474 p->error_indicator = 1;
19475 p->level--;
19476 return NULL;
19477 }
19478 int _start_lineno = p->tokens[_mark]->lineno;
19479 UNUSED(_start_lineno); // Only used by EXTRA macro
19480 int _start_col_offset = p->tokens[_mark]->col_offset;
19481 UNUSED(_start_col_offset); // Only used by EXTRA macro
19482 { // NAME
19483 if (p->error_indicator) {
19484 p->level--;
19485 return NULL;
19486 }
19487 D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
19488 expr_ty a;
19489 if (
19490 (a = _PyPegen_name_token(p)) // NAME
19491 )
19492 {
19493 D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
19494 _res = _PyPegen_set_expr_context ( p , a , Del );
19495 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19496 p->error_indicator = 1;
19497 p->level--;
19498 return NULL;
19499 }
19500 goto done;
19501 }
19502 p->mark = _mark;
19503 D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',
19504 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
19505 }
19506 { // '(' del_target ')'
19507 if (p->error_indicator) {
19508 p->level--;
19509 return NULL;
19510 }
19511 D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'"));
19512 Token * _literal;
19513 Token * _literal_1;
19514 expr_ty a;
19515 if (
19516 (_literal = _PyPegen_expect_token(p, 7)) // token='('
19517 &&
19518 (a = del_target_rule(p)) // del_target
19519 &&
19520 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
19521 )
19522 {
19523 D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'"));
19524 _res = _PyPegen_set_expr_context ( p , a , Del );
19525 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19526 p->error_indicator = 1;
19527 p->level--;
19528 return NULL;
19529 }
19530 goto done;
19531 }
19532 p->mark = _mark;
19533 D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',
19534 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_target ')'"));
19535 }
19536 { // '(' del_targets? ')'
19537 if (p->error_indicator) {
19538 p->level--;
19539 return NULL;
19540 }
19541 D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'"));
19542 Token * _literal;
19543 Token * _literal_1;
19544 void *a;
19545 if (
19546 (_literal = _PyPegen_expect_token(p, 7)) // token='('
19547 &&
19548 (a = del_targets_rule(p), !p->error_indicator) // del_targets?
19549 &&
19550 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
19551 )
19552 {
19553 D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'"));
19554 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19555 if (_token == NULL) {
19556 p->level--;
19557 return NULL;
19558 }
19559 int _end_lineno = _token->end_lineno;
19560 UNUSED(_end_lineno); // Only used by EXTRA macro
19561 int _end_col_offset = _token->end_col_offset;
19562 UNUSED(_end_col_offset); // Only used by EXTRA macro
19563 _res = _PyAST_Tuple ( a , Del , EXTRA );
19564 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19565 p->error_indicator = 1;
19566 p->level--;
19567 return NULL;
19568 }
19569 goto done;
19570 }
19571 p->mark = _mark;
19572 D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',
19573 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_targets? ')'"));
19574 }
19575 { // '[' del_targets? ']'
19576 if (p->error_indicator) {
19577 p->level--;
19578 return NULL;
19579 }
19580 D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'"));
19581 Token * _literal;
19582 Token * _literal_1;
19583 void *a;
19584 if (
19585 (_literal = _PyPegen_expect_token(p, 9)) // token='['
19586 &&
19587 (a = del_targets_rule(p), !p->error_indicator) // del_targets?
19588 &&
19589 (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']'
19590 )
19591 {
19592 D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'"));
19593 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
19594 if (_token == NULL) {
19595 p->level--;
19596 return NULL;
19597 }
19598 int _end_lineno = _token->end_lineno;
19599 UNUSED(_end_lineno); // Only used by EXTRA macro
19600 int _end_col_offset = _token->end_col_offset;
19601 UNUSED(_end_col_offset); // Only used by EXTRA macro
19602 _res = _PyAST_List ( a , Del , EXTRA );
19603 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19604 p->error_indicator = 1;
19605 p->level--;
19606 return NULL;
19607 }
19608 goto done;
19609 }
19610 p->mark = _mark;
19611 D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',
19612 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' del_targets? ']'"));
19613 }
19614 _res = NULL;
19615 done:
19616 p->level--;
19617 return _res;
19618 }
19619
19620 // type_expressions:
19621 // | ','.expression+ ',' '*' expression ',' '**' expression
19622 // | ','.expression+ ',' '*' expression
19623 // | ','.expression+ ',' '**' expression
19624 // | '*' expression ',' '**' expression
19625 // | '*' expression
19626 // | '**' expression
19627 // | ','.expression+
19628 static asdl_expr_seq*
19629 type_expressions_rule(Parser *p)
19630 {
19631 if (p->level++ == MAXSTACK) {
19632 _Pypegen_stack_overflow(p);
19633 }
19634 if (p->error_indicator) {
19635 p->level--;
19636 return NULL;
19637 }
19638 asdl_expr_seq* _res = NULL;
19639 int _mark = p->mark;
19640 { // ','.expression+ ',' '*' expression ',' '**' expression
19641 if (p->error_indicator) {
19642 p->level--;
19643 return NULL;
19644 }
19645 D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
19646 Token * _literal;
19647 Token * _literal_1;
19648 Token * _literal_2;
19649 Token * _literal_3;
19650 asdl_seq * a;
19651 expr_ty b;
19652 expr_ty c;
19653 if (
19654 (a = _gather_141_rule(p)) // ','.expression+
19655 &&
19656 (_literal = _PyPegen_expect_token(p, 12)) // token=','
19657 &&
19658 (_literal_1 = _PyPegen_expect_token(p, 16)) // token='*'
19659 &&
19660 (b = expression_rule(p)) // expression
19661 &&
19662 (_literal_2 = _PyPegen_expect_token(p, 12)) // token=','
19663 &&
19664 (_literal_3 = _PyPegen_expect_token(p, 35)) // token='**'
19665 &&
19666 (c = expression_rule(p)) // expression
19667 )
19668 {
19669 D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
19670 _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_seq_append_to_end ( p , a , b ) ) , c );
19671 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19672 p->error_indicator = 1;
19673 p->level--;
19674 return NULL;
19675 }
19676 goto done;
19677 }
19678 p->mark = _mark;
19679 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
19680 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
19681 }
19682 { // ','.expression+ ',' '*' expression
19683 if (p->error_indicator) {
19684 p->level--;
19685 return NULL;
19686 }
19687 D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression"));
19688 Token * _literal;
19689 Token * _literal_1;
19690 asdl_seq * a;
19691 expr_ty b;
19692 if (
19693 (a = _gather_143_rule(p)) // ','.expression+
19694 &&
19695 (_literal = _PyPegen_expect_token(p, 12)) // token=','
19696 &&
19697 (_literal_1 = _PyPegen_expect_token(p, 16)) // token='*'
19698 &&
19699 (b = expression_rule(p)) // expression
19700 )
19701 {
19702 D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression"));
19703 _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b );
19704 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19705 p->error_indicator = 1;
19706 p->level--;
19707 return NULL;
19708 }
19709 goto done;
19710 }
19711 p->mark = _mark;
19712 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
19713 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression"));
19714 }
19715 { // ','.expression+ ',' '**' expression
19716 if (p->error_indicator) {
19717 p->level--;
19718 return NULL;
19719 }
19720 D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression"));
19721 Token * _literal;
19722 Token * _literal_1;
19723 asdl_seq * a;
19724 expr_ty b;
19725 if (
19726 (a = _gather_145_rule(p)) // ','.expression+
19727 &&
19728 (_literal = _PyPegen_expect_token(p, 12)) // token=','
19729 &&
19730 (_literal_1 = _PyPegen_expect_token(p, 35)) // token='**'
19731 &&
19732 (b = expression_rule(p)) // expression
19733 )
19734 {
19735 D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression"));
19736 _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b );
19737 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19738 p->error_indicator = 1;
19739 p->level--;
19740 return NULL;
19741 }
19742 goto done;
19743 }
19744 p->mark = _mark;
19745 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
19746 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '**' expression"));
19747 }
19748 { // '*' expression ',' '**' expression
19749 if (p->error_indicator) {
19750 p->level--;
19751 return NULL;
19752 }
19753 D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression"));
19754 Token * _literal;
19755 Token * _literal_1;
19756 Token * _literal_2;
19757 expr_ty a;
19758 expr_ty b;
19759 if (
19760 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
19761 &&
19762 (a = expression_rule(p)) // expression
19763 &&
19764 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
19765 &&
19766 (_literal_2 = _PyPegen_expect_token(p, 35)) // token='**'
19767 &&
19768 (b = expression_rule(p)) // expression
19769 )
19770 {
19771 D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression"));
19772 _res = ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_singleton_seq ( p , a ) ) , b );
19773 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19774 p->error_indicator = 1;
19775 p->level--;
19776 return NULL;
19777 }
19778 goto done;
19779 }
19780 p->mark = _mark;
19781 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
19782 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression ',' '**' expression"));
19783 }
19784 { // '*' expression
19785 if (p->error_indicator) {
19786 p->level--;
19787 return NULL;
19788 }
19789 D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression"));
19790 Token * _literal;
19791 expr_ty a;
19792 if (
19793 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
19794 &&
19795 (a = expression_rule(p)) // expression
19796 )
19797 {
19798 D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression"));
19799 _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a );
19800 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19801 p->error_indicator = 1;
19802 p->level--;
19803 return NULL;
19804 }
19805 goto done;
19806 }
19807 p->mark = _mark;
19808 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
19809 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression"));
19810 }
19811 { // '**' expression
19812 if (p->error_indicator) {
19813 p->level--;
19814 return NULL;
19815 }
19816 D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression"));
19817 Token * _literal;
19818 expr_ty a;
19819 if (
19820 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
19821 &&
19822 (a = expression_rule(p)) // expression
19823 )
19824 {
19825 D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression"));
19826 _res = ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a );
19827 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19828 p->error_indicator = 1;
19829 p->level--;
19830 return NULL;
19831 }
19832 goto done;
19833 }
19834 p->mark = _mark;
19835 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
19836 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression"));
19837 }
19838 { // ','.expression+
19839 if (p->error_indicator) {
19840 p->level--;
19841 return NULL;
19842 }
19843 D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+"));
19844 asdl_expr_seq* a;
19845 if (
19846 (a = (asdl_expr_seq*)_gather_147_rule(p)) // ','.expression+
19847 )
19848 {
19849 D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+"));
19850 _res = a;
19851 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19852 p->error_indicator = 1;
19853 p->level--;
19854 return NULL;
19855 }
19856 goto done;
19857 }
19858 p->mark = _mark;
19859 D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
19860 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+"));
19861 }
19862 _res = NULL;
19863 done:
19864 p->level--;
19865 return _res;
19866 }
19867
19868 // func_type_comment:
19869 // | NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
19870 // | invalid_double_type_comments
19871 // | TYPE_COMMENT
19872 static Token*
19873 func_type_comment_rule(Parser *p)
19874 {
19875 if (p->level++ == MAXSTACK) {
19876 _Pypegen_stack_overflow(p);
19877 }
19878 if (p->error_indicator) {
19879 p->level--;
19880 return NULL;
19881 }
19882 Token* _res = NULL;
19883 int _mark = p->mark;
19884 { // NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
19885 if (p->error_indicator) {
19886 p->level--;
19887 return NULL;
19888 }
19889 D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)"));
19890 Token * newline_var;
19891 Token * t;
19892 if (
19893 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
19894 &&
19895 (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
19896 &&
19897 _PyPegen_lookahead(1, _tmp_149_rule, p)
19898 )
19899 {
19900 D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)"));
19901 _res = t;
19902 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19903 p->error_indicator = 1;
19904 p->level--;
19905 return NULL;
19906 }
19907 goto done;
19908 }
19909 p->mark = _mark;
19910 D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',
19911 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)"));
19912 }
19913 if (p->call_invalid_rules) { // invalid_double_type_comments
19914 if (p->error_indicator) {
19915 p->level--;
19916 return NULL;
19917 }
19918 D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments"));
19919 void *invalid_double_type_comments_var;
19920 if (
19921 (invalid_double_type_comments_var = invalid_double_type_comments_rule(p)) // invalid_double_type_comments
19922 )
19923 {
19924 D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments"));
19925 _res = invalid_double_type_comments_var;
19926 goto done;
19927 }
19928 p->mark = _mark;
19929 D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',
19930 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_double_type_comments"));
19931 }
19932 { // TYPE_COMMENT
19933 if (p->error_indicator) {
19934 p->level--;
19935 return NULL;
19936 }
19937 D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT"));
19938 Token * type_comment_var;
19939 if (
19940 (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
19941 )
19942 {
19943 D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT"));
19944 _res = type_comment_var;
19945 goto done;
19946 }
19947 p->mark = _mark;
19948 D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',
19949 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT"));
19950 }
19951 _res = NULL;
19952 done:
19953 p->level--;
19954 return _res;
19955 }
19956
19957 // invalid_arguments:
19958 // | ((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+
19959 // | expression for_if_clauses ',' [args | expression for_if_clauses]
19960 // | NAME '=' expression for_if_clauses
19961 // | [(args ',')] NAME '=' &(',' | ')')
19962 // | args for_if_clauses
19963 // | args ',' expression for_if_clauses
19964 // | args ',' args
19965 static void *
19966 invalid_arguments_rule(Parser *p)
19967 {
19968 if (p->level++ == MAXSTACK) {
19969 _Pypegen_stack_overflow(p);
19970 }
19971 if (p->error_indicator) {
19972 p->level--;
19973 return NULL;
19974 }
19975 void * _res = NULL;
19976 int _mark = p->mark;
19977 { // ((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+
19978 if (p->error_indicator) {
19979 p->level--;
19980 return NULL;
19981 }
19982 D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+"));
19983 asdl_seq * _gather_151_var;
19984 void *_tmp_150_var;
19985 Token * a;
19986 if (
19987 (_tmp_150_var = _tmp_150_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs
19988 &&
19989 (a = _PyPegen_expect_token(p, 12)) // token=','
19990 &&
19991 (_gather_151_var = _gather_151_rule(p)) // ','.(starred_expression !'=')+
19992 )
19993 {
19994 D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+"));
19995 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "iterable argument unpacking follows keyword argument unpacking" );
19996 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
19997 p->error_indicator = 1;
19998 p->level--;
19999 return NULL;
20000 }
20001 goto done;
20002 }
20003 p->mark = _mark;
20004 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
20005 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+"));
20006 }
20007 { // expression for_if_clauses ',' [args | expression for_if_clauses]
20008 if (p->error_indicator) {
20009 p->level--;
20010 return NULL;
20011 }
20012 D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]"));
20013 Token * _literal;
20014 void *_opt_var;
20015 UNUSED(_opt_var); // Silence compiler warnings
20016 expr_ty a;
20017 asdl_comprehension_seq* b;
20018 if (
20019 (a = expression_rule(p)) // expression
20020 &&
20021 (b = for_if_clauses_rule(p)) // for_if_clauses
20022 &&
20023 (_literal = _PyPegen_expect_token(p, 12)) // token=','
20024 &&
20025 (_opt_var = _tmp_153_rule(p), !p->error_indicator) // [args | expression for_if_clauses]
20026 )
20027 {
20028 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]"));
20029 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" );
20030 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20031 p->error_indicator = 1;
20032 p->level--;
20033 return NULL;
20034 }
20035 goto done;
20036 }
20037 p->mark = _mark;
20038 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
20039 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]"));
20040 }
20041 { // NAME '=' expression for_if_clauses
20042 if (p->error_indicator) {
20043 p->level--;
20044 return NULL;
20045 }
20046 D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses"));
20047 expr_ty a;
20048 Token * b;
20049 expr_ty expression_var;
20050 asdl_comprehension_seq* for_if_clauses_var;
20051 if (
20052 (a = _PyPegen_name_token(p)) // NAME
20053 &&
20054 (b = _PyPegen_expect_token(p, 22)) // token='='
20055 &&
20056 (expression_var = expression_rule(p)) // expression
20057 &&
20058 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
20059 )
20060 {
20061 D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses"));
20062 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" );
20063 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20064 p->error_indicator = 1;
20065 p->level--;
20066 return NULL;
20067 }
20068 goto done;
20069 }
20070 p->mark = _mark;
20071 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
20072 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses"));
20073 }
20074 { // [(args ',')] NAME '=' &(',' | ')')
20075 if (p->error_indicator) {
20076 p->level--;
20077 return NULL;
20078 }
20079 D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')"));
20080 void *_opt_var;
20081 UNUSED(_opt_var); // Silence compiler warnings
20082 expr_ty a;
20083 Token * b;
20084 if (
20085 (_opt_var = _tmp_154_rule(p), !p->error_indicator) // [(args ',')]
20086 &&
20087 (a = _PyPegen_name_token(p)) // NAME
20088 &&
20089 (b = _PyPegen_expect_token(p, 22)) // token='='
20090 &&
20091 _PyPegen_lookahead(1, _tmp_155_rule, p)
20092 )
20093 {
20094 D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')"));
20095 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expected argument value expression" );
20096 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20097 p->error_indicator = 1;
20098 p->level--;
20099 return NULL;
20100 }
20101 goto done;
20102 }
20103 p->mark = _mark;
20104 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
20105 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')"));
20106 }
20107 { // args for_if_clauses
20108 if (p->error_indicator) {
20109 p->level--;
20110 return NULL;
20111 }
20112 D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args for_if_clauses"));
20113 expr_ty a;
20114 asdl_comprehension_seq* b;
20115 if (
20116 (a = args_rule(p)) // args
20117 &&
20118 (b = for_if_clauses_rule(p)) // for_if_clauses
20119 )
20120 {
20121 D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args for_if_clauses"));
20122 _res = _PyPegen_nonparen_genexp_in_call ( p , a , b );
20123 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20124 p->error_indicator = 1;
20125 p->level--;
20126 return NULL;
20127 }
20128 goto done;
20129 }
20130 p->mark = _mark;
20131 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
20132 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args for_if_clauses"));
20133 }
20134 { // args ',' expression for_if_clauses
20135 if (p->error_indicator) {
20136 p->level--;
20137 return NULL;
20138 }
20139 D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses"));
20140 Token * _literal;
20141 expr_ty a;
20142 expr_ty args_var;
20143 asdl_comprehension_seq* b;
20144 if (
20145 (args_var = args_rule(p)) // args
20146 &&
20147 (_literal = _PyPegen_expect_token(p, 12)) // token=','
20148 &&
20149 (a = expression_rule(p)) // expression
20150 &&
20151 (b = for_if_clauses_rule(p)) // for_if_clauses
20152 )
20153 {
20154 D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses"));
20155 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" );
20156 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20157 p->error_indicator = 1;
20158 p->level--;
20159 return NULL;
20160 }
20161 goto done;
20162 }
20163 p->mark = _mark;
20164 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
20165 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' expression for_if_clauses"));
20166 }
20167 { // args ',' args
20168 if (p->error_indicator) {
20169 p->level--;
20170 return NULL;
20171 }
20172 D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' args"));
20173 Token * _literal;
20174 expr_ty a;
20175 expr_ty args_var;
20176 if (
20177 (a = args_rule(p)) // args
20178 &&
20179 (_literal = _PyPegen_expect_token(p, 12)) // token=','
20180 &&
20181 (args_var = args_rule(p)) // args
20182 )
20183 {
20184 D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' args"));
20185 _res = _PyPegen_arguments_parsing_error ( p , a );
20186 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20187 p->error_indicator = 1;
20188 p->level--;
20189 return NULL;
20190 }
20191 goto done;
20192 }
20193 p->mark = _mark;
20194 D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
20195 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' args"));
20196 }
20197 _res = NULL;
20198 done:
20199 p->level--;
20200 return _res;
20201 }
20202
20203 // invalid_kwarg:
20204 // | ('True' | 'False' | 'None') '='
20205 // | NAME '=' expression for_if_clauses
20206 // | !(NAME '=') expression '='
20207 // | '**' expression '=' expression
20208 static void *
20209 invalid_kwarg_rule(Parser *p)
20210 {
20211 if (p->level++ == MAXSTACK) {
20212 _Pypegen_stack_overflow(p);
20213 }
20214 if (p->error_indicator) {
20215 p->level--;
20216 return NULL;
20217 }
20218 void * _res = NULL;
20219 int _mark = p->mark;
20220 { // ('True' | 'False' | 'None') '='
20221 if (p->error_indicator) {
20222 p->level--;
20223 return NULL;
20224 }
20225 D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('True' | 'False' | 'None') '='"));
20226 Token* a;
20227 Token * b;
20228 if (
20229 (a = (Token*)_tmp_156_rule(p)) // 'True' | 'False' | 'None'
20230 &&
20231 (b = _PyPegen_expect_token(p, 22)) // token='='
20232 )
20233 {
20234 D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('True' | 'False' | 'None') '='"));
20235 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to %s" , PyBytes_AS_STRING ( a -> bytes ) );
20236 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20237 p->error_indicator = 1;
20238 p->level--;
20239 return NULL;
20240 }
20241 goto done;
20242 }
20243 p->mark = _mark;
20244 D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
20245 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('True' | 'False' | 'None') '='"));
20246 }
20247 { // NAME '=' expression for_if_clauses
20248 if (p->error_indicator) {
20249 p->level--;
20250 return NULL;
20251 }
20252 D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses"));
20253 expr_ty a;
20254 Token * b;
20255 expr_ty expression_var;
20256 asdl_comprehension_seq* for_if_clauses_var;
20257 if (
20258 (a = _PyPegen_name_token(p)) // NAME
20259 &&
20260 (b = _PyPegen_expect_token(p, 22)) // token='='
20261 &&
20262 (expression_var = expression_rule(p)) // expression
20263 &&
20264 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
20265 )
20266 {
20267 D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression for_if_clauses"));
20268 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" );
20269 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20270 p->error_indicator = 1;
20271 p->level--;
20272 return NULL;
20273 }
20274 goto done;
20275 }
20276 p->mark = _mark;
20277 D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
20278 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses"));
20279 }
20280 { // !(NAME '=') expression '='
20281 if (p->error_indicator) {
20282 p->level--;
20283 return NULL;
20284 }
20285 D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='"));
20286 expr_ty a;
20287 Token * b;
20288 if (
20289 _PyPegen_lookahead(0, _tmp_157_rule, p)
20290 &&
20291 (a = expression_rule(p)) // expression
20292 &&
20293 (b = _PyPegen_expect_token(p, 22)) // token='='
20294 )
20295 {
20296 D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='"));
20297 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expression cannot contain assignment, perhaps you meant \"==\"?" );
20298 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20299 p->error_indicator = 1;
20300 p->level--;
20301 return NULL;
20302 }
20303 goto done;
20304 }
20305 p->mark = _mark;
20306 D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
20307 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='"));
20308 }
20309 { // '**' expression '=' expression
20310 if (p->error_indicator) {
20311 p->level--;
20312 return NULL;
20313 }
20314 D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression '=' expression"));
20315 Token * _literal;
20316 Token * a;
20317 expr_ty b;
20318 expr_ty expression_var;
20319 if (
20320 (a = _PyPegen_expect_token(p, 35)) // token='**'
20321 &&
20322 (expression_var = expression_rule(p)) // expression
20323 &&
20324 (_literal = _PyPegen_expect_token(p, 22)) // token='='
20325 &&
20326 (b = expression_rule(p)) // expression
20327 )
20328 {
20329 D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression '=' expression"));
20330 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to keyword argument unpacking" );
20331 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20332 p->error_indicator = 1;
20333 p->level--;
20334 return NULL;
20335 }
20336 goto done;
20337 }
20338 p->mark = _mark;
20339 D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
20340 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression '=' expression"));
20341 }
20342 _res = NULL;
20343 done:
20344 p->level--;
20345 return _res;
20346 }
20347
20348 // expression_without_invalid:
20349 // | disjunction 'if' disjunction 'else' expression
20350 // | disjunction
20351 // | lambdef
20352 static expr_ty
20353 expression_without_invalid_rule(Parser *p)
20354 {
20355 int _prev_call_invalid = p->call_invalid_rules;
20356 p->call_invalid_rules = 0;
20357 if (p->level++ == MAXSTACK) {
20358 _Pypegen_stack_overflow(p);
20359 }
20360 if (p->error_indicator) {
20361 p->call_invalid_rules = _prev_call_invalid;
20362 p->level--;
20363 return NULL;
20364 }
20365 expr_ty _res = NULL;
20366 int _mark = p->mark;
20367 if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
20368 p->error_indicator = 1;
20369 p->call_invalid_rules = _prev_call_invalid;
20370 p->level--;
20371 return NULL;
20372 }
20373 int _start_lineno = p->tokens[_mark]->lineno;
20374 UNUSED(_start_lineno); // Only used by EXTRA macro
20375 int _start_col_offset = p->tokens[_mark]->col_offset;
20376 UNUSED(_start_col_offset); // Only used by EXTRA macro
20377 { // disjunction 'if' disjunction 'else' expression
20378 if (p->error_indicator) {
20379 p->call_invalid_rules = _prev_call_invalid;
20380 p->level--;
20381 return NULL;
20382 }
20383 D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
20384 Token * _keyword;
20385 Token * _keyword_1;
20386 expr_ty a;
20387 expr_ty b;
20388 expr_ty c;
20389 if (
20390 (a = disjunction_rule(p)) // disjunction
20391 &&
20392 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
20393 &&
20394 (b = disjunction_rule(p)) // disjunction
20395 &&
20396 (_keyword_1 = _PyPegen_expect_token(p, 663)) // token='else'
20397 &&
20398 (c = expression_rule(p)) // expression
20399 )
20400 {
20401 D(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
20402 Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
20403 if (_token == NULL) {
20404 p->call_invalid_rules = _prev_call_invalid;
20405 p->level--;
20406 return NULL;
20407 }
20408 int _end_lineno = _token->end_lineno;
20409 UNUSED(_end_lineno); // Only used by EXTRA macro
20410 int _end_col_offset = _token->end_col_offset;
20411 UNUSED(_end_col_offset); // Only used by EXTRA macro
20412 _res = _PyAST_IfExp ( b , a , c , EXTRA );
20413 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20414 p->error_indicator = 1;
20415 p->call_invalid_rules = _prev_call_invalid;
20416 p->level--;
20417 return NULL;
20418 }
20419 goto done;
20420 }
20421 p->mark = _mark;
20422 D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ',
20423 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
20424 }
20425 { // disjunction
20426 if (p->error_indicator) {
20427 p->call_invalid_rules = _prev_call_invalid;
20428 p->level--;
20429 return NULL;
20430 }
20431 D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction"));
20432 expr_ty disjunction_var;
20433 if (
20434 (disjunction_var = disjunction_rule(p)) // disjunction
20435 )
20436 {
20437 D(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction"));
20438 _res = disjunction_var;
20439 goto done;
20440 }
20441 p->mark = _mark;
20442 D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ',
20443 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction"));
20444 }
20445 { // lambdef
20446 if (p->error_indicator) {
20447 p->call_invalid_rules = _prev_call_invalid;
20448 p->level--;
20449 return NULL;
20450 }
20451 D(fprintf(stderr, "%*c> expression_without_invalid[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef"));
20452 expr_ty lambdef_var;
20453 if (
20454 (lambdef_var = lambdef_rule(p)) // lambdef
20455 )
20456 {
20457 D(fprintf(stderr, "%*c+ expression_without_invalid[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef"));
20458 _res = lambdef_var;
20459 goto done;
20460 }
20461 p->mark = _mark;
20462 D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ',
20463 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef"));
20464 }
20465 _res = NULL;
20466 done:
20467 p->call_invalid_rules = _prev_call_invalid;
20468 p->level--;
20469 return _res;
20470 }
20471
20472 // invalid_legacy_expression: NAME !'(' star_expressions
20473 static void *
20474 invalid_legacy_expression_rule(Parser *p)
20475 {
20476 if (p->level++ == MAXSTACK) {
20477 _Pypegen_stack_overflow(p);
20478 }
20479 if (p->error_indicator) {
20480 p->level--;
20481 return NULL;
20482 }
20483 void * _res = NULL;
20484 int _mark = p->mark;
20485 { // NAME !'(' star_expressions
20486 if (p->error_indicator) {
20487 p->level--;
20488 return NULL;
20489 }
20490 D(fprintf(stderr, "%*c> invalid_legacy_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME !'(' star_expressions"));
20491 expr_ty a;
20492 expr_ty b;
20493 if (
20494 (a = _PyPegen_name_token(p)) // NAME
20495 &&
20496 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 7) // token='('
20497 &&
20498 (b = star_expressions_rule(p)) // star_expressions
20499 )
20500 {
20501 D(fprintf(stderr, "%*c+ invalid_legacy_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME !'(' star_expressions"));
20502 _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;
20503 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20504 p->error_indicator = 1;
20505 p->level--;
20506 return NULL;
20507 }
20508 goto done;
20509 }
20510 p->mark = _mark;
20511 D(fprintf(stderr, "%*c%s invalid_legacy_expression[%d-%d]: %s failed!\n", p->level, ' ',
20512 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME !'(' star_expressions"));
20513 }
20514 _res = NULL;
20515 done:
20516 p->level--;
20517 return _res;
20518 }
20519
20520 // invalid_expression:
20521 // | !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid
20522 // | disjunction 'if' disjunction !('else' | ':')
20523 // | 'lambda' lambda_params? ':' &FSTRING_MIDDLE
20524 static void *
20525 invalid_expression_rule(Parser *p)
20526 {
20527 if (p->level++ == MAXSTACK) {
20528 _Pypegen_stack_overflow(p);
20529 }
20530 if (p->error_indicator) {
20531 p->level--;
20532 return NULL;
20533 }
20534 void * _res = NULL;
20535 int _mark = p->mark;
20536 { // !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid
20537 if (p->error_indicator) {
20538 p->level--;
20539 return NULL;
20540 }
20541 D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid"));
20542 expr_ty a;
20543 expr_ty b;
20544 if (
20545 _PyPegen_lookahead(0, _tmp_158_rule, p)
20546 &&
20547 (a = disjunction_rule(p)) // disjunction
20548 &&
20549 (b = expression_without_invalid_rule(p)) // expression_without_invalid
20550 )
20551 {
20552 D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid"));
20553 _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?" );
20554 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20555 p->error_indicator = 1;
20556 p->level--;
20557 return NULL;
20558 }
20559 goto done;
20560 }
20561 p->mark = _mark;
20562 D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
20563 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid"));
20564 }
20565 { // disjunction 'if' disjunction !('else' | ':')
20566 if (p->error_indicator) {
20567 p->level--;
20568 return NULL;
20569 }
20570 D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')"));
20571 Token * _keyword;
20572 expr_ty a;
20573 expr_ty b;
20574 if (
20575 (a = disjunction_rule(p)) // disjunction
20576 &&
20577 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
20578 &&
20579 (b = disjunction_rule(p)) // disjunction
20580 &&
20581 _PyPegen_lookahead(0, _tmp_159_rule, p)
20582 )
20583 {
20584 D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')"));
20585 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expected 'else' after 'if' expression" );
20586 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20587 p->error_indicator = 1;
20588 p->level--;
20589 return NULL;
20590 }
20591 goto done;
20592 }
20593 p->mark = _mark;
20594 D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
20595 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')"));
20596 }
20597 { // 'lambda' lambda_params? ':' &FSTRING_MIDDLE
20598 if (p->error_indicator) {
20599 p->level--;
20600 return NULL;
20601 }
20602 D(fprintf(stderr, "%*c> invalid_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE"));
20603 void *_opt_var;
20604 UNUSED(_opt_var); // Silence compiler warnings
20605 Token * a;
20606 Token * b;
20607 if (
20608 (a = _PyPegen_expect_token(p, 612)) // token='lambda'
20609 &&
20610 (_opt_var = lambda_params_rule(p), !p->error_indicator) // lambda_params?
20611 &&
20612 (b = _PyPegen_expect_token(p, 11)) // token=':'
20613 &&
20614 _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, FSTRING_MIDDLE) // token=FSTRING_MIDDLE
20615 )
20616 {
20617 D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE"));
20618 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "f-string: lambda expressions are not allowed without parentheses" );
20619 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20620 p->error_indicator = 1;
20621 p->level--;
20622 return NULL;
20623 }
20624 goto done;
20625 }
20626 p->mark = _mark;
20627 D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
20628 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE"));
20629 }
20630 _res = NULL;
20631 done:
20632 p->level--;
20633 return _res;
20634 }
20635
20636 // invalid_named_expression:
20637 // | expression ':=' expression
20638 // | NAME '=' bitwise_or !('=' | ':=')
20639 // | !(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')
20640 static void *
20641 invalid_named_expression_rule(Parser *p)
20642 {
20643 if (p->level++ == MAXSTACK) {
20644 _Pypegen_stack_overflow(p);
20645 }
20646 if (p->error_indicator) {
20647 p->level--;
20648 return NULL;
20649 }
20650 void * _res = NULL;
20651 if (_PyPegen_is_memoized(p, invalid_named_expression_type, &_res)) {
20652 p->level--;
20653 return _res;
20654 }
20655 int _mark = p->mark;
20656 { // expression ':=' expression
20657 if (p->error_indicator) {
20658 p->level--;
20659 return NULL;
20660 }
20661 D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':=' expression"));
20662 Token * _literal;
20663 expr_ty a;
20664 expr_ty expression_var;
20665 if (
20666 (a = expression_rule(p)) // expression
20667 &&
20668 (_literal = _PyPegen_expect_token(p, 53)) // token=':='
20669 &&
20670 (expression_var = expression_rule(p)) // expression
20671 )
20672 {
20673 D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':=' expression"));
20674 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) );
20675 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20676 p->error_indicator = 1;
20677 p->level--;
20678 return NULL;
20679 }
20680 goto done;
20681 }
20682 p->mark = _mark;
20683 D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
20684 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':=' expression"));
20685 }
20686 { // NAME '=' bitwise_or !('=' | ':=')
20687 if (p->error_indicator) {
20688 p->level--;
20689 return NULL;
20690 }
20691 D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')"));
20692 Token * _literal;
20693 expr_ty a;
20694 expr_ty b;
20695 if (
20696 (a = _PyPegen_name_token(p)) // NAME
20697 &&
20698 (_literal = _PyPegen_expect_token(p, 22)) // token='='
20699 &&
20700 (b = bitwise_or_rule(p)) // bitwise_or
20701 &&
20702 _PyPegen_lookahead(0, _tmp_160_rule, p)
20703 )
20704 {
20705 D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')"));
20706 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" );
20707 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20708 p->error_indicator = 1;
20709 p->level--;
20710 return NULL;
20711 }
20712 goto done;
20713 }
20714 p->mark = _mark;
20715 D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
20716 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')"));
20717 }
20718 { // !(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')
20719 if (p->error_indicator) {
20720 p->level--;
20721 return NULL;
20722 }
20723 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 !('=' | ':=')"));
20724 expr_ty a;
20725 Token * b;
20726 expr_ty bitwise_or_var;
20727 if (
20728 _PyPegen_lookahead(0, _tmp_161_rule, p)
20729 &&
20730 (a = bitwise_or_rule(p)) // bitwise_or
20731 &&
20732 (b = _PyPegen_expect_token(p, 22)) // token='='
20733 &&
20734 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
20735 &&
20736 _PyPegen_lookahead(0, _tmp_162_rule, p)
20737 )
20738 {
20739 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 !('=' | ':=')"));
20740 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot assign to %s here. Maybe you meant '==' instead of '='?" , _PyPegen_get_expr_name ( a ) );
20741 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20742 p->error_indicator = 1;
20743 p->level--;
20744 return NULL;
20745 }
20746 goto done;
20747 }
20748 p->mark = _mark;
20749 D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
20750 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')"));
20751 }
20752 _res = NULL;
20753 done:
20754 _PyPegen_insert_memo(p, _mark, invalid_named_expression_type, _res);
20755 p->level--;
20756 return _res;
20757 }
20758
20759 // invalid_assignment:
20760 // | invalid_ann_assign_target ':' expression
20761 // | star_named_expression ',' star_named_expressions* ':' expression
20762 // | expression ':' expression
20763 // | ((star_targets '='))* star_expressions '='
20764 // | ((star_targets '='))* yield_expr '='
20765 // | star_expressions augassign annotated_rhs
20766 static void *
20767 invalid_assignment_rule(Parser *p)
20768 {
20769 if (p->level++ == MAXSTACK) {
20770 _Pypegen_stack_overflow(p);
20771 }
20772 if (p->error_indicator) {
20773 p->level--;
20774 return NULL;
20775 }
20776 void * _res = NULL;
20777 int _mark = p->mark;
20778 { // invalid_ann_assign_target ':' expression
20779 if (p->error_indicator) {
20780 p->level--;
20781 return NULL;
20782 }
20783 D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression"));
20784 Token * _literal;
20785 expr_ty a;
20786 expr_ty expression_var;
20787 if (
20788 (a = invalid_ann_assign_target_rule(p)) // invalid_ann_assign_target
20789 &&
20790 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
20791 &&
20792 (expression_var = expression_rule(p)) // expression
20793 )
20794 {
20795 D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression"));
20796 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not %s) can be annotated" , _PyPegen_get_expr_name ( a ) );
20797 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20798 p->error_indicator = 1;
20799 p->level--;
20800 return NULL;
20801 }
20802 goto done;
20803 }
20804 p->mark = _mark;
20805 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
20806 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_ann_assign_target ':' expression"));
20807 }
20808 { // star_named_expression ',' star_named_expressions* ':' expression
20809 if (p->error_indicator) {
20810 p->level--;
20811 return NULL;
20812 }
20813 D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression"));
20814 Token * _literal;
20815 Token * _literal_1;
20816 asdl_seq * _loop0_163_var;
20817 expr_ty a;
20818 expr_ty expression_var;
20819 if (
20820 (a = star_named_expression_rule(p)) // star_named_expression
20821 &&
20822 (_literal = _PyPegen_expect_token(p, 12)) // token=','
20823 &&
20824 (_loop0_163_var = _loop0_163_rule(p)) // star_named_expressions*
20825 &&
20826 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
20827 &&
20828 (expression_var = expression_rule(p)) // expression
20829 )
20830 {
20831 D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression"));
20832 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not tuple) can be annotated" );
20833 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20834 p->error_indicator = 1;
20835 p->level--;
20836 return NULL;
20837 }
20838 goto done;
20839 }
20840 p->mark = _mark;
20841 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
20842 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression"));
20843 }
20844 { // expression ':' expression
20845 if (p->error_indicator) {
20846 p->level--;
20847 return NULL;
20848 }
20849 D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
20850 Token * _literal;
20851 expr_ty a;
20852 expr_ty expression_var;
20853 if (
20854 (a = expression_rule(p)) // expression
20855 &&
20856 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
20857 &&
20858 (expression_var = expression_rule(p)) // expression
20859 )
20860 {
20861 D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
20862 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "illegal target for annotation" );
20863 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20864 p->error_indicator = 1;
20865 p->level--;
20866 return NULL;
20867 }
20868 goto done;
20869 }
20870 p->mark = _mark;
20871 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
20872 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression"));
20873 }
20874 { // ((star_targets '='))* star_expressions '='
20875 if (p->error_indicator) {
20876 p->level--;
20877 return NULL;
20878 }
20879 D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='"));
20880 Token * _literal;
20881 asdl_seq * _loop0_164_var;
20882 expr_ty a;
20883 if (
20884 (_loop0_164_var = _loop0_164_rule(p)) // ((star_targets '='))*
20885 &&
20886 (a = star_expressions_rule(p)) // star_expressions
20887 &&
20888 (_literal = _PyPegen_expect_token(p, 22)) // token='='
20889 )
20890 {
20891 D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='"));
20892 _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a );
20893 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20894 p->error_indicator = 1;
20895 p->level--;
20896 return NULL;
20897 }
20898 goto done;
20899 }
20900 p->mark = _mark;
20901 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
20902 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* star_expressions '='"));
20903 }
20904 { // ((star_targets '='))* yield_expr '='
20905 if (p->error_indicator) {
20906 p->level--;
20907 return NULL;
20908 }
20909 D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='"));
20910 Token * _literal;
20911 asdl_seq * _loop0_165_var;
20912 expr_ty a;
20913 if (
20914 (_loop0_165_var = _loop0_165_rule(p)) // ((star_targets '='))*
20915 &&
20916 (a = yield_expr_rule(p)) // yield_expr
20917 &&
20918 (_literal = _PyPegen_expect_token(p, 22)) // token='='
20919 )
20920 {
20921 D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='"));
20922 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "assignment to yield expression not possible" );
20923 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20924 p->error_indicator = 1;
20925 p->level--;
20926 return NULL;
20927 }
20928 goto done;
20929 }
20930 p->mark = _mark;
20931 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
20932 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* yield_expr '='"));
20933 }
20934 { // star_expressions augassign annotated_rhs
20935 if (p->error_indicator) {
20936 p->level--;
20937 return NULL;
20938 }
20939 D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions augassign annotated_rhs"));
20940 expr_ty a;
20941 expr_ty annotated_rhs_var;
20942 AugOperator* augassign_var;
20943 if (
20944 (a = star_expressions_rule(p)) // star_expressions
20945 &&
20946 (augassign_var = augassign_rule(p)) // augassign
20947 &&
20948 (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs
20949 )
20950 {
20951 D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions augassign annotated_rhs"));
20952 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "'%s' is an illegal expression for augmented assignment" , _PyPegen_get_expr_name ( a ) );
20953 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
20954 p->error_indicator = 1;
20955 p->level--;
20956 return NULL;
20957 }
20958 goto done;
20959 }
20960 p->mark = _mark;
20961 D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
20962 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions augassign annotated_rhs"));
20963 }
20964 _res = NULL;
20965 done:
20966 p->level--;
20967 return _res;
20968 }
20969
20970 // invalid_ann_assign_target: list | tuple | '(' invalid_ann_assign_target ')'
20971 static expr_ty
20972 invalid_ann_assign_target_rule(Parser *p)
20973 {
20974 if (p->level++ == MAXSTACK) {
20975 _Pypegen_stack_overflow(p);
20976 }
20977 if (p->error_indicator) {
20978 p->level--;
20979 return NULL;
20980 }
20981 expr_ty _res = NULL;
20982 int _mark = p->mark;
20983 { // list
20984 if (p->error_indicator) {
20985 p->level--;
20986 return NULL;
20987 }
20988 D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));
20989 expr_ty list_var;
20990 if (
20991 (list_var = list_rule(p)) // list
20992 )
20993 {
20994 D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
20995 _res = list_var;
20996 goto done;
20997 }
20998 p->mark = _mark;
20999 D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',
21000 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));
21001 }
21002 { // tuple
21003 if (p->error_indicator) {
21004 p->level--;
21005 return NULL;
21006 }
21007 D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));
21008 expr_ty tuple_var;
21009 if (
21010 (tuple_var = tuple_rule(p)) // tuple
21011 )
21012 {
21013 D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
21014 _res = tuple_var;
21015 goto done;
21016 }
21017 p->mark = _mark;
21018 D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',
21019 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));
21020 }
21021 { // '(' invalid_ann_assign_target ')'
21022 if (p->error_indicator) {
21023 p->level--;
21024 return NULL;
21025 }
21026 D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'"));
21027 Token * _literal;
21028 Token * _literal_1;
21029 expr_ty a;
21030 if (
21031 (_literal = _PyPegen_expect_token(p, 7)) // token='('
21032 &&
21033 (a = invalid_ann_assign_target_rule(p)) // invalid_ann_assign_target
21034 &&
21035 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
21036 )
21037 {
21038 D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'"));
21039 _res = a;
21040 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21041 p->error_indicator = 1;
21042 p->level--;
21043 return NULL;
21044 }
21045 goto done;
21046 }
21047 p->mark = _mark;
21048 D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',
21049 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' invalid_ann_assign_target ')'"));
21050 }
21051 _res = NULL;
21052 done:
21053 p->level--;
21054 return _res;
21055 }
21056
21057 // invalid_del_stmt: 'del' star_expressions
21058 static void *
21059 invalid_del_stmt_rule(Parser *p)
21060 {
21061 if (p->level++ == MAXSTACK) {
21062 _Pypegen_stack_overflow(p);
21063 }
21064 if (p->error_indicator) {
21065 p->level--;
21066 return NULL;
21067 }
21068 void * _res = NULL;
21069 int _mark = p->mark;
21070 { // 'del' star_expressions
21071 if (p->error_indicator) {
21072 p->level--;
21073 return NULL;
21074 }
21075 D(fprintf(stderr, "%*c> invalid_del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' star_expressions"));
21076 Token * _keyword;
21077 expr_ty a;
21078 if (
21079 (_keyword = _PyPegen_expect_token(p, 616)) // token='del'
21080 &&
21081 (a = star_expressions_rule(p)) // star_expressions
21082 )
21083 {
21084 D(fprintf(stderr, "%*c+ invalid_del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' star_expressions"));
21085 _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( DEL_TARGETS , a );
21086 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21087 p->error_indicator = 1;
21088 p->level--;
21089 return NULL;
21090 }
21091 goto done;
21092 }
21093 p->mark = _mark;
21094 D(fprintf(stderr, "%*c%s invalid_del_stmt[%d-%d]: %s failed!\n", p->level, ' ',
21095 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' star_expressions"));
21096 }
21097 _res = NULL;
21098 done:
21099 p->level--;
21100 return _res;
21101 }
21102
21103 // invalid_block: NEWLINE !INDENT
21104 static void *
21105 invalid_block_rule(Parser *p)
21106 {
21107 if (p->level++ == MAXSTACK) {
21108 _Pypegen_stack_overflow(p);
21109 }
21110 if (p->error_indicator) {
21111 p->level--;
21112 return NULL;
21113 }
21114 void * _res = NULL;
21115 int _mark = p->mark;
21116 { // NEWLINE !INDENT
21117 if (p->error_indicator) {
21118 p->level--;
21119 return NULL;
21120 }
21121 D(fprintf(stderr, "%*c> invalid_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT"));
21122 Token * newline_var;
21123 if (
21124 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
21125 &&
21126 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
21127 )
21128 {
21129 D(fprintf(stderr, "%*c+ invalid_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT"));
21130 _res = RAISE_INDENTATION_ERROR ( "expected an indented block" );
21131 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21132 p->error_indicator = 1;
21133 p->level--;
21134 return NULL;
21135 }
21136 goto done;
21137 }
21138 p->mark = _mark;
21139 D(fprintf(stderr, "%*c%s invalid_block[%d-%d]: %s failed!\n", p->level, ' ',
21140 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE !INDENT"));
21141 }
21142 _res = NULL;
21143 done:
21144 p->level--;
21145 return _res;
21146 }
21147
21148 // invalid_comprehension:
21149 // | ('[' | '(' | '{') starred_expression for_if_clauses
21150 // | ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses
21151 // | ('[' | '{') star_named_expression ',' for_if_clauses
21152 static void *
21153 invalid_comprehension_rule(Parser *p)
21154 {
21155 if (p->level++ == MAXSTACK) {
21156 _Pypegen_stack_overflow(p);
21157 }
21158 if (p->error_indicator) {
21159 p->level--;
21160 return NULL;
21161 }
21162 void * _res = NULL;
21163 int _mark = p->mark;
21164 { // ('[' | '(' | '{') starred_expression for_if_clauses
21165 if (p->error_indicator) {
21166 p->level--;
21167 return NULL;
21168 }
21169 D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses"));
21170 void *_tmp_166_var;
21171 expr_ty a;
21172 asdl_comprehension_seq* for_if_clauses_var;
21173 if (
21174 (_tmp_166_var = _tmp_166_rule(p)) // '[' | '(' | '{'
21175 &&
21176 (a = starred_expression_rule(p)) // starred_expression
21177 &&
21178 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
21179 )
21180 {
21181 D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses"));
21182 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable unpacking cannot be used in comprehension" );
21183 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21184 p->error_indicator = 1;
21185 p->level--;
21186 return NULL;
21187 }
21188 goto done;
21189 }
21190 p->mark = _mark;
21191 D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
21192 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses"));
21193 }
21194 { // ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses
21195 if (p->error_indicator) {
21196 p->level--;
21197 return NULL;
21198 }
21199 D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses"));
21200 Token * _literal;
21201 void *_tmp_167_var;
21202 expr_ty a;
21203 asdl_expr_seq* b;
21204 asdl_comprehension_seq* for_if_clauses_var;
21205 if (
21206 (_tmp_167_var = _tmp_167_rule(p)) // '[' | '{'
21207 &&
21208 (a = star_named_expression_rule(p)) // star_named_expression
21209 &&
21210 (_literal = _PyPegen_expect_token(p, 12)) // token=','
21211 &&
21212 (b = star_named_expressions_rule(p)) // star_named_expressions
21213 &&
21214 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
21215 )
21216 {
21217 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"));
21218 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , PyPegen_last_item ( b , expr_ty ) , "did you forget parentheses around the comprehension target?" );
21219 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21220 p->error_indicator = 1;
21221 p->level--;
21222 return NULL;
21223 }
21224 goto done;
21225 }
21226 p->mark = _mark;
21227 D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
21228 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses"));
21229 }
21230 { // ('[' | '{') star_named_expression ',' for_if_clauses
21231 if (p->error_indicator) {
21232 p->level--;
21233 return NULL;
21234 }
21235 D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses"));
21236 void *_tmp_168_var;
21237 expr_ty a;
21238 Token * b;
21239 asdl_comprehension_seq* for_if_clauses_var;
21240 if (
21241 (_tmp_168_var = _tmp_168_rule(p)) // '[' | '{'
21242 &&
21243 (a = star_named_expression_rule(p)) // star_named_expression
21244 &&
21245 (b = _PyPegen_expect_token(p, 12)) // token=','
21246 &&
21247 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
21248 )
21249 {
21250 D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses"));
21251 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "did you forget parentheses around the comprehension target?" );
21252 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21253 p->error_indicator = 1;
21254 p->level--;
21255 return NULL;
21256 }
21257 goto done;
21258 }
21259 p->mark = _mark;
21260 D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
21261 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses"));
21262 }
21263 _res = NULL;
21264 done:
21265 p->level--;
21266 return _res;
21267 }
21268
21269 // invalid_dict_comprehension: '{' '**' bitwise_or for_if_clauses '}'
21270 static void *
21271 invalid_dict_comprehension_rule(Parser *p)
21272 {
21273 if (p->level++ == MAXSTACK) {
21274 _Pypegen_stack_overflow(p);
21275 }
21276 if (p->error_indicator) {
21277 p->level--;
21278 return NULL;
21279 }
21280 void * _res = NULL;
21281 int _mark = p->mark;
21282 { // '{' '**' bitwise_or for_if_clauses '}'
21283 if (p->error_indicator) {
21284 p->level--;
21285 return NULL;
21286 }
21287 D(fprintf(stderr, "%*c> invalid_dict_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'"));
21288 Token * _literal;
21289 Token * _literal_1;
21290 Token * a;
21291 expr_ty bitwise_or_var;
21292 asdl_comprehension_seq* for_if_clauses_var;
21293 if (
21294 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
21295 &&
21296 (a = _PyPegen_expect_token(p, 35)) // token='**'
21297 &&
21298 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
21299 &&
21300 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
21301 &&
21302 (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}'
21303 )
21304 {
21305 D(fprintf(stderr, "%*c+ invalid_dict_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'"));
21306 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "dict unpacking cannot be used in dict comprehension" );
21307 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21308 p->error_indicator = 1;
21309 p->level--;
21310 return NULL;
21311 }
21312 goto done;
21313 }
21314 p->mark = _mark;
21315 D(fprintf(stderr, "%*c%s invalid_dict_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
21316 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'"));
21317 }
21318 _res = NULL;
21319 done:
21320 p->level--;
21321 return _res;
21322 }
21323
21324 // invalid_parameters:
21325 // | "/" ','
21326 // | (slash_no_default | slash_with_default) param_maybe_default* '/'
21327 // | slash_no_default? param_no_default* invalid_parameters_helper param_no_default
21328 // | param_no_default* '(' param_no_default+ ','? ')'
21329 // | [(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'
21330 // | param_maybe_default+ '/' '*'
21331 static void *
21332 invalid_parameters_rule(Parser *p)
21333 {
21334 if (p->level++ == MAXSTACK) {
21335 _Pypegen_stack_overflow(p);
21336 }
21337 if (p->error_indicator) {
21338 p->level--;
21339 return NULL;
21340 }
21341 void * _res = NULL;
21342 int _mark = p->mark;
21343 { // "/" ','
21344 if (p->error_indicator) {
21345 p->level--;
21346 return NULL;
21347 }
21348 D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"/\" ','"));
21349 Token * _literal;
21350 Token * a;
21351 if (
21352 (a = _PyPegen_expect_token(p, 17)) // token='/'
21353 &&
21354 (_literal = _PyPegen_expect_token(p, 12)) // token=','
21355 )
21356 {
21357 D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"/\" ','"));
21358 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "at least one argument must precede /" );
21359 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21360 p->error_indicator = 1;
21361 p->level--;
21362 return NULL;
21363 }
21364 goto done;
21365 }
21366 p->mark = _mark;
21367 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
21368 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','"));
21369 }
21370 { // (slash_no_default | slash_with_default) param_maybe_default* '/'
21371 if (p->error_indicator) {
21372 p->level--;
21373 return NULL;
21374 }
21375 D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'"));
21376 asdl_seq * _loop0_170_var;
21377 void *_tmp_169_var;
21378 Token * a;
21379 if (
21380 (_tmp_169_var = _tmp_169_rule(p)) // slash_no_default | slash_with_default
21381 &&
21382 (_loop0_170_var = _loop0_170_rule(p)) // param_maybe_default*
21383 &&
21384 (a = _PyPegen_expect_token(p, 17)) // token='/'
21385 )
21386 {
21387 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* '/'"));
21388 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ may appear only once" );
21389 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21390 p->error_indicator = 1;
21391 p->level--;
21392 return NULL;
21393 }
21394 goto done;
21395 }
21396 p->mark = _mark;
21397 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
21398 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'"));
21399 }
21400 { // slash_no_default? param_no_default* invalid_parameters_helper param_no_default
21401 if (p->error_indicator) {
21402 p->level--;
21403 return NULL;
21404 }
21405 D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default? param_no_default* invalid_parameters_helper param_no_default"));
21406 asdl_seq * _loop0_171_var;
21407 void *_opt_var;
21408 UNUSED(_opt_var); // Silence compiler warnings
21409 arg_ty a;
21410 void *invalid_parameters_helper_var;
21411 if (
21412 (_opt_var = slash_no_default_rule(p), !p->error_indicator) // slash_no_default?
21413 &&
21414 (_loop0_171_var = _loop0_171_rule(p)) // param_no_default*
21415 &&
21416 (invalid_parameters_helper_var = invalid_parameters_helper_rule(p)) // invalid_parameters_helper
21417 &&
21418 (a = param_no_default_rule(p)) // param_no_default
21419 )
21420 {
21421 D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default? param_no_default* invalid_parameters_helper param_no_default"));
21422 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "parameter without a default follows parameter with a default" );
21423 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21424 p->error_indicator = 1;
21425 p->level--;
21426 return NULL;
21427 }
21428 goto done;
21429 }
21430 p->mark = _mark;
21431 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
21432 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default? param_no_default* invalid_parameters_helper param_no_default"));
21433 }
21434 { // param_no_default* '(' param_no_default+ ','? ')'
21435 if (p->error_indicator) {
21436 p->level--;
21437 return NULL;
21438 }
21439 D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* '(' param_no_default+ ','? ')'"));
21440 asdl_seq * _loop0_172_var;
21441 asdl_seq * _loop1_173_var;
21442 void *_opt_var;
21443 UNUSED(_opt_var); // Silence compiler warnings
21444 Token * a;
21445 Token * b;
21446 if (
21447 (_loop0_172_var = _loop0_172_rule(p)) // param_no_default*
21448 &&
21449 (a = _PyPegen_expect_token(p, 7)) // token='('
21450 &&
21451 (_loop1_173_var = _loop1_173_rule(p)) // param_no_default+
21452 &&
21453 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
21454 &&
21455 (b = _PyPegen_expect_token(p, 8)) // token=')'
21456 )
21457 {
21458 D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* '(' param_no_default+ ','? ')'"));
21459 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Function parameters cannot be parenthesized" );
21460 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21461 p->error_indicator = 1;
21462 p->level--;
21463 return NULL;
21464 }
21465 goto done;
21466 }
21467 p->mark = _mark;
21468 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
21469 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* '(' param_no_default+ ','? ')'"));
21470 }
21471 { // [(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'
21472 if (p->error_indicator) {
21473 p->level--;
21474 return NULL;
21475 }
21476 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* '/'"));
21477 Token * _literal;
21478 asdl_seq * _loop0_175_var;
21479 asdl_seq * _loop0_177_var;
21480 void *_opt_var;
21481 UNUSED(_opt_var); // Silence compiler warnings
21482 void *_tmp_176_var;
21483 Token * a;
21484 if (
21485 (_opt_var = _tmp_174_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)]
21486 &&
21487 (_loop0_175_var = _loop0_175_rule(p)) // param_maybe_default*
21488 &&
21489 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
21490 &&
21491 (_tmp_176_var = _tmp_176_rule(p)) // ',' | param_no_default
21492 &&
21493 (_loop0_177_var = _loop0_177_rule(p)) // param_maybe_default*
21494 &&
21495 (a = _PyPegen_expect_token(p, 17)) // token='/'
21496 )
21497 {
21498 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* '/'"));
21499 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ must be ahead of *" );
21500 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21501 p->error_indicator = 1;
21502 p->level--;
21503 return NULL;
21504 }
21505 goto done;
21506 }
21507 p->mark = _mark;
21508 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
21509 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'"));
21510 }
21511 { // param_maybe_default+ '/' '*'
21512 if (p->error_indicator) {
21513 p->level--;
21514 return NULL;
21515 }
21516 D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default+ '/' '*'"));
21517 Token * _literal;
21518 asdl_seq * _loop1_178_var;
21519 Token * a;
21520 if (
21521 (_loop1_178_var = _loop1_178_rule(p)) // param_maybe_default+
21522 &&
21523 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
21524 &&
21525 (a = _PyPegen_expect_token(p, 16)) // token='*'
21526 )
21527 {
21528 D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_maybe_default+ '/' '*'"));
21529 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected comma between / and *" );
21530 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21531 p->error_indicator = 1;
21532 p->level--;
21533 return NULL;
21534 }
21535 goto done;
21536 }
21537 p->mark = _mark;
21538 D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
21539 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default+ '/' '*'"));
21540 }
21541 _res = NULL;
21542 done:
21543 p->level--;
21544 return _res;
21545 }
21546
21547 // invalid_default: '=' &(')' | ',')
21548 static void *
21549 invalid_default_rule(Parser *p)
21550 {
21551 if (p->level++ == MAXSTACK) {
21552 _Pypegen_stack_overflow(p);
21553 }
21554 if (p->error_indicator) {
21555 p->level--;
21556 return NULL;
21557 }
21558 void * _res = NULL;
21559 int _mark = p->mark;
21560 { // '=' &(')' | ',')
21561 if (p->error_indicator) {
21562 p->level--;
21563 return NULL;
21564 }
21565 D(fprintf(stderr, "%*c> invalid_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')"));
21566 Token * a;
21567 if (
21568 (a = _PyPegen_expect_token(p, 22)) // token='='
21569 &&
21570 _PyPegen_lookahead(1, _tmp_179_rule, p)
21571 )
21572 {
21573 D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')"));
21574 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected default value expression" );
21575 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21576 p->error_indicator = 1;
21577 p->level--;
21578 return NULL;
21579 }
21580 goto done;
21581 }
21582 p->mark = _mark;
21583 D(fprintf(stderr, "%*c%s invalid_default[%d-%d]: %s failed!\n", p->level, ' ',
21584 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' &(')' | ',')"));
21585 }
21586 _res = NULL;
21587 done:
21588 p->level--;
21589 return _res;
21590 }
21591
21592 // invalid_star_etc:
21593 // | '*' (')' | ',' (')' | '**'))
21594 // | '*' ',' TYPE_COMMENT
21595 // | '*' param '='
21596 // | '*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')
21597 static void *
21598 invalid_star_etc_rule(Parser *p)
21599 {
21600 if (p->level++ == MAXSTACK) {
21601 _Pypegen_stack_overflow(p);
21602 }
21603 if (p->error_indicator) {
21604 p->level--;
21605 return NULL;
21606 }
21607 void * _res = NULL;
21608 int _mark = p->mark;
21609 { // '*' (')' | ',' (')' | '**'))
21610 if (p->error_indicator) {
21611 p->level--;
21612 return NULL;
21613 }
21614 D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));
21615 void *_tmp_180_var;
21616 Token * a;
21617 if (
21618 (a = _PyPegen_expect_token(p, 16)) // token='*'
21619 &&
21620 (_tmp_180_var = _tmp_180_rule(p)) // ')' | ',' (')' | '**')
21621 )
21622 {
21623 D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));
21624 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "named arguments must follow bare *" );
21625 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21626 p->error_indicator = 1;
21627 p->level--;
21628 return NULL;
21629 }
21630 goto done;
21631 }
21632 p->mark = _mark;
21633 D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
21634 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));
21635 }
21636 { // '*' ',' TYPE_COMMENT
21637 if (p->error_indicator) {
21638 p->level--;
21639 return NULL;
21640 }
21641 D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT"));
21642 Token * _literal;
21643 Token * _literal_1;
21644 Token * type_comment_var;
21645 if (
21646 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
21647 &&
21648 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
21649 &&
21650 (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
21651 )
21652 {
21653 D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT"));
21654 _res = RAISE_SYNTAX_ERROR ( "bare * has associated type comment" );
21655 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21656 p->error_indicator = 1;
21657 p->level--;
21658 return NULL;
21659 }
21660 goto done;
21661 }
21662 p->mark = _mark;
21663 D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
21664 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' TYPE_COMMENT"));
21665 }
21666 { // '*' param '='
21667 if (p->error_indicator) {
21668 p->level--;
21669 return NULL;
21670 }
21671 D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param '='"));
21672 Token * _literal;
21673 Token * a;
21674 arg_ty param_var;
21675 if (
21676 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
21677 &&
21678 (param_var = param_rule(p)) // param
21679 &&
21680 (a = _PyPegen_expect_token(p, 22)) // token='='
21681 )
21682 {
21683 D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param '='"));
21684 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-positional argument cannot have default value" );
21685 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21686 p->error_indicator = 1;
21687 p->level--;
21688 return NULL;
21689 }
21690 goto done;
21691 }
21692 p->mark = _mark;
21693 D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
21694 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param '='"));
21695 }
21696 { // '*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')
21697 if (p->error_indicator) {
21698 p->level--;
21699 return NULL;
21700 }
21701 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 | ',')"));
21702 Token * _literal;
21703 asdl_seq * _loop0_182_var;
21704 void *_tmp_181_var;
21705 void *_tmp_183_var;
21706 Token * a;
21707 if (
21708 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
21709 &&
21710 (_tmp_181_var = _tmp_181_rule(p)) // param_no_default | ','
21711 &&
21712 (_loop0_182_var = _loop0_182_rule(p)) // param_maybe_default*
21713 &&
21714 (a = _PyPegen_expect_token(p, 16)) // token='*'
21715 &&
21716 (_tmp_183_var = _tmp_183_rule(p)) // param_no_default | ','
21717 )
21718 {
21719 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 | ',')"));
21720 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "* argument may appear only once" );
21721 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21722 p->error_indicator = 1;
21723 p->level--;
21724 return NULL;
21725 }
21726 goto done;
21727 }
21728 p->mark = _mark;
21729 D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
21730 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')"));
21731 }
21732 _res = NULL;
21733 done:
21734 p->level--;
21735 return _res;
21736 }
21737
21738 // invalid_kwds: '**' param '=' | '**' param ',' param | '**' param ',' ('*' | '**' | '/')
21739 static void *
21740 invalid_kwds_rule(Parser *p)
21741 {
21742 if (p->level++ == MAXSTACK) {
21743 _Pypegen_stack_overflow(p);
21744 }
21745 if (p->error_indicator) {
21746 p->level--;
21747 return NULL;
21748 }
21749 void * _res = NULL;
21750 int _mark = p->mark;
21751 { // '**' param '='
21752 if (p->error_indicator) {
21753 p->level--;
21754 return NULL;
21755 }
21756 D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param '='"));
21757 Token * _literal;
21758 Token * a;
21759 arg_ty param_var;
21760 if (
21761 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
21762 &&
21763 (param_var = param_rule(p)) // param
21764 &&
21765 (a = _PyPegen_expect_token(p, 22)) // token='='
21766 )
21767 {
21768 D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param '='"));
21769 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-keyword argument cannot have default value" );
21770 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21771 p->error_indicator = 1;
21772 p->level--;
21773 return NULL;
21774 }
21775 goto done;
21776 }
21777 p->mark = _mark;
21778 D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ',
21779 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param '='"));
21780 }
21781 { // '**' param ',' param
21782 if (p->error_indicator) {
21783 p->level--;
21784 return NULL;
21785 }
21786 D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param ',' param"));
21787 Token * _literal;
21788 Token * _literal_1;
21789 arg_ty a;
21790 arg_ty param_var;
21791 if (
21792 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
21793 &&
21794 (param_var = param_rule(p)) // param
21795 &&
21796 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
21797 &&
21798 (a = param_rule(p)) // param
21799 )
21800 {
21801 D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' param"));
21802 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" );
21803 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21804 p->error_indicator = 1;
21805 p->level--;
21806 return NULL;
21807 }
21808 goto done;
21809 }
21810 p->mark = _mark;
21811 D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ',
21812 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param ',' param"));
21813 }
21814 { // '**' param ',' ('*' | '**' | '/')
21815 if (p->error_indicator) {
21816 p->level--;
21817 return NULL;
21818 }
21819 D(fprintf(stderr, "%*c> invalid_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')"));
21820 Token * _literal;
21821 Token * _literal_1;
21822 Token* a;
21823 arg_ty param_var;
21824 if (
21825 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
21826 &&
21827 (param_var = param_rule(p)) // param
21828 &&
21829 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
21830 &&
21831 (a = (Token*)_tmp_184_rule(p)) // '*' | '**' | '/'
21832 )
21833 {
21834 D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')"));
21835 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" );
21836 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21837 p->error_indicator = 1;
21838 p->level--;
21839 return NULL;
21840 }
21841 goto done;
21842 }
21843 p->mark = _mark;
21844 D(fprintf(stderr, "%*c%s invalid_kwds[%d-%d]: %s failed!\n", p->level, ' ',
21845 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param ',' ('*' | '**' | '/')"));
21846 }
21847 _res = NULL;
21848 done:
21849 p->level--;
21850 return _res;
21851 }
21852
21853 // invalid_parameters_helper: slash_with_default | param_with_default+
21854 static void *
21855 invalid_parameters_helper_rule(Parser *p)
21856 {
21857 if (p->level++ == MAXSTACK) {
21858 _Pypegen_stack_overflow(p);
21859 }
21860 if (p->error_indicator) {
21861 p->level--;
21862 return NULL;
21863 }
21864 void * _res = NULL;
21865 int _mark = p->mark;
21866 { // slash_with_default
21867 if (p->error_indicator) {
21868 p->level--;
21869 return NULL;
21870 }
21871 D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
21872 SlashWithDefault* a;
21873 if (
21874 (a = slash_with_default_rule(p)) // slash_with_default
21875 )
21876 {
21877 D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
21878 _res = _PyPegen_singleton_seq ( p , a );
21879 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21880 p->error_indicator = 1;
21881 p->level--;
21882 return NULL;
21883 }
21884 goto done;
21885 }
21886 p->mark = _mark;
21887 D(fprintf(stderr, "%*c%s invalid_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ',
21888 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default"));
21889 }
21890 { // param_with_default+
21891 if (p->error_indicator) {
21892 p->level--;
21893 return NULL;
21894 }
21895 D(fprintf(stderr, "%*c> invalid_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+"));
21896 asdl_seq * _loop1_185_var;
21897 if (
21898 (_loop1_185_var = _loop1_185_rule(p)) // param_with_default+
21899 )
21900 {
21901 D(fprintf(stderr, "%*c+ invalid_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+"));
21902 _res = _loop1_185_var;
21903 goto done;
21904 }
21905 p->mark = _mark;
21906 D(fprintf(stderr, "%*c%s invalid_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ',
21907 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+"));
21908 }
21909 _res = NULL;
21910 done:
21911 p->level--;
21912 return _res;
21913 }
21914
21915 // invalid_lambda_parameters:
21916 // | "/" ','
21917 // | (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'
21918 // | lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default
21919 // | lambda_param_no_default* '(' ','.lambda_param+ ','? ')'
21920 // | [(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'
21921 // | lambda_param_maybe_default+ '/' '*'
21922 static void *
21923 invalid_lambda_parameters_rule(Parser *p)
21924 {
21925 if (p->level++ == MAXSTACK) {
21926 _Pypegen_stack_overflow(p);
21927 }
21928 if (p->error_indicator) {
21929 p->level--;
21930 return NULL;
21931 }
21932 void * _res = NULL;
21933 int _mark = p->mark;
21934 { // "/" ','
21935 if (p->error_indicator) {
21936 p->level--;
21937 return NULL;
21938 }
21939 D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"/\" ','"));
21940 Token * _literal;
21941 Token * a;
21942 if (
21943 (a = _PyPegen_expect_token(p, 17)) // token='/'
21944 &&
21945 (_literal = _PyPegen_expect_token(p, 12)) // token=','
21946 )
21947 {
21948 D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"/\" ','"));
21949 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "at least one argument must precede /" );
21950 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21951 p->error_indicator = 1;
21952 p->level--;
21953 return NULL;
21954 }
21955 goto done;
21956 }
21957 p->mark = _mark;
21958 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
21959 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','"));
21960 }
21961 { // (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'
21962 if (p->error_indicator) {
21963 p->level--;
21964 return NULL;
21965 }
21966 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* '/'"));
21967 asdl_seq * _loop0_187_var;
21968 void *_tmp_186_var;
21969 Token * a;
21970 if (
21971 (_tmp_186_var = _tmp_186_rule(p)) // lambda_slash_no_default | lambda_slash_with_default
21972 &&
21973 (_loop0_187_var = _loop0_187_rule(p)) // lambda_param_maybe_default*
21974 &&
21975 (a = _PyPegen_expect_token(p, 17)) // token='/'
21976 )
21977 {
21978 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* '/'"));
21979 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ may appear only once" );
21980 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
21981 p->error_indicator = 1;
21982 p->level--;
21983 return NULL;
21984 }
21985 goto done;
21986 }
21987 p->mark = _mark;
21988 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
21989 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'"));
21990 }
21991 { // lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default
21992 if (p->error_indicator) {
21993 p->level--;
21994 return NULL;
21995 }
21996 D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default"));
21997 asdl_seq * _loop0_188_var;
21998 void *_opt_var;
21999 UNUSED(_opt_var); // Silence compiler warnings
22000 arg_ty a;
22001 void *invalid_lambda_parameters_helper_var;
22002 if (
22003 (_opt_var = lambda_slash_no_default_rule(p), !p->error_indicator) // lambda_slash_no_default?
22004 &&
22005 (_loop0_188_var = _loop0_188_rule(p)) // lambda_param_no_default*
22006 &&
22007 (invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lambda_parameters_helper
22008 &&
22009 (a = lambda_param_no_default_rule(p)) // lambda_param_no_default
22010 )
22011 {
22012 D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default"));
22013 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "parameter without a default follows parameter with a default" );
22014 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22015 p->error_indicator = 1;
22016 p->level--;
22017 return NULL;
22018 }
22019 goto done;
22020 }
22021 p->mark = _mark;
22022 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
22023 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default"));
22024 }
22025 { // lambda_param_no_default* '(' ','.lambda_param+ ','? ')'
22026 if (p->error_indicator) {
22027 p->level--;
22028 return NULL;
22029 }
22030 D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'"));
22031 asdl_seq * _gather_190_var;
22032 asdl_seq * _loop0_189_var;
22033 void *_opt_var;
22034 UNUSED(_opt_var); // Silence compiler warnings
22035 Token * a;
22036 Token * b;
22037 if (
22038 (_loop0_189_var = _loop0_189_rule(p)) // lambda_param_no_default*
22039 &&
22040 (a = _PyPegen_expect_token(p, 7)) // token='('
22041 &&
22042 (_gather_190_var = _gather_190_rule(p)) // ','.lambda_param+
22043 &&
22044 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
22045 &&
22046 (b = _PyPegen_expect_token(p, 8)) // token=')'
22047 )
22048 {
22049 D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'"));
22050 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Lambda expression parameters cannot be parenthesized" );
22051 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22052 p->error_indicator = 1;
22053 p->level--;
22054 return NULL;
22055 }
22056 goto done;
22057 }
22058 p->mark = _mark;
22059 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
22060 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'"));
22061 }
22062 { // [(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'
22063 if (p->error_indicator) {
22064 p->level--;
22065 return NULL;
22066 }
22067 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* '/'"));
22068 Token * _literal;
22069 asdl_seq * _loop0_193_var;
22070 asdl_seq * _loop0_195_var;
22071 void *_opt_var;
22072 UNUSED(_opt_var); // Silence compiler warnings
22073 void *_tmp_194_var;
22074 Token * a;
22075 if (
22076 (_opt_var = _tmp_192_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)]
22077 &&
22078 (_loop0_193_var = _loop0_193_rule(p)) // lambda_param_maybe_default*
22079 &&
22080 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
22081 &&
22082 (_tmp_194_var = _tmp_194_rule(p)) // ',' | lambda_param_no_default
22083 &&
22084 (_loop0_195_var = _loop0_195_rule(p)) // lambda_param_maybe_default*
22085 &&
22086 (a = _PyPegen_expect_token(p, 17)) // token='/'
22087 )
22088 {
22089 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* '/'"));
22090 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ must be ahead of *" );
22091 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22092 p->error_indicator = 1;
22093 p->level--;
22094 return NULL;
22095 }
22096 goto done;
22097 }
22098 p->mark = _mark;
22099 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
22100 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* '/'"));
22101 }
22102 { // lambda_param_maybe_default+ '/' '*'
22103 if (p->error_indicator) {
22104 p->level--;
22105 return NULL;
22106 }
22107 D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default+ '/' '*'"));
22108 Token * _literal;
22109 asdl_seq * _loop1_196_var;
22110 Token * a;
22111 if (
22112 (_loop1_196_var = _loop1_196_rule(p)) // lambda_param_maybe_default+
22113 &&
22114 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
22115 &&
22116 (a = _PyPegen_expect_token(p, 16)) // token='*'
22117 )
22118 {
22119 D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default+ '/' '*'"));
22120 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected comma between / and *" );
22121 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22122 p->error_indicator = 1;
22123 p->level--;
22124 return NULL;
22125 }
22126 goto done;
22127 }
22128 p->mark = _mark;
22129 D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
22130 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default+ '/' '*'"));
22131 }
22132 _res = NULL;
22133 done:
22134 p->level--;
22135 return _res;
22136 }
22137
22138 // invalid_lambda_parameters_helper:
22139 // | lambda_slash_with_default
22140 // | lambda_param_with_default+
22141 static void *
22142 invalid_lambda_parameters_helper_rule(Parser *p)
22143 {
22144 if (p->level++ == MAXSTACK) {
22145 _Pypegen_stack_overflow(p);
22146 }
22147 if (p->error_indicator) {
22148 p->level--;
22149 return NULL;
22150 }
22151 void * _res = NULL;
22152 int _mark = p->mark;
22153 { // lambda_slash_with_default
22154 if (p->error_indicator) {
22155 p->level--;
22156 return NULL;
22157 }
22158 D(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
22159 SlashWithDefault* a;
22160 if (
22161 (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default
22162 )
22163 {
22164 D(fprintf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
22165 _res = _PyPegen_singleton_seq ( p , a );
22166 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22167 p->error_indicator = 1;
22168 p->level--;
22169 return NULL;
22170 }
22171 goto done;
22172 }
22173 p->mark = _mark;
22174 D(fprintf(stderr, "%*c%s invalid_lambda_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ',
22175 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default"));
22176 }
22177 { // lambda_param_with_default+
22178 if (p->error_indicator) {
22179 p->level--;
22180 return NULL;
22181 }
22182 D(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+"));
22183 asdl_seq * _loop1_197_var;
22184 if (
22185 (_loop1_197_var = _loop1_197_rule(p)) // lambda_param_with_default+
22186 )
22187 {
22188 D(fprintf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+"));
22189 _res = _loop1_197_var;
22190 goto done;
22191 }
22192 p->mark = _mark;
22193 D(fprintf(stderr, "%*c%s invalid_lambda_parameters_helper[%d-%d]: %s failed!\n", p->level, ' ',
22194 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+"));
22195 }
22196 _res = NULL;
22197 done:
22198 p->level--;
22199 return _res;
22200 }
22201
22202 // invalid_lambda_star_etc:
22203 // | '*' (':' | ',' (':' | '**'))
22204 // | '*' lambda_param '='
22205 // | '*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')
22206 static void *
22207 invalid_lambda_star_etc_rule(Parser *p)
22208 {
22209 if (p->level++ == MAXSTACK) {
22210 _Pypegen_stack_overflow(p);
22211 }
22212 if (p->error_indicator) {
22213 p->level--;
22214 return NULL;
22215 }
22216 void * _res = NULL;
22217 int _mark = p->mark;
22218 { // '*' (':' | ',' (':' | '**'))
22219 if (p->error_indicator) {
22220 p->level--;
22221 return NULL;
22222 }
22223 D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));
22224 Token * _literal;
22225 void *_tmp_198_var;
22226 if (
22227 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
22228 &&
22229 (_tmp_198_var = _tmp_198_rule(p)) // ':' | ',' (':' | '**')
22230 )
22231 {
22232 D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));
22233 _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" );
22234 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22235 p->error_indicator = 1;
22236 p->level--;
22237 return NULL;
22238 }
22239 goto done;
22240 }
22241 p->mark = _mark;
22242 D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
22243 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));
22244 }
22245 { // '*' lambda_param '='
22246 if (p->error_indicator) {
22247 p->level--;
22248 return NULL;
22249 }
22250 D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' lambda_param '='"));
22251 Token * _literal;
22252 Token * a;
22253 arg_ty lambda_param_var;
22254 if (
22255 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
22256 &&
22257 (lambda_param_var = lambda_param_rule(p)) // lambda_param
22258 &&
22259 (a = _PyPegen_expect_token(p, 22)) // token='='
22260 )
22261 {
22262 D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' lambda_param '='"));
22263 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-positional argument cannot have default value" );
22264 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22265 p->error_indicator = 1;
22266 p->level--;
22267 return NULL;
22268 }
22269 goto done;
22270 }
22271 p->mark = _mark;
22272 D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
22273 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param '='"));
22274 }
22275 { // '*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')
22276 if (p->error_indicator) {
22277 p->level--;
22278 return NULL;
22279 }
22280 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 | ',')"));
22281 Token * _literal;
22282 asdl_seq * _loop0_200_var;
22283 void *_tmp_199_var;
22284 void *_tmp_201_var;
22285 Token * a;
22286 if (
22287 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
22288 &&
22289 (_tmp_199_var = _tmp_199_rule(p)) // lambda_param_no_default | ','
22290 &&
22291 (_loop0_200_var = _loop0_200_rule(p)) // lambda_param_maybe_default*
22292 &&
22293 (a = _PyPegen_expect_token(p, 16)) // token='*'
22294 &&
22295 (_tmp_201_var = _tmp_201_rule(p)) // lambda_param_no_default | ','
22296 )
22297 {
22298 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 | ',')"));
22299 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "* argument may appear only once" );
22300 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22301 p->error_indicator = 1;
22302 p->level--;
22303 return NULL;
22304 }
22305 goto done;
22306 }
22307 p->mark = _mark;
22308 D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
22309 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')"));
22310 }
22311 _res = NULL;
22312 done:
22313 p->level--;
22314 return _res;
22315 }
22316
22317 // invalid_lambda_kwds:
22318 // | '**' lambda_param '='
22319 // | '**' lambda_param ',' lambda_param
22320 // | '**' lambda_param ',' ('*' | '**' | '/')
22321 static void *
22322 invalid_lambda_kwds_rule(Parser *p)
22323 {
22324 if (p->level++ == MAXSTACK) {
22325 _Pypegen_stack_overflow(p);
22326 }
22327 if (p->error_indicator) {
22328 p->level--;
22329 return NULL;
22330 }
22331 void * _res = NULL;
22332 int _mark = p->mark;
22333 { // '**' lambda_param '='
22334 if (p->error_indicator) {
22335 p->level--;
22336 return NULL;
22337 }
22338 D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param '='"));
22339 Token * _literal;
22340 Token * a;
22341 arg_ty lambda_param_var;
22342 if (
22343 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
22344 &&
22345 (lambda_param_var = lambda_param_rule(p)) // lambda_param
22346 &&
22347 (a = _PyPegen_expect_token(p, 22)) // token='='
22348 )
22349 {
22350 D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param '='"));
22351 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-keyword argument cannot have default value" );
22352 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22353 p->error_indicator = 1;
22354 p->level--;
22355 return NULL;
22356 }
22357 goto done;
22358 }
22359 p->mark = _mark;
22360 D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ',
22361 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param '='"));
22362 }
22363 { // '**' lambda_param ',' lambda_param
22364 if (p->error_indicator) {
22365 p->level--;
22366 return NULL;
22367 }
22368 D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' lambda_param"));
22369 Token * _literal;
22370 Token * _literal_1;
22371 arg_ty a;
22372 arg_ty lambda_param_var;
22373 if (
22374 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
22375 &&
22376 (lambda_param_var = lambda_param_rule(p)) // lambda_param
22377 &&
22378 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
22379 &&
22380 (a = lambda_param_rule(p)) // lambda_param
22381 )
22382 {
22383 D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' lambda_param"));
22384 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" );
22385 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22386 p->error_indicator = 1;
22387 p->level--;
22388 return NULL;
22389 }
22390 goto done;
22391 }
22392 p->mark = _mark;
22393 D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ',
22394 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param ',' lambda_param"));
22395 }
22396 { // '**' lambda_param ',' ('*' | '**' | '/')
22397 if (p->error_indicator) {
22398 p->level--;
22399 return NULL;
22400 }
22401 D(fprintf(stderr, "%*c> invalid_lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')"));
22402 Token * _literal;
22403 Token * _literal_1;
22404 Token* a;
22405 arg_ty lambda_param_var;
22406 if (
22407 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
22408 &&
22409 (lambda_param_var = lambda_param_rule(p)) // lambda_param
22410 &&
22411 (_literal_1 = _PyPegen_expect_token(p, 12)) // token=','
22412 &&
22413 (a = (Token*)_tmp_202_rule(p)) // '*' | '**' | '/'
22414 )
22415 {
22416 D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')"));
22417 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" );
22418 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22419 p->error_indicator = 1;
22420 p->level--;
22421 return NULL;
22422 }
22423 goto done;
22424 }
22425 p->mark = _mark;
22426 D(fprintf(stderr, "%*c%s invalid_lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ',
22427 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')"));
22428 }
22429 _res = NULL;
22430 done:
22431 p->level--;
22432 return _res;
22433 }
22434
22435 // invalid_double_type_comments: TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
22436 static void *
22437 invalid_double_type_comments_rule(Parser *p)
22438 {
22439 if (p->level++ == MAXSTACK) {
22440 _Pypegen_stack_overflow(p);
22441 }
22442 if (p->error_indicator) {
22443 p->level--;
22444 return NULL;
22445 }
22446 void * _res = NULL;
22447 int _mark = p->mark;
22448 { // TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
22449 if (p->error_indicator) {
22450 p->level--;
22451 return NULL;
22452 }
22453 D(fprintf(stderr, "%*c> invalid_double_type_comments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT"));
22454 Token * indent_var;
22455 Token * newline_var;
22456 Token * newline_var_1;
22457 Token * type_comment_var;
22458 Token * type_comment_var_1;
22459 if (
22460 (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
22461 &&
22462 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22463 &&
22464 (type_comment_var_1 = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT'
22465 &&
22466 (newline_var_1 = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22467 &&
22468 (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT'
22469 )
22470 {
22471 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"));
22472 _res = RAISE_SYNTAX_ERROR ( "Cannot have two type comments on def" );
22473 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22474 p->error_indicator = 1;
22475 p->level--;
22476 return NULL;
22477 }
22478 goto done;
22479 }
22480 p->mark = _mark;
22481 D(fprintf(stderr, "%*c%s invalid_double_type_comments[%d-%d]: %s failed!\n", p->level, ' ',
22482 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT"));
22483 }
22484 _res = NULL;
22485 done:
22486 p->level--;
22487 return _res;
22488 }
22489
22490 // invalid_with_item: expression 'as' expression &(',' | ')' | ':')
22491 static void *
22492 invalid_with_item_rule(Parser *p)
22493 {
22494 if (p->level++ == MAXSTACK) {
22495 _Pypegen_stack_overflow(p);
22496 }
22497 if (p->error_indicator) {
22498 p->level--;
22499 return NULL;
22500 }
22501 void * _res = NULL;
22502 int _mark = p->mark;
22503 { // expression 'as' expression &(',' | ')' | ':')
22504 if (p->error_indicator) {
22505 p->level--;
22506 return NULL;
22507 }
22508 D(fprintf(stderr, "%*c> invalid_with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' expression &(',' | ')' | ':')"));
22509 Token * _keyword;
22510 expr_ty a;
22511 expr_ty expression_var;
22512 if (
22513 (expression_var = expression_rule(p)) // expression
22514 &&
22515 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
22516 &&
22517 (a = expression_rule(p)) // expression
22518 &&
22519 _PyPegen_lookahead(1, _tmp_203_rule, p)
22520 )
22521 {
22522 D(fprintf(stderr, "%*c+ invalid_with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' expression &(',' | ')' | ':')"));
22523 _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a );
22524 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22525 p->error_indicator = 1;
22526 p->level--;
22527 return NULL;
22528 }
22529 goto done;
22530 }
22531 p->mark = _mark;
22532 D(fprintf(stderr, "%*c%s invalid_with_item[%d-%d]: %s failed!\n", p->level, ' ',
22533 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' expression &(',' | ')' | ':')"));
22534 }
22535 _res = NULL;
22536 done:
22537 p->level--;
22538 return _res;
22539 }
22540
22541 // invalid_for_target: 'async'? 'for' star_expressions
22542 static void *
22543 invalid_for_target_rule(Parser *p)
22544 {
22545 if (p->level++ == MAXSTACK) {
22546 _Pypegen_stack_overflow(p);
22547 }
22548 if (p->error_indicator) {
22549 p->level--;
22550 return NULL;
22551 }
22552 void * _res = NULL;
22553 int _mark = p->mark;
22554 { // 'async'? 'for' star_expressions
22555 if (p->error_indicator) {
22556 p->level--;
22557 return NULL;
22558 }
22559 D(fprintf(stderr, "%*c> invalid_for_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'for' star_expressions"));
22560 Token * _keyword;
22561 void *_opt_var;
22562 UNUSED(_opt_var); // Silence compiler warnings
22563 expr_ty a;
22564 if (
22565 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
22566 &&
22567 (_keyword = _PyPegen_expect_token(p, 670)) // token='for'
22568 &&
22569 (a = star_expressions_rule(p)) // star_expressions
22570 )
22571 {
22572 D(fprintf(stderr, "%*c+ invalid_for_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'? 'for' star_expressions"));
22573 _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( FOR_TARGETS , a );
22574 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22575 p->error_indicator = 1;
22576 p->level--;
22577 return NULL;
22578 }
22579 goto done;
22580 }
22581 p->mark = _mark;
22582 D(fprintf(stderr, "%*c%s invalid_for_target[%d-%d]: %s failed!\n", p->level, ' ',
22583 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'for' star_expressions"));
22584 }
22585 _res = NULL;
22586 done:
22587 p->level--;
22588 return _res;
22589 }
22590
22591 // invalid_group: '(' starred_expression ')' | '(' '**' expression ')'
22592 static void *
22593 invalid_group_rule(Parser *p)
22594 {
22595 if (p->level++ == MAXSTACK) {
22596 _Pypegen_stack_overflow(p);
22597 }
22598 if (p->error_indicator) {
22599 p->level--;
22600 return NULL;
22601 }
22602 void * _res = NULL;
22603 int _mark = p->mark;
22604 { // '(' starred_expression ')'
22605 if (p->error_indicator) {
22606 p->level--;
22607 return NULL;
22608 }
22609 D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'"));
22610 Token * _literal;
22611 Token * _literal_1;
22612 expr_ty a;
22613 if (
22614 (_literal = _PyPegen_expect_token(p, 7)) // token='('
22615 &&
22616 (a = starred_expression_rule(p)) // starred_expression
22617 &&
22618 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
22619 )
22620 {
22621 D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'"));
22622 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use starred expression here" );
22623 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22624 p->error_indicator = 1;
22625 p->level--;
22626 return NULL;
22627 }
22628 goto done;
22629 }
22630 p->mark = _mark;
22631 D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ',
22632 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' starred_expression ')'"));
22633 }
22634 { // '(' '**' expression ')'
22635 if (p->error_indicator) {
22636 p->level--;
22637 return NULL;
22638 }
22639 D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' '**' expression ')'"));
22640 Token * _literal;
22641 Token * _literal_1;
22642 Token * a;
22643 expr_ty expression_var;
22644 if (
22645 (_literal = _PyPegen_expect_token(p, 7)) // token='('
22646 &&
22647 (a = _PyPegen_expect_token(p, 35)) // token='**'
22648 &&
22649 (expression_var = expression_rule(p)) // expression
22650 &&
22651 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
22652 )
22653 {
22654 D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' '**' expression ')'"));
22655 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use double starred expression here" );
22656 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22657 p->error_indicator = 1;
22658 p->level--;
22659 return NULL;
22660 }
22661 goto done;
22662 }
22663 p->mark = _mark;
22664 D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ',
22665 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' '**' expression ')'"));
22666 }
22667 _res = NULL;
22668 done:
22669 p->level--;
22670 return _res;
22671 }
22672
22673 // invalid_import: 'import' ','.dotted_name+ 'from' dotted_name | 'import' NEWLINE
22674 static void *
22675 invalid_import_rule(Parser *p)
22676 {
22677 if (p->level++ == MAXSTACK) {
22678 _Pypegen_stack_overflow(p);
22679 }
22680 if (p->error_indicator) {
22681 p->level--;
22682 return NULL;
22683 }
22684 void * _res = NULL;
22685 int _mark = p->mark;
22686 { // 'import' ','.dotted_name+ 'from' dotted_name
22687 if (p->error_indicator) {
22688 p->level--;
22689 return NULL;
22690 }
22691 D(fprintf(stderr, "%*c> invalid_import[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' ','.dotted_name+ 'from' dotted_name"));
22692 asdl_seq * _gather_204_var;
22693 Token * _keyword;
22694 Token * a;
22695 expr_ty dotted_name_var;
22696 if (
22697 (a = _PyPegen_expect_token(p, 622)) // token='import'
22698 &&
22699 (_gather_204_var = _gather_204_rule(p)) // ','.dotted_name+
22700 &&
22701 (_keyword = _PyPegen_expect_token(p, 621)) // token='from'
22702 &&
22703 (dotted_name_var = dotted_name_rule(p)) // dotted_name
22704 )
22705 {
22706 D(fprintf(stderr, "%*c+ invalid_import[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' ','.dotted_name+ 'from' dotted_name"));
22707 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "Did you mean to use 'from ... import ...' instead?" );
22708 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22709 p->error_indicator = 1;
22710 p->level--;
22711 return NULL;
22712 }
22713 goto done;
22714 }
22715 p->mark = _mark;
22716 D(fprintf(stderr, "%*c%s invalid_import[%d-%d]: %s failed!\n", p->level, ' ',
22717 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import' ','.dotted_name+ 'from' dotted_name"));
22718 }
22719 { // 'import' NEWLINE
22720 if (p->error_indicator) {
22721 p->level--;
22722 return NULL;
22723 }
22724 D(fprintf(stderr, "%*c> invalid_import[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' NEWLINE"));
22725 Token * _keyword;
22726 Token * token;
22727 if (
22728 (_keyword = _PyPegen_expect_token(p, 622)) // token='import'
22729 &&
22730 (token = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22731 )
22732 {
22733 D(fprintf(stderr, "%*c+ invalid_import[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' NEWLINE"));
22734 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( token , "Expected one or more names after 'import'" );
22735 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22736 p->error_indicator = 1;
22737 p->level--;
22738 return NULL;
22739 }
22740 goto done;
22741 }
22742 p->mark = _mark;
22743 D(fprintf(stderr, "%*c%s invalid_import[%d-%d]: %s failed!\n", p->level, ' ',
22744 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import' NEWLINE"));
22745 }
22746 _res = NULL;
22747 done:
22748 p->level--;
22749 return _res;
22750 }
22751
22752 // invalid_import_from_targets: import_from_as_names ',' NEWLINE | NEWLINE
22753 static void *
22754 invalid_import_from_targets_rule(Parser *p)
22755 {
22756 if (p->level++ == MAXSTACK) {
22757 _Pypegen_stack_overflow(p);
22758 }
22759 if (p->error_indicator) {
22760 p->level--;
22761 return NULL;
22762 }
22763 void * _res = NULL;
22764 int _mark = p->mark;
22765 { // import_from_as_names ',' NEWLINE
22766 if (p->error_indicator) {
22767 p->level--;
22768 return NULL;
22769 }
22770 D(fprintf(stderr, "%*c> invalid_import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE"));
22771 Token * _literal;
22772 asdl_alias_seq* import_from_as_names_var;
22773 Token * newline_var;
22774 if (
22775 (import_from_as_names_var = import_from_as_names_rule(p)) // import_from_as_names
22776 &&
22777 (_literal = _PyPegen_expect_token(p, 12)) // token=','
22778 &&
22779 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22780 )
22781 {
22782 D(fprintf(stderr, "%*c+ invalid_import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE"));
22783 _res = RAISE_SYNTAX_ERROR ( "trailing comma not allowed without surrounding parentheses" );
22784 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22785 p->error_indicator = 1;
22786 p->level--;
22787 return NULL;
22788 }
22789 goto done;
22790 }
22791 p->mark = _mark;
22792 D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
22793 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names ',' NEWLINE"));
22794 }
22795 { // NEWLINE
22796 if (p->error_indicator) {
22797 p->level--;
22798 return NULL;
22799 }
22800 D(fprintf(stderr, "%*c> invalid_import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
22801 Token * token;
22802 if (
22803 (token = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22804 )
22805 {
22806 D(fprintf(stderr, "%*c+ invalid_import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
22807 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( token , "Expected one or more names after 'import'" );
22808 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22809 p->error_indicator = 1;
22810 p->level--;
22811 return NULL;
22812 }
22813 goto done;
22814 }
22815 p->mark = _mark;
22816 D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
22817 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
22818 }
22819 _res = NULL;
22820 done:
22821 p->level--;
22822 return _res;
22823 }
22824
22825 // invalid_with_stmt:
22826 // | 'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE
22827 // | 'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE
22828 static void *
22829 invalid_with_stmt_rule(Parser *p)
22830 {
22831 if (p->level++ == MAXSTACK) {
22832 _Pypegen_stack_overflow(p);
22833 }
22834 if (p->error_indicator) {
22835 p->level--;
22836 return NULL;
22837 }
22838 void * _res = NULL;
22839 int _mark = p->mark;
22840 { // 'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE
22841 if (p->error_indicator) {
22842 p->level--;
22843 return NULL;
22844 }
22845 D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE"));
22846 asdl_seq * _gather_206_var;
22847 Token * _keyword;
22848 void *_opt_var;
22849 UNUSED(_opt_var); // Silence compiler warnings
22850 Token * newline_var;
22851 if (
22852 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
22853 &&
22854 (_keyword = _PyPegen_expect_token(p, 633)) // token='with'
22855 &&
22856 (_gather_206_var = _gather_206_rule(p)) // ','.(expression ['as' star_target])+
22857 &&
22858 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22859 )
22860 {
22861 D(fprintf(stderr, "%*c+ invalid_with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE"));
22862 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
22863 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22864 p->error_indicator = 1;
22865 p->level--;
22866 return NULL;
22867 }
22868 goto done;
22869 }
22870 p->mark = _mark;
22871 D(fprintf(stderr, "%*c%s invalid_with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
22872 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE"));
22873 }
22874 { // 'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE
22875 if (p->error_indicator) {
22876 p->level--;
22877 return NULL;
22878 }
22879 D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE"));
22880 asdl_seq * _gather_208_var;
22881 Token * _keyword;
22882 Token * _literal;
22883 Token * _literal_1;
22884 void *_opt_var;
22885 UNUSED(_opt_var); // Silence compiler warnings
22886 void *_opt_var_1;
22887 UNUSED(_opt_var_1); // Silence compiler warnings
22888 Token * newline_var;
22889 if (
22890 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
22891 &&
22892 (_keyword = _PyPegen_expect_token(p, 633)) // token='with'
22893 &&
22894 (_literal = _PyPegen_expect_token(p, 7)) // token='('
22895 &&
22896 (_gather_208_var = _gather_208_rule(p)) // ','.(expressions ['as' star_target])+
22897 &&
22898 (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
22899 &&
22900 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
22901 &&
22902 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22903 )
22904 {
22905 D(fprintf(stderr, "%*c+ invalid_with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE"));
22906 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
22907 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22908 p->error_indicator = 1;
22909 p->level--;
22910 return NULL;
22911 }
22912 goto done;
22913 }
22914 p->mark = _mark;
22915 D(fprintf(stderr, "%*c%s invalid_with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
22916 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE"));
22917 }
22918 _res = NULL;
22919 done:
22920 p->level--;
22921 return _res;
22922 }
22923
22924 // invalid_with_stmt_indent:
22925 // | 'async'? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT
22926 // | 'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT
22927 static void *
22928 invalid_with_stmt_indent_rule(Parser *p)
22929 {
22930 if (p->level++ == MAXSTACK) {
22931 _Pypegen_stack_overflow(p);
22932 }
22933 if (p->error_indicator) {
22934 p->level--;
22935 return NULL;
22936 }
22937 void * _res = NULL;
22938 int _mark = p->mark;
22939 { // 'async'? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT
22940 if (p->error_indicator) {
22941 p->level--;
22942 return NULL;
22943 }
22944 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"));
22945 asdl_seq * _gather_210_var;
22946 Token * _literal;
22947 void *_opt_var;
22948 UNUSED(_opt_var); // Silence compiler warnings
22949 Token * a;
22950 Token * newline_var;
22951 if (
22952 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
22953 &&
22954 (a = _PyPegen_expect_token(p, 633)) // token='with'
22955 &&
22956 (_gather_210_var = _gather_210_rule(p)) // ','.(expression ['as' star_target])+
22957 &&
22958 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
22959 &&
22960 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
22961 &&
22962 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
22963 )
22964 {
22965 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"));
22966 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno );
22967 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
22968 p->error_indicator = 1;
22969 p->level--;
22970 return NULL;
22971 }
22972 goto done;
22973 }
22974 p->mark = _mark;
22975 D(fprintf(stderr, "%*c%s invalid_with_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',
22976 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT"));
22977 }
22978 { // 'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT
22979 if (p->error_indicator) {
22980 p->level--;
22981 return NULL;
22982 }
22983 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"));
22984 asdl_seq * _gather_212_var;
22985 Token * _literal;
22986 Token * _literal_1;
22987 Token * _literal_2;
22988 void *_opt_var;
22989 UNUSED(_opt_var); // Silence compiler warnings
22990 void *_opt_var_1;
22991 UNUSED(_opt_var_1); // Silence compiler warnings
22992 Token * a;
22993 Token * newline_var;
22994 if (
22995 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
22996 &&
22997 (a = _PyPegen_expect_token(p, 633)) // token='with'
22998 &&
22999 (_literal = _PyPegen_expect_token(p, 7)) // token='('
23000 &&
23001 (_gather_212_var = _gather_212_rule(p)) // ','.(expressions ['as' star_target])+
23002 &&
23003 (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
23004 &&
23005 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
23006 &&
23007 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
23008 &&
23009 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23010 &&
23011 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
23012 )
23013 {
23014 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"));
23015 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno );
23016 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23017 p->error_indicator = 1;
23018 p->level--;
23019 return NULL;
23020 }
23021 goto done;
23022 }
23023 p->mark = _mark;
23024 D(fprintf(stderr, "%*c%s invalid_with_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',
23025 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT"));
23026 }
23027 _res = NULL;
23028 done:
23029 p->level--;
23030 return _res;
23031 }
23032
23033 // invalid_try_stmt:
23034 // | 'try' ':' NEWLINE !INDENT
23035 // | 'try' ':' block !('except' | 'finally')
23036 // | 'try' ':' block* except_block+ 'except' '*' expression ['as' NAME] ':'
23037 // | 'try' ':' block* except_star_block+ 'except' [expression ['as' NAME]] ':'
23038 static void *
23039 invalid_try_stmt_rule(Parser *p)
23040 {
23041 if (p->level++ == MAXSTACK) {
23042 _Pypegen_stack_overflow(p);
23043 }
23044 if (p->error_indicator) {
23045 p->level--;
23046 return NULL;
23047 }
23048 void * _res = NULL;
23049 int _mark = p->mark;
23050 { // 'try' ':' NEWLINE !INDENT
23051 if (p->error_indicator) {
23052 p->level--;
23053 return NULL;
23054 }
23055 D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' NEWLINE !INDENT"));
23056 Token * _literal;
23057 Token * a;
23058 Token * newline_var;
23059 if (
23060 (a = _PyPegen_expect_token(p, 642)) // token='try'
23061 &&
23062 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23063 &&
23064 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23065 &&
23066 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
23067 )
23068 {
23069 D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' NEWLINE !INDENT"));
23070 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'try' statement on line %d" , a -> lineno );
23071 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23072 p->error_indicator = 1;
23073 p->level--;
23074 return NULL;
23075 }
23076 goto done;
23077 }
23078 p->mark = _mark;
23079 D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23080 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' NEWLINE !INDENT"));
23081 }
23082 { // 'try' ':' block !('except' | 'finally')
23083 if (p->error_indicator) {
23084 p->level--;
23085 return NULL;
23086 }
23087 D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')"));
23088 Token * _keyword;
23089 Token * _literal;
23090 asdl_stmt_seq* block_var;
23091 if (
23092 (_keyword = _PyPegen_expect_token(p, 642)) // token='try'
23093 &&
23094 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23095 &&
23096 (block_var = block_rule(p)) // block
23097 &&
23098 _PyPegen_lookahead(0, _tmp_214_rule, p)
23099 )
23100 {
23101 D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')"));
23102 _res = RAISE_SYNTAX_ERROR ( "expected 'except' or 'finally' block" );
23103 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23104 p->error_indicator = 1;
23105 p->level--;
23106 return NULL;
23107 }
23108 goto done;
23109 }
23110 p->mark = _mark;
23111 D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23112 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block !('except' | 'finally')"));
23113 }
23114 { // 'try' ':' block* except_block+ 'except' '*' expression ['as' NAME] ':'
23115 if (p->error_indicator) {
23116 p->level--;
23117 return NULL;
23118 }
23119 D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block* except_block+ 'except' '*' expression ['as' NAME] ':'"));
23120 Token * _keyword;
23121 Token * _literal;
23122 Token * _literal_1;
23123 asdl_seq * _loop0_215_var;
23124 asdl_seq * _loop1_216_var;
23125 void *_opt_var;
23126 UNUSED(_opt_var); // Silence compiler warnings
23127 Token * a;
23128 Token * b;
23129 expr_ty expression_var;
23130 if (
23131 (_keyword = _PyPegen_expect_token(p, 642)) // token='try'
23132 &&
23133 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23134 &&
23135 (_loop0_215_var = _loop0_215_rule(p)) // block*
23136 &&
23137 (_loop1_216_var = _loop1_216_rule(p)) // except_block+
23138 &&
23139 (a = _PyPegen_expect_token(p, 655)) // token='except'
23140 &&
23141 (b = _PyPegen_expect_token(p, 16)) // token='*'
23142 &&
23143 (expression_var = expression_rule(p)) // expression
23144 &&
23145 (_opt_var = _tmp_217_rule(p), !p->error_indicator) // ['as' NAME]
23146 &&
23147 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
23148 )
23149 {
23150 D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block* except_block+ 'except' '*' expression ['as' NAME] ':'"));
23151 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot have both 'except' and 'except*' on the same 'try'" );
23152 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23153 p->error_indicator = 1;
23154 p->level--;
23155 return NULL;
23156 }
23157 goto done;
23158 }
23159 p->mark = _mark;
23160 D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23161 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block* except_block+ 'except' '*' expression ['as' NAME] ':'"));
23162 }
23163 { // 'try' ':' block* except_star_block+ 'except' [expression ['as' NAME]] ':'
23164 if (p->error_indicator) {
23165 p->level--;
23166 return NULL;
23167 }
23168 D(fprintf(stderr, "%*c> invalid_try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block* except_star_block+ 'except' [expression ['as' NAME]] ':'"));
23169 Token * _keyword;
23170 Token * _literal;
23171 Token * _literal_1;
23172 asdl_seq * _loop0_218_var;
23173 asdl_seq * _loop1_219_var;
23174 void *_opt_var;
23175 UNUSED(_opt_var); // Silence compiler warnings
23176 Token * a;
23177 if (
23178 (_keyword = _PyPegen_expect_token(p, 642)) // token='try'
23179 &&
23180 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23181 &&
23182 (_loop0_218_var = _loop0_218_rule(p)) // block*
23183 &&
23184 (_loop1_219_var = _loop1_219_rule(p)) // except_star_block+
23185 &&
23186 (a = _PyPegen_expect_token(p, 655)) // token='except'
23187 &&
23188 (_opt_var = _tmp_220_rule(p), !p->error_indicator) // [expression ['as' NAME]]
23189 &&
23190 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
23191 )
23192 {
23193 D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block* except_star_block+ 'except' [expression ['as' NAME]] ':'"));
23194 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot have both 'except' and 'except*' on the same 'try'" );
23195 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23196 p->error_indicator = 1;
23197 p->level--;
23198 return NULL;
23199 }
23200 goto done;
23201 }
23202 p->mark = _mark;
23203 D(fprintf(stderr, "%*c%s invalid_try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23204 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block* except_star_block+ 'except' [expression ['as' NAME]] ':'"));
23205 }
23206 _res = NULL;
23207 done:
23208 p->level--;
23209 return _res;
23210 }
23211
23212 // invalid_except_stmt:
23213 // | 'except' '*'? expression ',' expressions ['as' NAME] ':'
23214 // | 'except' '*'? expression ['as' NAME] NEWLINE
23215 // | 'except' NEWLINE
23216 // | 'except' '*' (NEWLINE | ':')
23217 static void *
23218 invalid_except_stmt_rule(Parser *p)
23219 {
23220 if (p->level++ == MAXSTACK) {
23221 _Pypegen_stack_overflow(p);
23222 }
23223 if (p->error_indicator) {
23224 p->level--;
23225 return NULL;
23226 }
23227 void * _res = NULL;
23228 int _mark = p->mark;
23229 { // 'except' '*'? expression ',' expressions ['as' NAME] ':'
23230 if (p->error_indicator) {
23231 p->level--;
23232 return NULL;
23233 }
23234 D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*'? expression ',' expressions ['as' NAME] ':'"));
23235 Token * _keyword;
23236 Token * _literal;
23237 Token * _literal_1;
23238 void *_opt_var;
23239 UNUSED(_opt_var); // Silence compiler warnings
23240 void *_opt_var_1;
23241 UNUSED(_opt_var_1); // Silence compiler warnings
23242 expr_ty a;
23243 expr_ty expressions_var;
23244 if (
23245 (_keyword = _PyPegen_expect_token(p, 655)) // token='except'
23246 &&
23247 (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'?
23248 &&
23249 (a = expression_rule(p)) // expression
23250 &&
23251 (_literal = _PyPegen_expect_token(p, 12)) // token=','
23252 &&
23253 (expressions_var = expressions_rule(p)) // expressions
23254 &&
23255 (_opt_var_1 = _tmp_221_rule(p), !p->error_indicator) // ['as' NAME]
23256 &&
23257 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
23258 )
23259 {
23260 D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*'? expression ',' expressions ['as' NAME] ':'"));
23261 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "multiple exception types must be parenthesized" );
23262 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23263 p->error_indicator = 1;
23264 p->level--;
23265 return NULL;
23266 }
23267 goto done;
23268 }
23269 p->mark = _mark;
23270 D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23271 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*'? expression ',' expressions ['as' NAME] ':'"));
23272 }
23273 { // 'except' '*'? expression ['as' NAME] NEWLINE
23274 if (p->error_indicator) {
23275 p->level--;
23276 return NULL;
23277 }
23278 D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*'? expression ['as' NAME] NEWLINE"));
23279 void *_opt_var;
23280 UNUSED(_opt_var); // Silence compiler warnings
23281 void *_opt_var_1;
23282 UNUSED(_opt_var_1); // Silence compiler warnings
23283 Token * a;
23284 expr_ty expression_var;
23285 Token * newline_var;
23286 if (
23287 (a = _PyPegen_expect_token(p, 655)) // token='except'
23288 &&
23289 (_opt_var = _PyPegen_expect_token(p, 16), !p->error_indicator) // '*'?
23290 &&
23291 (expression_var = expression_rule(p)) // expression
23292 &&
23293 (_opt_var_1 = _tmp_222_rule(p), !p->error_indicator) // ['as' NAME]
23294 &&
23295 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23296 )
23297 {
23298 D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*'? expression ['as' NAME] NEWLINE"));
23299 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
23300 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23301 p->error_indicator = 1;
23302 p->level--;
23303 return NULL;
23304 }
23305 goto done;
23306 }
23307 p->mark = _mark;
23308 D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23309 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*'? expression ['as' NAME] NEWLINE"));
23310 }
23311 { // 'except' NEWLINE
23312 if (p->error_indicator) {
23313 p->level--;
23314 return NULL;
23315 }
23316 D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' NEWLINE"));
23317 Token * a;
23318 Token * newline_var;
23319 if (
23320 (a = _PyPegen_expect_token(p, 655)) // token='except'
23321 &&
23322 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23323 )
23324 {
23325 D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' NEWLINE"));
23326 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
23327 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23328 p->error_indicator = 1;
23329 p->level--;
23330 return NULL;
23331 }
23332 goto done;
23333 }
23334 p->mark = _mark;
23335 D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23336 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' NEWLINE"));
23337 }
23338 { // 'except' '*' (NEWLINE | ':')
23339 if (p->error_indicator) {
23340 p->level--;
23341 return NULL;
23342 }
23343 D(fprintf(stderr, "%*c> invalid_except_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')"));
23344 Token * _literal;
23345 void *_tmp_223_var;
23346 Token * a;
23347 if (
23348 (a = _PyPegen_expect_token(p, 655)) // token='except'
23349 &&
23350 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
23351 &&
23352 (_tmp_223_var = _tmp_223_rule(p)) // NEWLINE | ':'
23353 )
23354 {
23355 D(fprintf(stderr, "%*c+ invalid_except_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')"));
23356 _res = RAISE_SYNTAX_ERROR ( "expected one or more exception types" );
23357 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23358 p->error_indicator = 1;
23359 p->level--;
23360 return NULL;
23361 }
23362 goto done;
23363 }
23364 p->mark = _mark;
23365 D(fprintf(stderr, "%*c%s invalid_except_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23366 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' (NEWLINE | ':')"));
23367 }
23368 _res = NULL;
23369 done:
23370 p->level--;
23371 return _res;
23372 }
23373
23374 // invalid_finally_stmt: 'finally' ':' NEWLINE !INDENT
23375 static void *
23376 invalid_finally_stmt_rule(Parser *p)
23377 {
23378 if (p->level++ == MAXSTACK) {
23379 _Pypegen_stack_overflow(p);
23380 }
23381 if (p->error_indicator) {
23382 p->level--;
23383 return NULL;
23384 }
23385 void * _res = NULL;
23386 int _mark = p->mark;
23387 { // 'finally' ':' NEWLINE !INDENT
23388 if (p->error_indicator) {
23389 p->level--;
23390 return NULL;
23391 }
23392 D(fprintf(stderr, "%*c> invalid_finally_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' ':' NEWLINE !INDENT"));
23393 Token * _literal;
23394 Token * a;
23395 Token * newline_var;
23396 if (
23397 (a = _PyPegen_expect_token(p, 651)) // token='finally'
23398 &&
23399 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23400 &&
23401 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23402 &&
23403 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
23404 )
23405 {
23406 D(fprintf(stderr, "%*c+ invalid_finally_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally' ':' NEWLINE !INDENT"));
23407 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'finally' statement on line %d" , a -> lineno );
23408 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23409 p->error_indicator = 1;
23410 p->level--;
23411 return NULL;
23412 }
23413 goto done;
23414 }
23415 p->mark = _mark;
23416 D(fprintf(stderr, "%*c%s invalid_finally_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23417 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' ':' NEWLINE !INDENT"));
23418 }
23419 _res = NULL;
23420 done:
23421 p->level--;
23422 return _res;
23423 }
23424
23425 // invalid_except_stmt_indent:
23426 // | 'except' expression ['as' NAME] ':' NEWLINE !INDENT
23427 // | 'except' ':' NEWLINE !INDENT
23428 static void *
23429 invalid_except_stmt_indent_rule(Parser *p)
23430 {
23431 if (p->level++ == MAXSTACK) {
23432 _Pypegen_stack_overflow(p);
23433 }
23434 if (p->error_indicator) {
23435 p->level--;
23436 return NULL;
23437 }
23438 void * _res = NULL;
23439 int _mark = p->mark;
23440 { // 'except' expression ['as' NAME] ':' NEWLINE !INDENT
23441 if (p->error_indicator) {
23442 p->level--;
23443 return NULL;
23444 }
23445 D(fprintf(stderr, "%*c> invalid_except_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' NEWLINE !INDENT"));
23446 Token * _literal;
23447 void *_opt_var;
23448 UNUSED(_opt_var); // Silence compiler warnings
23449 Token * a;
23450 expr_ty expression_var;
23451 Token * newline_var;
23452 if (
23453 (a = _PyPegen_expect_token(p, 655)) // token='except'
23454 &&
23455 (expression_var = expression_rule(p)) // expression
23456 &&
23457 (_opt_var = _tmp_224_rule(p), !p->error_indicator) // ['as' NAME]
23458 &&
23459 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23460 &&
23461 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23462 &&
23463 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
23464 )
23465 {
23466 D(fprintf(stderr, "%*c+ invalid_except_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' NEWLINE !INDENT"));
23467 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno );
23468 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23469 p->error_indicator = 1;
23470 p->level--;
23471 return NULL;
23472 }
23473 goto done;
23474 }
23475 p->mark = _mark;
23476 D(fprintf(stderr, "%*c%s invalid_except_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',
23477 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' NEWLINE !INDENT"));
23478 }
23479 { // 'except' ':' NEWLINE !INDENT
23480 if (p->error_indicator) {
23481 p->level--;
23482 return NULL;
23483 }
23484 D(fprintf(stderr, "%*c> invalid_except_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' NEWLINE !INDENT"));
23485 Token * _literal;
23486 Token * a;
23487 Token * newline_var;
23488 if (
23489 (a = _PyPegen_expect_token(p, 655)) // token='except'
23490 &&
23491 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23492 &&
23493 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23494 &&
23495 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
23496 )
23497 {
23498 D(fprintf(stderr, "%*c+ invalid_except_stmt_indent[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' NEWLINE !INDENT"));
23499 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno );
23500 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23501 p->error_indicator = 1;
23502 p->level--;
23503 return NULL;
23504 }
23505 goto done;
23506 }
23507 p->mark = _mark;
23508 D(fprintf(stderr, "%*c%s invalid_except_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',
23509 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' NEWLINE !INDENT"));
23510 }
23511 _res = NULL;
23512 done:
23513 p->level--;
23514 return _res;
23515 }
23516
23517 // invalid_except_star_stmt_indent:
23518 // | 'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT
23519 static void *
23520 invalid_except_star_stmt_indent_rule(Parser *p)
23521 {
23522 if (p->level++ == MAXSTACK) {
23523 _Pypegen_stack_overflow(p);
23524 }
23525 if (p->error_indicator) {
23526 p->level--;
23527 return NULL;
23528 }
23529 void * _res = NULL;
23530 int _mark = p->mark;
23531 { // 'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT
23532 if (p->error_indicator) {
23533 p->level--;
23534 return NULL;
23535 }
23536 D(fprintf(stderr, "%*c> invalid_except_star_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT"));
23537 Token * _literal;
23538 Token * _literal_1;
23539 void *_opt_var;
23540 UNUSED(_opt_var); // Silence compiler warnings
23541 Token * a;
23542 expr_ty expression_var;
23543 Token * newline_var;
23544 if (
23545 (a = _PyPegen_expect_token(p, 655)) // token='except'
23546 &&
23547 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
23548 &&
23549 (expression_var = expression_rule(p)) // expression
23550 &&
23551 (_opt_var = _tmp_225_rule(p), !p->error_indicator) // ['as' NAME]
23552 &&
23553 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
23554 &&
23555 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23556 &&
23557 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
23558 )
23559 {
23560 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"));
23561 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'except*' statement on line %d" , a -> lineno );
23562 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23563 p->error_indicator = 1;
23564 p->level--;
23565 return NULL;
23566 }
23567 goto done;
23568 }
23569 p->mark = _mark;
23570 D(fprintf(stderr, "%*c%s invalid_except_star_stmt_indent[%d-%d]: %s failed!\n", p->level, ' ',
23571 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT"));
23572 }
23573 _res = NULL;
23574 done:
23575 p->level--;
23576 return _res;
23577 }
23578
23579 // invalid_match_stmt:
23580 // | "match" subject_expr NEWLINE
23581 // | "match" subject_expr ':' NEWLINE !INDENT
23582 static void *
23583 invalid_match_stmt_rule(Parser *p)
23584 {
23585 if (p->level++ == MAXSTACK) {
23586 _Pypegen_stack_overflow(p);
23587 }
23588 if (p->error_indicator) {
23589 p->level--;
23590 return NULL;
23591 }
23592 void * _res = NULL;
23593 int _mark = p->mark;
23594 { // "match" subject_expr NEWLINE
23595 if (p->error_indicator) {
23596 p->level--;
23597 return NULL;
23598 }
23599 D(fprintf(stderr, "%*c> invalid_match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr NEWLINE"));
23600 expr_ty _keyword;
23601 Token * newline_var;
23602 expr_ty subject_expr_var;
23603 if (
23604 (_keyword = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"'
23605 &&
23606 (subject_expr_var = subject_expr_rule(p)) // subject_expr
23607 &&
23608 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23609 )
23610 {
23611 D(fprintf(stderr, "%*c+ invalid_match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr NEWLINE"));
23612 _res = CHECK_VERSION ( void* , 10 , "Pattern matching is" , RAISE_SYNTAX_ERROR ( "expected ':'" ) );
23613 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23614 p->error_indicator = 1;
23615 p->level--;
23616 return NULL;
23617 }
23618 goto done;
23619 }
23620 p->mark = _mark;
23621 D(fprintf(stderr, "%*c%s invalid_match_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23622 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr NEWLINE"));
23623 }
23624 { // "match" subject_expr ':' NEWLINE !INDENT
23625 if (p->error_indicator) {
23626 p->level--;
23627 return NULL;
23628 }
23629 D(fprintf(stderr, "%*c> invalid_match_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr ':' NEWLINE !INDENT"));
23630 Token * _literal;
23631 expr_ty a;
23632 Token * newline_var;
23633 expr_ty subject;
23634 if (
23635 (a = _PyPegen_expect_soft_keyword(p, "match")) // soft_keyword='"match"'
23636 &&
23637 (subject = subject_expr_rule(p)) // subject_expr
23638 &&
23639 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23640 &&
23641 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23642 &&
23643 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
23644 )
23645 {
23646 D(fprintf(stderr, "%*c+ invalid_match_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"match\" subject_expr ':' NEWLINE !INDENT"));
23647 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'match' statement on line %d" , a -> lineno );
23648 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23649 p->error_indicator = 1;
23650 p->level--;
23651 return NULL;
23652 }
23653 goto done;
23654 }
23655 p->mark = _mark;
23656 D(fprintf(stderr, "%*c%s invalid_match_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23657 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"match\" subject_expr ':' NEWLINE !INDENT"));
23658 }
23659 _res = NULL;
23660 done:
23661 p->level--;
23662 return _res;
23663 }
23664
23665 // invalid_case_block:
23666 // | "case" patterns guard? NEWLINE
23667 // | "case" patterns guard? ':' NEWLINE !INDENT
23668 static void *
23669 invalid_case_block_rule(Parser *p)
23670 {
23671 if (p->level++ == MAXSTACK) {
23672 _Pypegen_stack_overflow(p);
23673 }
23674 if (p->error_indicator) {
23675 p->level--;
23676 return NULL;
23677 }
23678 void * _res = NULL;
23679 int _mark = p->mark;
23680 { // "case" patterns guard? NEWLINE
23681 if (p->error_indicator) {
23682 p->level--;
23683 return NULL;
23684 }
23685 D(fprintf(stderr, "%*c> invalid_case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? NEWLINE"));
23686 expr_ty _keyword;
23687 void *_opt_var;
23688 UNUSED(_opt_var); // Silence compiler warnings
23689 Token * newline_var;
23690 pattern_ty patterns_var;
23691 if (
23692 (_keyword = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"'
23693 &&
23694 (patterns_var = patterns_rule(p)) // patterns
23695 &&
23696 (_opt_var = guard_rule(p), !p->error_indicator) // guard?
23697 &&
23698 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23699 )
23700 {
23701 D(fprintf(stderr, "%*c+ invalid_case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? NEWLINE"));
23702 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
23703 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23704 p->error_indicator = 1;
23705 p->level--;
23706 return NULL;
23707 }
23708 goto done;
23709 }
23710 p->mark = _mark;
23711 D(fprintf(stderr, "%*c%s invalid_case_block[%d-%d]: %s failed!\n", p->level, ' ',
23712 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? NEWLINE"));
23713 }
23714 { // "case" patterns guard? ':' NEWLINE !INDENT
23715 if (p->error_indicator) {
23716 p->level--;
23717 return NULL;
23718 }
23719 D(fprintf(stderr, "%*c> invalid_case_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' NEWLINE !INDENT"));
23720 Token * _literal;
23721 void *_opt_var;
23722 UNUSED(_opt_var); // Silence compiler warnings
23723 expr_ty a;
23724 Token * newline_var;
23725 pattern_ty patterns_var;
23726 if (
23727 (a = _PyPegen_expect_soft_keyword(p, "case")) // soft_keyword='"case"'
23728 &&
23729 (patterns_var = patterns_rule(p)) // patterns
23730 &&
23731 (_opt_var = guard_rule(p), !p->error_indicator) // guard?
23732 &&
23733 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
23734 &&
23735 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23736 &&
23737 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
23738 )
23739 {
23740 D(fprintf(stderr, "%*c+ invalid_case_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "\"case\" patterns guard? ':' NEWLINE !INDENT"));
23741 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'case' statement on line %d" , a -> lineno );
23742 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23743 p->error_indicator = 1;
23744 p->level--;
23745 return NULL;
23746 }
23747 goto done;
23748 }
23749 p->mark = _mark;
23750 D(fprintf(stderr, "%*c%s invalid_case_block[%d-%d]: %s failed!\n", p->level, ' ',
23751 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"case\" patterns guard? ':' NEWLINE !INDENT"));
23752 }
23753 _res = NULL;
23754 done:
23755 p->level--;
23756 return _res;
23757 }
23758
23759 // invalid_as_pattern: or_pattern 'as' "_" | or_pattern 'as' !NAME expression
23760 static void *
23761 invalid_as_pattern_rule(Parser *p)
23762 {
23763 if (p->level++ == MAXSTACK) {
23764 _Pypegen_stack_overflow(p);
23765 }
23766 if (p->error_indicator) {
23767 p->level--;
23768 return NULL;
23769 }
23770 void * _res = NULL;
23771 int _mark = p->mark;
23772 { // or_pattern 'as' "_"
23773 if (p->error_indicator) {
23774 p->level--;
23775 return NULL;
23776 }
23777 D(fprintf(stderr, "%*c> invalid_as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' \"_\""));
23778 Token * _keyword;
23779 expr_ty a;
23780 pattern_ty or_pattern_var;
23781 if (
23782 (or_pattern_var = or_pattern_rule(p)) // or_pattern
23783 &&
23784 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
23785 &&
23786 (a = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"'
23787 )
23788 {
23789 D(fprintf(stderr, "%*c+ invalid_as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' \"_\""));
23790 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use '_' as a target" );
23791 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23792 p->error_indicator = 1;
23793 p->level--;
23794 return NULL;
23795 }
23796 goto done;
23797 }
23798 p->mark = _mark;
23799 D(fprintf(stderr, "%*c%s invalid_as_pattern[%d-%d]: %s failed!\n", p->level, ' ',
23800 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' \"_\""));
23801 }
23802 { // or_pattern 'as' !NAME expression
23803 if (p->error_indicator) {
23804 p->level--;
23805 return NULL;
23806 }
23807 D(fprintf(stderr, "%*c> invalid_as_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' !NAME expression"));
23808 Token * _keyword;
23809 expr_ty a;
23810 pattern_ty or_pattern_var;
23811 if (
23812 (or_pattern_var = or_pattern_rule(p)) // or_pattern
23813 &&
23814 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
23815 &&
23816 _PyPegen_lookahead_for_expr(0, _PyPegen_name_token, p)
23817 &&
23818 (a = expression_rule(p)) // expression
23819 )
23820 {
23821 D(fprintf(stderr, "%*c+ invalid_as_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "or_pattern 'as' !NAME expression"));
23822 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "invalid pattern target" );
23823 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23824 p->error_indicator = 1;
23825 p->level--;
23826 return NULL;
23827 }
23828 goto done;
23829 }
23830 p->mark = _mark;
23831 D(fprintf(stderr, "%*c%s invalid_as_pattern[%d-%d]: %s failed!\n", p->level, ' ',
23832 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "or_pattern 'as' !NAME expression"));
23833 }
23834 _res = NULL;
23835 done:
23836 p->level--;
23837 return _res;
23838 }
23839
23840 // invalid_class_pattern: name_or_attr '(' invalid_class_argument_pattern
23841 static void *
23842 invalid_class_pattern_rule(Parser *p)
23843 {
23844 if (p->level++ == MAXSTACK) {
23845 _Pypegen_stack_overflow(p);
23846 }
23847 if (p->error_indicator) {
23848 p->level--;
23849 return NULL;
23850 }
23851 void * _res = NULL;
23852 int _mark = p->mark;
23853 { // name_or_attr '(' invalid_class_argument_pattern
23854 if (p->error_indicator) {
23855 p->level--;
23856 return NULL;
23857 }
23858 D(fprintf(stderr, "%*c> invalid_class_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' invalid_class_argument_pattern"));
23859 Token * _literal;
23860 asdl_pattern_seq* a;
23861 expr_ty name_or_attr_var;
23862 if (
23863 (name_or_attr_var = name_or_attr_rule(p)) // name_or_attr
23864 &&
23865 (_literal = _PyPegen_expect_token(p, 7)) // token='('
23866 &&
23867 (a = invalid_class_argument_pattern_rule(p)) // invalid_class_argument_pattern
23868 )
23869 {
23870 D(fprintf(stderr, "%*c+ invalid_class_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "name_or_attr '(' invalid_class_argument_pattern"));
23871 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( PyPegen_first_item ( a , pattern_ty ) , PyPegen_last_item ( a , pattern_ty ) , "positional patterns follow keyword patterns" );
23872 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23873 p->error_indicator = 1;
23874 p->level--;
23875 return NULL;
23876 }
23877 goto done;
23878 }
23879 p->mark = _mark;
23880 D(fprintf(stderr, "%*c%s invalid_class_pattern[%d-%d]: %s failed!\n", p->level, ' ',
23881 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "name_or_attr '(' invalid_class_argument_pattern"));
23882 }
23883 _res = NULL;
23884 done:
23885 p->level--;
23886 return _res;
23887 }
23888
23889 // invalid_class_argument_pattern:
23890 // | [positional_patterns ','] keyword_patterns ',' positional_patterns
23891 static asdl_pattern_seq*
23892 invalid_class_argument_pattern_rule(Parser *p)
23893 {
23894 if (p->level++ == MAXSTACK) {
23895 _Pypegen_stack_overflow(p);
23896 }
23897 if (p->error_indicator) {
23898 p->level--;
23899 return NULL;
23900 }
23901 asdl_pattern_seq* _res = NULL;
23902 int _mark = p->mark;
23903 { // [positional_patterns ','] keyword_patterns ',' positional_patterns
23904 if (p->error_indicator) {
23905 p->level--;
23906 return NULL;
23907 }
23908 D(fprintf(stderr, "%*c> invalid_class_argument_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[positional_patterns ','] keyword_patterns ',' positional_patterns"));
23909 Token * _literal;
23910 void *_opt_var;
23911 UNUSED(_opt_var); // Silence compiler warnings
23912 asdl_pattern_seq* a;
23913 asdl_seq* keyword_patterns_var;
23914 if (
23915 (_opt_var = _tmp_226_rule(p), !p->error_indicator) // [positional_patterns ',']
23916 &&
23917 (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns
23918 &&
23919 (_literal = _PyPegen_expect_token(p, 12)) // token=','
23920 &&
23921 (a = positional_patterns_rule(p)) // positional_patterns
23922 )
23923 {
23924 D(fprintf(stderr, "%*c+ invalid_class_argument_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[positional_patterns ','] keyword_patterns ',' positional_patterns"));
23925 _res = a;
23926 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23927 p->error_indicator = 1;
23928 p->level--;
23929 return NULL;
23930 }
23931 goto done;
23932 }
23933 p->mark = _mark;
23934 D(fprintf(stderr, "%*c%s invalid_class_argument_pattern[%d-%d]: %s failed!\n", p->level, ' ',
23935 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[positional_patterns ','] keyword_patterns ',' positional_patterns"));
23936 }
23937 _res = NULL;
23938 done:
23939 p->level--;
23940 return _res;
23941 }
23942
23943 // invalid_if_stmt:
23944 // | 'if' named_expression NEWLINE
23945 // | 'if' named_expression ':' NEWLINE !INDENT
23946 static void *
23947 invalid_if_stmt_rule(Parser *p)
23948 {
23949 if (p->level++ == MAXSTACK) {
23950 _Pypegen_stack_overflow(p);
23951 }
23952 if (p->error_indicator) {
23953 p->level--;
23954 return NULL;
23955 }
23956 void * _res = NULL;
23957 int _mark = p->mark;
23958 { // 'if' named_expression NEWLINE
23959 if (p->error_indicator) {
23960 p->level--;
23961 return NULL;
23962 }
23963 D(fprintf(stderr, "%*c> invalid_if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression NEWLINE"));
23964 Token * _keyword;
23965 expr_ty named_expression_var;
23966 Token * newline_var;
23967 if (
23968 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
23969 &&
23970 (named_expression_var = named_expression_rule(p)) // named_expression
23971 &&
23972 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
23973 )
23974 {
23975 D(fprintf(stderr, "%*c+ invalid_if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression NEWLINE"));
23976 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
23977 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
23978 p->error_indicator = 1;
23979 p->level--;
23980 return NULL;
23981 }
23982 goto done;
23983 }
23984 p->mark = _mark;
23985 D(fprintf(stderr, "%*c%s invalid_if_stmt[%d-%d]: %s failed!\n", p->level, ' ',
23986 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression NEWLINE"));
23987 }
23988 { // 'if' named_expression ':' NEWLINE !INDENT
23989 if (p->error_indicator) {
23990 p->level--;
23991 return NULL;
23992 }
23993 D(fprintf(stderr, "%*c> invalid_if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' NEWLINE !INDENT"));
23994 Token * _literal;
23995 Token * a;
23996 expr_ty a_1;
23997 Token * newline_var;
23998 if (
23999 (a = _PyPegen_expect_token(p, 660)) // token='if'
24000 &&
24001 (a_1 = named_expression_rule(p)) // named_expression
24002 &&
24003 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
24004 &&
24005 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24006 &&
24007 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
24008 )
24009 {
24010 D(fprintf(stderr, "%*c+ invalid_if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' NEWLINE !INDENT"));
24011 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'if' statement on line %d" , a -> lineno );
24012 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24013 p->error_indicator = 1;
24014 p->level--;
24015 return NULL;
24016 }
24017 goto done;
24018 }
24019 p->mark = _mark;
24020 D(fprintf(stderr, "%*c%s invalid_if_stmt[%d-%d]: %s failed!\n", p->level, ' ',
24021 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' NEWLINE !INDENT"));
24022 }
24023 _res = NULL;
24024 done:
24025 p->level--;
24026 return _res;
24027 }
24028
24029 // invalid_elif_stmt:
24030 // | 'elif' named_expression NEWLINE
24031 // | 'elif' named_expression ':' NEWLINE !INDENT
24032 static void *
24033 invalid_elif_stmt_rule(Parser *p)
24034 {
24035 if (p->level++ == MAXSTACK) {
24036 _Pypegen_stack_overflow(p);
24037 }
24038 if (p->error_indicator) {
24039 p->level--;
24040 return NULL;
24041 }
24042 void * _res = NULL;
24043 int _mark = p->mark;
24044 { // 'elif' named_expression NEWLINE
24045 if (p->error_indicator) {
24046 p->level--;
24047 return NULL;
24048 }
24049 D(fprintf(stderr, "%*c> invalid_elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression NEWLINE"));
24050 Token * _keyword;
24051 expr_ty named_expression_var;
24052 Token * newline_var;
24053 if (
24054 (_keyword = _PyPegen_expect_token(p, 662)) // token='elif'
24055 &&
24056 (named_expression_var = named_expression_rule(p)) // named_expression
24057 &&
24058 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24059 )
24060 {
24061 D(fprintf(stderr, "%*c+ invalid_elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression NEWLINE"));
24062 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
24063 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24064 p->error_indicator = 1;
24065 p->level--;
24066 return NULL;
24067 }
24068 goto done;
24069 }
24070 p->mark = _mark;
24071 D(fprintf(stderr, "%*c%s invalid_elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',
24072 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression NEWLINE"));
24073 }
24074 { // 'elif' named_expression ':' NEWLINE !INDENT
24075 if (p->error_indicator) {
24076 p->level--;
24077 return NULL;
24078 }
24079 D(fprintf(stderr, "%*c> invalid_elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' NEWLINE !INDENT"));
24080 Token * _literal;
24081 Token * a;
24082 expr_ty named_expression_var;
24083 Token * newline_var;
24084 if (
24085 (a = _PyPegen_expect_token(p, 662)) // token='elif'
24086 &&
24087 (named_expression_var = named_expression_rule(p)) // named_expression
24088 &&
24089 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
24090 &&
24091 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24092 &&
24093 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
24094 )
24095 {
24096 D(fprintf(stderr, "%*c+ invalid_elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' NEWLINE !INDENT"));
24097 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'elif' statement on line %d" , a -> lineno );
24098 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24099 p->error_indicator = 1;
24100 p->level--;
24101 return NULL;
24102 }
24103 goto done;
24104 }
24105 p->mark = _mark;
24106 D(fprintf(stderr, "%*c%s invalid_elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',
24107 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' NEWLINE !INDENT"));
24108 }
24109 _res = NULL;
24110 done:
24111 p->level--;
24112 return _res;
24113 }
24114
24115 // invalid_else_stmt: 'else' ':' NEWLINE !INDENT
24116 static void *
24117 invalid_else_stmt_rule(Parser *p)
24118 {
24119 if (p->level++ == MAXSTACK) {
24120 _Pypegen_stack_overflow(p);
24121 }
24122 if (p->error_indicator) {
24123 p->level--;
24124 return NULL;
24125 }
24126 void * _res = NULL;
24127 int _mark = p->mark;
24128 { // 'else' ':' NEWLINE !INDENT
24129 if (p->error_indicator) {
24130 p->level--;
24131 return NULL;
24132 }
24133 D(fprintf(stderr, "%*c> invalid_else_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' ':' NEWLINE !INDENT"));
24134 Token * _literal;
24135 Token * a;
24136 Token * newline_var;
24137 if (
24138 (a = _PyPegen_expect_token(p, 663)) // token='else'
24139 &&
24140 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
24141 &&
24142 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24143 &&
24144 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
24145 )
24146 {
24147 D(fprintf(stderr, "%*c+ invalid_else_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' ':' NEWLINE !INDENT"));
24148 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'else' statement on line %d" , a -> lineno );
24149 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24150 p->error_indicator = 1;
24151 p->level--;
24152 return NULL;
24153 }
24154 goto done;
24155 }
24156 p->mark = _mark;
24157 D(fprintf(stderr, "%*c%s invalid_else_stmt[%d-%d]: %s failed!\n", p->level, ' ',
24158 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' ':' NEWLINE !INDENT"));
24159 }
24160 _res = NULL;
24161 done:
24162 p->level--;
24163 return _res;
24164 }
24165
24166 // invalid_while_stmt:
24167 // | 'while' named_expression NEWLINE
24168 // | 'while' named_expression ':' NEWLINE !INDENT
24169 static void *
24170 invalid_while_stmt_rule(Parser *p)
24171 {
24172 if (p->level++ == MAXSTACK) {
24173 _Pypegen_stack_overflow(p);
24174 }
24175 if (p->error_indicator) {
24176 p->level--;
24177 return NULL;
24178 }
24179 void * _res = NULL;
24180 int _mark = p->mark;
24181 { // 'while' named_expression NEWLINE
24182 if (p->error_indicator) {
24183 p->level--;
24184 return NULL;
24185 }
24186 D(fprintf(stderr, "%*c> invalid_while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression NEWLINE"));
24187 Token * _keyword;
24188 expr_ty named_expression_var;
24189 Token * newline_var;
24190 if (
24191 (_keyword = _PyPegen_expect_token(p, 665)) // token='while'
24192 &&
24193 (named_expression_var = named_expression_rule(p)) // named_expression
24194 &&
24195 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24196 )
24197 {
24198 D(fprintf(stderr, "%*c+ invalid_while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression NEWLINE"));
24199 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
24200 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24201 p->error_indicator = 1;
24202 p->level--;
24203 return NULL;
24204 }
24205 goto done;
24206 }
24207 p->mark = _mark;
24208 D(fprintf(stderr, "%*c%s invalid_while_stmt[%d-%d]: %s failed!\n", p->level, ' ',
24209 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression NEWLINE"));
24210 }
24211 { // 'while' named_expression ':' NEWLINE !INDENT
24212 if (p->error_indicator) {
24213 p->level--;
24214 return NULL;
24215 }
24216 D(fprintf(stderr, "%*c> invalid_while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' NEWLINE !INDENT"));
24217 Token * _literal;
24218 Token * a;
24219 expr_ty named_expression_var;
24220 Token * newline_var;
24221 if (
24222 (a = _PyPegen_expect_token(p, 665)) // token='while'
24223 &&
24224 (named_expression_var = named_expression_rule(p)) // named_expression
24225 &&
24226 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
24227 &&
24228 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24229 &&
24230 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
24231 )
24232 {
24233 D(fprintf(stderr, "%*c+ invalid_while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' NEWLINE !INDENT"));
24234 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'while' statement on line %d" , a -> lineno );
24235 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24236 p->error_indicator = 1;
24237 p->level--;
24238 return NULL;
24239 }
24240 goto done;
24241 }
24242 p->mark = _mark;
24243 D(fprintf(stderr, "%*c%s invalid_while_stmt[%d-%d]: %s failed!\n", p->level, ' ',
24244 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' NEWLINE !INDENT"));
24245 }
24246 _res = NULL;
24247 done:
24248 p->level--;
24249 return _res;
24250 }
24251
24252 // invalid_for_stmt:
24253 // | 'async'? 'for' star_targets 'in' star_expressions NEWLINE
24254 // | 'async'? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT
24255 static void *
24256 invalid_for_stmt_rule(Parser *p)
24257 {
24258 if (p->level++ == MAXSTACK) {
24259 _Pypegen_stack_overflow(p);
24260 }
24261 if (p->error_indicator) {
24262 p->level--;
24263 return NULL;
24264 }
24265 void * _res = NULL;
24266 int _mark = p->mark;
24267 { // 'async'? 'for' star_targets 'in' star_expressions NEWLINE
24268 if (p->error_indicator) {
24269 p->level--;
24270 return NULL;
24271 }
24272 D(fprintf(stderr, "%*c> invalid_for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'for' star_targets 'in' star_expressions NEWLINE"));
24273 Token * _keyword;
24274 Token * _keyword_1;
24275 void *_opt_var;
24276 UNUSED(_opt_var); // Silence compiler warnings
24277 Token * newline_var;
24278 expr_ty star_expressions_var;
24279 expr_ty star_targets_var;
24280 if (
24281 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
24282 &&
24283 (_keyword = _PyPegen_expect_token(p, 670)) // token='for'
24284 &&
24285 (star_targets_var = star_targets_rule(p)) // star_targets
24286 &&
24287 (_keyword_1 = _PyPegen_expect_token(p, 671)) // token='in'
24288 &&
24289 (star_expressions_var = star_expressions_rule(p)) // star_expressions
24290 &&
24291 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24292 )
24293 {
24294 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"));
24295 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
24296 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24297 p->error_indicator = 1;
24298 p->level--;
24299 return NULL;
24300 }
24301 goto done;
24302 }
24303 p->mark = _mark;
24304 D(fprintf(stderr, "%*c%s invalid_for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
24305 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'for' star_targets 'in' star_expressions NEWLINE"));
24306 }
24307 { // 'async'? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT
24308 if (p->error_indicator) {
24309 p->level--;
24310 return NULL;
24311 }
24312 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"));
24313 Token * _keyword;
24314 Token * _literal;
24315 void *_opt_var;
24316 UNUSED(_opt_var); // Silence compiler warnings
24317 Token * a;
24318 Token * newline_var;
24319 expr_ty star_expressions_var;
24320 expr_ty star_targets_var;
24321 if (
24322 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
24323 &&
24324 (a = _PyPegen_expect_token(p, 670)) // token='for'
24325 &&
24326 (star_targets_var = star_targets_rule(p)) // star_targets
24327 &&
24328 (_keyword = _PyPegen_expect_token(p, 671)) // token='in'
24329 &&
24330 (star_expressions_var = star_expressions_rule(p)) // star_expressions
24331 &&
24332 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
24333 &&
24334 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24335 &&
24336 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
24337 )
24338 {
24339 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"));
24340 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after 'for' statement on line %d" , a -> lineno );
24341 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24342 p->error_indicator = 1;
24343 p->level--;
24344 return NULL;
24345 }
24346 goto done;
24347 }
24348 p->mark = _mark;
24349 D(fprintf(stderr, "%*c%s invalid_for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
24350 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT"));
24351 }
24352 _res = NULL;
24353 done:
24354 p->level--;
24355 return _res;
24356 }
24357
24358 // invalid_def_raw:
24359 // | 'async'? 'def' NAME type_params? '(' params? ')' ['->' expression] ':' NEWLINE !INDENT
24360 // | 'async'? 'def' NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block
24361 static void *
24362 invalid_def_raw_rule(Parser *p)
24363 {
24364 if (p->level++ == MAXSTACK) {
24365 _Pypegen_stack_overflow(p);
24366 }
24367 if (p->error_indicator) {
24368 p->level--;
24369 return NULL;
24370 }
24371 void * _res = NULL;
24372 int _mark = p->mark;
24373 { // 'async'? 'def' NAME type_params? '(' params? ')' ['->' expression] ':' NEWLINE !INDENT
24374 if (p->error_indicator) {
24375 p->level--;
24376 return NULL;
24377 }
24378 D(fprintf(stderr, "%*c> invalid_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'def' NAME type_params? '(' params? ')' ['->' expression] ':' NEWLINE !INDENT"));
24379 Token * _literal;
24380 Token * _literal_1;
24381 Token * _literal_2;
24382 void *_opt_var;
24383 UNUSED(_opt_var); // Silence compiler warnings
24384 void *_opt_var_1;
24385 UNUSED(_opt_var_1); // Silence compiler warnings
24386 void *_opt_var_2;
24387 UNUSED(_opt_var_2); // Silence compiler warnings
24388 void *_opt_var_3;
24389 UNUSED(_opt_var_3); // Silence compiler warnings
24390 Token * a;
24391 expr_ty name_var;
24392 Token * newline_var;
24393 if (
24394 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
24395 &&
24396 (a = _PyPegen_expect_token(p, 675)) // token='def'
24397 &&
24398 (name_var = _PyPegen_name_token(p)) // NAME
24399 &&
24400 (_opt_var_1 = type_params_rule(p), !p->error_indicator) // type_params?
24401 &&
24402 (_literal = _PyPegen_expect_token(p, 7)) // token='('
24403 &&
24404 (_opt_var_2 = params_rule(p), !p->error_indicator) // params?
24405 &&
24406 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
24407 &&
24408 (_opt_var_3 = _tmp_227_rule(p), !p->error_indicator) // ['->' expression]
24409 &&
24410 (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':'
24411 &&
24412 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24413 &&
24414 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
24415 )
24416 {
24417 D(fprintf(stderr, "%*c+ invalid_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'? 'def' NAME type_params? '(' params? ')' ['->' expression] ':' NEWLINE !INDENT"));
24418 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after function definition on line %d" , a -> lineno );
24419 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24420 p->error_indicator = 1;
24421 p->level--;
24422 return NULL;
24423 }
24424 goto done;
24425 }
24426 p->mark = _mark;
24427 D(fprintf(stderr, "%*c%s invalid_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
24428 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'def' NAME type_params? '(' params? ')' ['->' expression] ':' NEWLINE !INDENT"));
24429 }
24430 { // 'async'? 'def' NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block
24431 if (p->error_indicator) {
24432 p->level--;
24433 return NULL;
24434 }
24435 D(fprintf(stderr, "%*c> invalid_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'def' NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block"));
24436 Token * _keyword;
24437 Token * _literal;
24438 Token * _literal_1;
24439 Token * _literal_2;
24440 void *_opt_var;
24441 UNUSED(_opt_var); // Silence compiler warnings
24442 void *_opt_var_1;
24443 UNUSED(_opt_var_1); // Silence compiler warnings
24444 void *_opt_var_2;
24445 UNUSED(_opt_var_2); // Silence compiler warnings
24446 void *_opt_var_3;
24447 UNUSED(_opt_var_3); // Silence compiler warnings
24448 void *_opt_var_4;
24449 UNUSED(_opt_var_4); // Silence compiler warnings
24450 asdl_stmt_seq* block_var;
24451 expr_ty name_var;
24452 if (
24453 (_opt_var = _PyPegen_expect_token(p, 674), !p->error_indicator) // 'async'?
24454 &&
24455 (_keyword = _PyPegen_expect_token(p, 675)) // token='def'
24456 &&
24457 (name_var = _PyPegen_name_token(p)) // NAME
24458 &&
24459 (_opt_var_1 = type_params_rule(p), !p->error_indicator) // type_params?
24460 &&
24461 (_literal = _PyPegen_expect_forced_token(p, 7, "(")) // forced_token='('
24462 &&
24463 (_opt_var_2 = params_rule(p), !p->error_indicator) // params?
24464 &&
24465 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
24466 &&
24467 (_opt_var_3 = _tmp_228_rule(p), !p->error_indicator) // ['->' expression]
24468 &&
24469 (_literal_2 = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':'
24470 &&
24471 (_opt_var_4 = func_type_comment_rule(p), !p->error_indicator) // func_type_comment?
24472 &&
24473 (block_var = block_rule(p)) // block
24474 )
24475 {
24476 D(fprintf(stderr, "%*c+ invalid_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'? 'def' NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block"));
24477 _res = _PyPegen_dummy_name(p, _opt_var, _keyword, name_var, _opt_var_1, _literal, _opt_var_2, _literal_1, _opt_var_3, _literal_2, _opt_var_4, block_var);
24478 goto done;
24479 }
24480 p->mark = _mark;
24481 D(fprintf(stderr, "%*c%s invalid_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
24482 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'? 'def' NAME type_params? &&'(' params? ')' ['->' expression] &&':' func_type_comment? block"));
24483 }
24484 _res = NULL;
24485 done:
24486 p->level--;
24487 return _res;
24488 }
24489
24490 // invalid_class_def_raw:
24491 // | 'class' NAME type_params? ['(' arguments? ')'] NEWLINE
24492 // | 'class' NAME type_params? ['(' arguments? ')'] ':' NEWLINE !INDENT
24493 static void *
24494 invalid_class_def_raw_rule(Parser *p)
24495 {
24496 if (p->level++ == MAXSTACK) {
24497 _Pypegen_stack_overflow(p);
24498 }
24499 if (p->error_indicator) {
24500 p->level--;
24501 return NULL;
24502 }
24503 void * _res = NULL;
24504 int _mark = p->mark;
24505 { // 'class' NAME type_params? ['(' arguments? ')'] NEWLINE
24506 if (p->error_indicator) {
24507 p->level--;
24508 return NULL;
24509 }
24510 D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] NEWLINE"));
24511 Token * _keyword;
24512 void *_opt_var;
24513 UNUSED(_opt_var); // Silence compiler warnings
24514 void *_opt_var_1;
24515 UNUSED(_opt_var_1); // Silence compiler warnings
24516 expr_ty name_var;
24517 Token * newline_var;
24518 if (
24519 (_keyword = _PyPegen_expect_token(p, 677)) // token='class'
24520 &&
24521 (name_var = _PyPegen_name_token(p)) // NAME
24522 &&
24523 (_opt_var = type_params_rule(p), !p->error_indicator) // type_params?
24524 &&
24525 (_opt_var_1 = _tmp_229_rule(p), !p->error_indicator) // ['(' arguments? ')']
24526 &&
24527 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24528 )
24529 {
24530 D(fprintf(stderr, "%*c+ invalid_class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] NEWLINE"));
24531 _res = RAISE_SYNTAX_ERROR ( "expected ':'" );
24532 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24533 p->error_indicator = 1;
24534 p->level--;
24535 return NULL;
24536 }
24537 goto done;
24538 }
24539 p->mark = _mark;
24540 D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
24541 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] NEWLINE"));
24542 }
24543 { // 'class' NAME type_params? ['(' arguments? ')'] ':' NEWLINE !INDENT
24544 if (p->error_indicator) {
24545 p->level--;
24546 return NULL;
24547 }
24548 D(fprintf(stderr, "%*c> invalid_class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] ':' NEWLINE !INDENT"));
24549 Token * _literal;
24550 void *_opt_var;
24551 UNUSED(_opt_var); // Silence compiler warnings
24552 void *_opt_var_1;
24553 UNUSED(_opt_var_1); // Silence compiler warnings
24554 Token * a;
24555 expr_ty name_var;
24556 Token * newline_var;
24557 if (
24558 (a = _PyPegen_expect_token(p, 677)) // token='class'
24559 &&
24560 (name_var = _PyPegen_name_token(p)) // NAME
24561 &&
24562 (_opt_var = type_params_rule(p), !p->error_indicator) // type_params?
24563 &&
24564 (_opt_var_1 = _tmp_230_rule(p), !p->error_indicator) // ['(' arguments? ')']
24565 &&
24566 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
24567 &&
24568 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
24569 &&
24570 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT) // token=INDENT
24571 )
24572 {
24573 D(fprintf(stderr, "%*c+ invalid_class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] ':' NEWLINE !INDENT"));
24574 _res = RAISE_INDENTATION_ERROR ( "expected an indented block after class definition on line %d" , a -> lineno );
24575 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24576 p->error_indicator = 1;
24577 p->level--;
24578 return NULL;
24579 }
24580 goto done;
24581 }
24582 p->mark = _mark;
24583 D(fprintf(stderr, "%*c%s invalid_class_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
24584 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME type_params? ['(' arguments? ')'] ':' NEWLINE !INDENT"));
24585 }
24586 _res = NULL;
24587 done:
24588 p->level--;
24589 return _res;
24590 }
24591
24592 // invalid_double_starred_kvpairs:
24593 // | ','.double_starred_kvpair+ ',' invalid_kvpair
24594 // | expression ':' '*' bitwise_or
24595 // | expression ':' &('}' | ',')
24596 static void *
24597 invalid_double_starred_kvpairs_rule(Parser *p)
24598 {
24599 if (p->level++ == MAXSTACK) {
24600 _Pypegen_stack_overflow(p);
24601 }
24602 if (p->error_indicator) {
24603 p->level--;
24604 return NULL;
24605 }
24606 void * _res = NULL;
24607 int _mark = p->mark;
24608 { // ','.double_starred_kvpair+ ',' invalid_kvpair
24609 if (p->error_indicator) {
24610 p->level--;
24611 return NULL;
24612 }
24613 D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair"));
24614 asdl_seq * _gather_231_var;
24615 Token * _literal;
24616 void *invalid_kvpair_var;
24617 if (
24618 (_gather_231_var = _gather_231_rule(p)) // ','.double_starred_kvpair+
24619 &&
24620 (_literal = _PyPegen_expect_token(p, 12)) // token=','
24621 &&
24622 (invalid_kvpair_var = invalid_kvpair_rule(p)) // invalid_kvpair
24623 )
24624 {
24625 D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair"));
24626 _res = _PyPegen_dummy_name(p, _gather_231_var, _literal, invalid_kvpair_var);
24627 goto done;
24628 }
24629 p->mark = _mark;
24630 D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',
24631 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair"));
24632 }
24633 { // expression ':' '*' bitwise_or
24634 if (p->error_indicator) {
24635 p->level--;
24636 return NULL;
24637 }
24638 D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or"));
24639 Token * _literal;
24640 Token * a;
24641 expr_ty bitwise_or_var;
24642 expr_ty expression_var;
24643 if (
24644 (expression_var = expression_rule(p)) // expression
24645 &&
24646 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
24647 &&
24648 (a = _PyPegen_expect_token(p, 16)) // token='*'
24649 &&
24650 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
24651 )
24652 {
24653 D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or"));
24654 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" );
24655 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24656 p->error_indicator = 1;
24657 p->level--;
24658 return NULL;
24659 }
24660 goto done;
24661 }
24662 p->mark = _mark;
24663 D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',
24664 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or"));
24665 }
24666 { // expression ':' &('}' | ',')
24667 if (p->error_indicator) {
24668 p->level--;
24669 return NULL;
24670 }
24671 D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')"));
24672 Token * a;
24673 expr_ty expression_var;
24674 if (
24675 (expression_var = expression_rule(p)) // expression
24676 &&
24677 (a = _PyPegen_expect_token(p, 11)) // token=':'
24678 &&
24679 _PyPegen_lookahead(1, _tmp_233_rule, p)
24680 )
24681 {
24682 D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')"));
24683 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" );
24684 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24685 p->error_indicator = 1;
24686 p->level--;
24687 return NULL;
24688 }
24689 goto done;
24690 }
24691 p->mark = _mark;
24692 D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',
24693 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')"));
24694 }
24695 _res = NULL;
24696 done:
24697 p->level--;
24698 return _res;
24699 }
24700
24701 // invalid_kvpair:
24702 // | expression !(':')
24703 // | expression ':' '*' bitwise_or
24704 // | expression ':' &('}' | ',')
24705 static void *
24706 invalid_kvpair_rule(Parser *p)
24707 {
24708 if (p->level++ == MAXSTACK) {
24709 _Pypegen_stack_overflow(p);
24710 }
24711 if (p->error_indicator) {
24712 p->level--;
24713 return NULL;
24714 }
24715 void * _res = NULL;
24716 int _mark = p->mark;
24717 { // expression !(':')
24718 if (p->error_indicator) {
24719 p->level--;
24720 return NULL;
24721 }
24722 D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !(':')"));
24723 expr_ty a;
24724 if (
24725 (a = expression_rule(p)) // expression
24726 &&
24727 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 11) // token=(':')
24728 )
24729 {
24730 D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !(':')"));
24731 _res = RAISE_ERROR_KNOWN_LOCATION ( p , PyExc_SyntaxError , a -> lineno , a -> end_col_offset - 1 , a -> end_lineno , - 1 , "':' expected after dictionary key" );
24732 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24733 p->error_indicator = 1;
24734 p->level--;
24735 return NULL;
24736 }
24737 goto done;
24738 }
24739 p->mark = _mark;
24740 D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
24741 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !(':')"));
24742 }
24743 { // expression ':' '*' bitwise_or
24744 if (p->error_indicator) {
24745 p->level--;
24746 return NULL;
24747 }
24748 D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or"));
24749 Token * _literal;
24750 Token * a;
24751 expr_ty bitwise_or_var;
24752 expr_ty expression_var;
24753 if (
24754 (expression_var = expression_rule(p)) // expression
24755 &&
24756 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
24757 &&
24758 (a = _PyPegen_expect_token(p, 16)) // token='*'
24759 &&
24760 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
24761 )
24762 {
24763 D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or"));
24764 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" );
24765 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24766 p->error_indicator = 1;
24767 p->level--;
24768 return NULL;
24769 }
24770 goto done;
24771 }
24772 p->mark = _mark;
24773 D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
24774 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or"));
24775 }
24776 { // expression ':' &('}' | ',')
24777 if (p->error_indicator) {
24778 p->level--;
24779 return NULL;
24780 }
24781 D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')"));
24782 Token * a;
24783 expr_ty expression_var;
24784 if (
24785 (expression_var = expression_rule(p)) // expression
24786 &&
24787 (a = _PyPegen_expect_token(p, 11)) // token=':'
24788 &&
24789 _PyPegen_lookahead(1, _tmp_234_rule, p)
24790 )
24791 {
24792 D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')"));
24793 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" );
24794 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24795 p->error_indicator = 1;
24796 p->level--;
24797 return NULL;
24798 }
24799 goto done;
24800 }
24801 p->mark = _mark;
24802 D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
24803 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')"));
24804 }
24805 _res = NULL;
24806 done:
24807 p->level--;
24808 return _res;
24809 }
24810
24811 // invalid_starred_expression: '*' expression '=' expression
24812 static void *
24813 invalid_starred_expression_rule(Parser *p)
24814 {
24815 if (p->level++ == MAXSTACK) {
24816 _Pypegen_stack_overflow(p);
24817 }
24818 if (p->error_indicator) {
24819 p->level--;
24820 return NULL;
24821 }
24822 void * _res = NULL;
24823 int _mark = p->mark;
24824 { // '*' expression '=' expression
24825 if (p->error_indicator) {
24826 p->level--;
24827 return NULL;
24828 }
24829 D(fprintf(stderr, "%*c> invalid_starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression '=' expression"));
24830 Token * _literal;
24831 Token * a;
24832 expr_ty b;
24833 expr_ty expression_var;
24834 if (
24835 (a = _PyPegen_expect_token(p, 16)) // token='*'
24836 &&
24837 (expression_var = expression_rule(p)) // expression
24838 &&
24839 (_literal = _PyPegen_expect_token(p, 22)) // token='='
24840 &&
24841 (b = expression_rule(p)) // expression
24842 )
24843 {
24844 D(fprintf(stderr, "%*c+ invalid_starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression '=' expression"));
24845 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to iterable argument unpacking" );
24846 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24847 p->error_indicator = 1;
24848 p->level--;
24849 return NULL;
24850 }
24851 goto done;
24852 }
24853 p->mark = _mark;
24854 D(fprintf(stderr, "%*c%s invalid_starred_expression[%d-%d]: %s failed!\n", p->level, ' ',
24855 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression '=' expression"));
24856 }
24857 _res = NULL;
24858 done:
24859 p->level--;
24860 return _res;
24861 }
24862
24863 // invalid_replacement_field:
24864 // | '{' '='
24865 // | '{' '!'
24866 // | '{' ':'
24867 // | '{' '}'
24868 // | '{' !annotated_rhs
24869 // | '{' annotated_rhs !('=' | '!' | ':' | '}')
24870 // | '{' annotated_rhs '=' !('!' | ':' | '}')
24871 // | '{' annotated_rhs '='? invalid_conversion_character
24872 // | '{' annotated_rhs '='? ['!' NAME] !(':' | '}')
24873 // | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'
24874 // | '{' annotated_rhs '='? ['!' NAME] !'}'
24875 static void *
24876 invalid_replacement_field_rule(Parser *p)
24877 {
24878 if (p->level++ == MAXSTACK) {
24879 _Pypegen_stack_overflow(p);
24880 }
24881 if (p->error_indicator) {
24882 p->level--;
24883 return NULL;
24884 }
24885 void * _res = NULL;
24886 int _mark = p->mark;
24887 { // '{' '='
24888 if (p->error_indicator) {
24889 p->level--;
24890 return NULL;
24891 }
24892 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '='"));
24893 Token * _literal;
24894 Token * a;
24895 if (
24896 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
24897 &&
24898 (a = _PyPegen_expect_token(p, 22)) // token='='
24899 )
24900 {
24901 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '='"));
24902 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '='" );
24903 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24904 p->error_indicator = 1;
24905 p->level--;
24906 return NULL;
24907 }
24908 goto done;
24909 }
24910 p->mark = _mark;
24911 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
24912 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '='"));
24913 }
24914 { // '{' '!'
24915 if (p->error_indicator) {
24916 p->level--;
24917 return NULL;
24918 }
24919 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '!'"));
24920 Token * _literal;
24921 Token * a;
24922 if (
24923 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
24924 &&
24925 (a = _PyPegen_expect_token(p, 54)) // token='!'
24926 )
24927 {
24928 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '!'"));
24929 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '!'" );
24930 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24931 p->error_indicator = 1;
24932 p->level--;
24933 return NULL;
24934 }
24935 goto done;
24936 }
24937 p->mark = _mark;
24938 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
24939 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '!'"));
24940 }
24941 { // '{' ':'
24942 if (p->error_indicator) {
24943 p->level--;
24944 return NULL;
24945 }
24946 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' ':'"));
24947 Token * _literal;
24948 Token * a;
24949 if (
24950 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
24951 &&
24952 (a = _PyPegen_expect_token(p, 11)) // token=':'
24953 )
24954 {
24955 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' ':'"));
24956 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before ':'" );
24957 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24958 p->error_indicator = 1;
24959 p->level--;
24960 return NULL;
24961 }
24962 goto done;
24963 }
24964 p->mark = _mark;
24965 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
24966 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' ':'"));
24967 }
24968 { // '{' '}'
24969 if (p->error_indicator) {
24970 p->level--;
24971 return NULL;
24972 }
24973 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '}'"));
24974 Token * _literal;
24975 Token * a;
24976 if (
24977 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
24978 &&
24979 (a = _PyPegen_expect_token(p, 26)) // token='}'
24980 )
24981 {
24982 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '}'"));
24983 _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "f-string: valid expression required before '}'" );
24984 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
24985 p->error_indicator = 1;
24986 p->level--;
24987 return NULL;
24988 }
24989 goto done;
24990 }
24991 p->mark = _mark;
24992 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
24993 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '}'"));
24994 }
24995 { // '{' !annotated_rhs
24996 if (p->error_indicator) {
24997 p->level--;
24998 return NULL;
24999 }
25000 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs"));
25001 Token * _literal;
25002 if (
25003 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
25004 &&
25005 _PyPegen_lookahead_for_expr(0, annotated_rhs_rule, p)
25006 )
25007 {
25008 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' !annotated_rhs"));
25009 _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting a valid expression after '{'" );
25010 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25011 p->error_indicator = 1;
25012 p->level--;
25013 return NULL;
25014 }
25015 goto done;
25016 }
25017 p->mark = _mark;
25018 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
25019 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' !annotated_rhs"));
25020 }
25021 { // '{' annotated_rhs !('=' | '!' | ':' | '}')
25022 if (p->error_indicator) {
25023 p->level--;
25024 return NULL;
25025 }
25026 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')"));
25027 Token * _literal;
25028 expr_ty annotated_rhs_var;
25029 if (
25030 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
25031 &&
25032 (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs
25033 &&
25034 _PyPegen_lookahead(0, _tmp_235_rule, p)
25035 )
25036 {
25037 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')"));
25038 _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '=', or '!', or ':', or '}'" );
25039 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25040 p->error_indicator = 1;
25041 p->level--;
25042 return NULL;
25043 }
25044 goto done;
25045 }
25046 p->mark = _mark;
25047 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
25048 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')"));
25049 }
25050 { // '{' annotated_rhs '=' !('!' | ':' | '}')
25051 if (p->error_indicator) {
25052 p->level--;
25053 return NULL;
25054 }
25055 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')"));
25056 Token * _literal;
25057 Token * _literal_1;
25058 expr_ty annotated_rhs_var;
25059 if (
25060 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
25061 &&
25062 (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs
25063 &&
25064 (_literal_1 = _PyPegen_expect_token(p, 22)) // token='='
25065 &&
25066 _PyPegen_lookahead(0, _tmp_236_rule, p)
25067 )
25068 {
25069 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')"));
25070 _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '!', or ':', or '}'" );
25071 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25072 p->error_indicator = 1;
25073 p->level--;
25074 return NULL;
25075 }
25076 goto done;
25077 }
25078 p->mark = _mark;
25079 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
25080 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')"));
25081 }
25082 { // '{' annotated_rhs '='? invalid_conversion_character
25083 if (p->error_indicator) {
25084 p->level--;
25085 return NULL;
25086 }
25087 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? invalid_conversion_character"));
25088 Token * _literal;
25089 void *_opt_var;
25090 UNUSED(_opt_var); // Silence compiler warnings
25091 expr_ty annotated_rhs_var;
25092 void *invalid_conversion_character_var;
25093 if (
25094 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
25095 &&
25096 (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs
25097 &&
25098 (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='?
25099 &&
25100 (invalid_conversion_character_var = invalid_conversion_character_rule(p)) // invalid_conversion_character
25101 )
25102 {
25103 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? invalid_conversion_character"));
25104 _res = _PyPegen_dummy_name(p, _literal, annotated_rhs_var, _opt_var, invalid_conversion_character_var);
25105 goto done;
25106 }
25107 p->mark = _mark;
25108 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
25109 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? invalid_conversion_character"));
25110 }
25111 { // '{' annotated_rhs '='? ['!' NAME] !(':' | '}')
25112 if (p->error_indicator) {
25113 p->level--;
25114 return NULL;
25115 }
25116 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')"));
25117 Token * _literal;
25118 void *_opt_var;
25119 UNUSED(_opt_var); // Silence compiler warnings
25120 void *_opt_var_1;
25121 UNUSED(_opt_var_1); // Silence compiler warnings
25122 expr_ty annotated_rhs_var;
25123 if (
25124 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
25125 &&
25126 (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs
25127 &&
25128 (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='?
25129 &&
25130 (_opt_var_1 = _tmp_237_rule(p), !p->error_indicator) // ['!' NAME]
25131 &&
25132 _PyPegen_lookahead(0, _tmp_238_rule, p)
25133 )
25134 {
25135 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')"));
25136 _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting ':' or '}'" );
25137 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25138 p->error_indicator = 1;
25139 p->level--;
25140 return NULL;
25141 }
25142 goto done;
25143 }
25144 p->mark = _mark;
25145 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
25146 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')"));
25147 }
25148 { // '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'
25149 if (p->error_indicator) {
25150 p->level--;
25151 return NULL;
25152 }
25153 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'"));
25154 Token * _literal;
25155 Token * _literal_1;
25156 asdl_seq * _loop0_240_var;
25157 void *_opt_var;
25158 UNUSED(_opt_var); // Silence compiler warnings
25159 void *_opt_var_1;
25160 UNUSED(_opt_var_1); // Silence compiler warnings
25161 expr_ty annotated_rhs_var;
25162 if (
25163 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
25164 &&
25165 (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs
25166 &&
25167 (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='?
25168 &&
25169 (_opt_var_1 = _tmp_239_rule(p), !p->error_indicator) // ['!' NAME]
25170 &&
25171 (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':'
25172 &&
25173 (_loop0_240_var = _loop0_240_rule(p)) // fstring_format_spec*
25174 &&
25175 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}'
25176 )
25177 {
25178 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'"));
25179 _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '}', or format specs" );
25180 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25181 p->error_indicator = 1;
25182 p->level--;
25183 return NULL;
25184 }
25185 goto done;
25186 }
25187 p->mark = _mark;
25188 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
25189 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'"));
25190 }
25191 { // '{' annotated_rhs '='? ['!' NAME] !'}'
25192 if (p->error_indicator) {
25193 p->level--;
25194 return NULL;
25195 }
25196 D(fprintf(stderr, "%*c> invalid_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'"));
25197 Token * _literal;
25198 void *_opt_var;
25199 UNUSED(_opt_var); // Silence compiler warnings
25200 void *_opt_var_1;
25201 UNUSED(_opt_var_1); // Silence compiler warnings
25202 expr_ty annotated_rhs_var;
25203 if (
25204 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
25205 &&
25206 (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs
25207 &&
25208 (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='?
25209 &&
25210 (_opt_var_1 = _tmp_241_rule(p), !p->error_indicator) // ['!' NAME]
25211 &&
25212 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}'
25213 )
25214 {
25215 D(fprintf(stderr, "%*c+ invalid_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'"));
25216 _res = PyErr_Occurred ( ) ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: expecting '}'" );
25217 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25218 p->error_indicator = 1;
25219 p->level--;
25220 return NULL;
25221 }
25222 goto done;
25223 }
25224 p->mark = _mark;
25225 D(fprintf(stderr, "%*c%s invalid_replacement_field[%d-%d]: %s failed!\n", p->level, ' ',
25226 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !'}'"));
25227 }
25228 _res = NULL;
25229 done:
25230 p->level--;
25231 return _res;
25232 }
25233
25234 // invalid_conversion_character: '!' &(':' | '}') | '!' !NAME
25235 static void *
25236 invalid_conversion_character_rule(Parser *p)
25237 {
25238 if (p->level++ == MAXSTACK) {
25239 _Pypegen_stack_overflow(p);
25240 }
25241 if (p->error_indicator) {
25242 p->level--;
25243 return NULL;
25244 }
25245 void * _res = NULL;
25246 int _mark = p->mark;
25247 { // '!' &(':' | '}')
25248 if (p->error_indicator) {
25249 p->level--;
25250 return NULL;
25251 }
25252 D(fprintf(stderr, "%*c> invalid_conversion_character[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')"));
25253 Token * _literal;
25254 if (
25255 (_literal = _PyPegen_expect_token(p, 54)) // token='!'
25256 &&
25257 _PyPegen_lookahead(1, _tmp_242_rule, p)
25258 )
25259 {
25260 D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')"));
25261 _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: missing conversion character" );
25262 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25263 p->error_indicator = 1;
25264 p->level--;
25265 return NULL;
25266 }
25267 goto done;
25268 }
25269 p->mark = _mark;
25270 D(fprintf(stderr, "%*c%s invalid_conversion_character[%d-%d]: %s failed!\n", p->level, ' ',
25271 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' &(':' | '}')"));
25272 }
25273 { // '!' !NAME
25274 if (p->error_indicator) {
25275 p->level--;
25276 return NULL;
25277 }
25278 D(fprintf(stderr, "%*c> invalid_conversion_character[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' !NAME"));
25279 Token * _literal;
25280 if (
25281 (_literal = _PyPegen_expect_token(p, 54)) // token='!'
25282 &&
25283 _PyPegen_lookahead_for_expr(0, _PyPegen_name_token, p)
25284 )
25285 {
25286 D(fprintf(stderr, "%*c+ invalid_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' !NAME"));
25287 _res = RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN ( "f-string: invalid conversion character" );
25288 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25289 p->error_indicator = 1;
25290 p->level--;
25291 return NULL;
25292 }
25293 goto done;
25294 }
25295 p->mark = _mark;
25296 D(fprintf(stderr, "%*c%s invalid_conversion_character[%d-%d]: %s failed!\n", p->level, ' ',
25297 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' !NAME"));
25298 }
25299 _res = NULL;
25300 done:
25301 p->level--;
25302 return _res;
25303 }
25304
25305 // invalid_arithmetic: sum ('+' | '-' | '*' | '/' | '%' | '//' | '@') 'not' inversion
25306 static void *
25307 invalid_arithmetic_rule(Parser *p)
25308 {
25309 if (p->level++ == MAXSTACK) {
25310 _Pypegen_stack_overflow(p);
25311 }
25312 if (p->error_indicator) {
25313 p->level--;
25314 return NULL;
25315 }
25316 void * _res = NULL;
25317 int _mark = p->mark;
25318 { // sum ('+' | '-' | '*' | '/' | '%' | '//' | '@') 'not' inversion
25319 if (p->error_indicator) {
25320 p->level--;
25321 return NULL;
25322 }
25323 D(fprintf(stderr, "%*c> invalid_arithmetic[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum ('+' | '-' | '*' | '/' | '%' | '//' | '@') 'not' inversion"));
25324 void *_tmp_243_var;
25325 Token * a;
25326 expr_ty b;
25327 expr_ty sum_var;
25328 if (
25329 (sum_var = sum_rule(p)) // sum
25330 &&
25331 (_tmp_243_var = _tmp_243_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@'
25332 &&
25333 (a = _PyPegen_expect_token(p, 679)) // token='not'
25334 &&
25335 (b = inversion_rule(p)) // inversion
25336 )
25337 {
25338 D(fprintf(stderr, "%*c+ invalid_arithmetic[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum ('+' | '-' | '*' | '/' | '%' | '//' | '@') 'not' inversion"));
25339 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "'not' after an operator must be parenthesized" );
25340 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25341 p->error_indicator = 1;
25342 p->level--;
25343 return NULL;
25344 }
25345 goto done;
25346 }
25347 p->mark = _mark;
25348 D(fprintf(stderr, "%*c%s invalid_arithmetic[%d-%d]: %s failed!\n", p->level, ' ',
25349 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum ('+' | '-' | '*' | '/' | '%' | '//' | '@') 'not' inversion"));
25350 }
25351 _res = NULL;
25352 done:
25353 p->level--;
25354 return _res;
25355 }
25356
25357 // invalid_factor: ('+' | '-' | '~') 'not' factor
25358 static void *
25359 invalid_factor_rule(Parser *p)
25360 {
25361 if (p->level++ == MAXSTACK) {
25362 _Pypegen_stack_overflow(p);
25363 }
25364 if (p->error_indicator) {
25365 p->level--;
25366 return NULL;
25367 }
25368 void * _res = NULL;
25369 int _mark = p->mark;
25370 { // ('+' | '-' | '~') 'not' factor
25371 if (p->error_indicator) {
25372 p->level--;
25373 return NULL;
25374 }
25375 D(fprintf(stderr, "%*c> invalid_factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('+' | '-' | '~') 'not' factor"));
25376 void *_tmp_244_var;
25377 Token * a;
25378 expr_ty b;
25379 if (
25380 (_tmp_244_var = _tmp_244_rule(p)) // '+' | '-' | '~'
25381 &&
25382 (a = _PyPegen_expect_token(p, 679)) // token='not'
25383 &&
25384 (b = factor_rule(p)) // factor
25385 )
25386 {
25387 D(fprintf(stderr, "%*c+ invalid_factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('+' | '-' | '~') 'not' factor"));
25388 _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "'not' after an operator must be parenthesized" );
25389 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25390 p->error_indicator = 1;
25391 p->level--;
25392 return NULL;
25393 }
25394 goto done;
25395 }
25396 p->mark = _mark;
25397 D(fprintf(stderr, "%*c%s invalid_factor[%d-%d]: %s failed!\n", p->level, ' ',
25398 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('+' | '-' | '~') 'not' factor"));
25399 }
25400 _res = NULL;
25401 done:
25402 p->level--;
25403 return _res;
25404 }
25405
25406 // invalid_type_params: '[' ']'
25407 static void *
25408 invalid_type_params_rule(Parser *p)
25409 {
25410 if (p->level++ == MAXSTACK) {
25411 _Pypegen_stack_overflow(p);
25412 }
25413 if (p->error_indicator) {
25414 p->level--;
25415 return NULL;
25416 }
25417 void * _res = NULL;
25418 int _mark = p->mark;
25419 { // '[' ']'
25420 if (p->error_indicator) {
25421 p->level--;
25422 return NULL;
25423 }
25424 D(fprintf(stderr, "%*c> invalid_type_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' ']'"));
25425 Token * _literal;
25426 Token * token;
25427 if (
25428 (_literal = _PyPegen_expect_token(p, 9)) // token='['
25429 &&
25430 (token = _PyPegen_expect_token(p, 10)) // token=']'
25431 )
25432 {
25433 D(fprintf(stderr, "%*c+ invalid_type_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' ']'"));
25434 _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( token , "Type parameter list cannot be empty" );
25435 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25436 p->error_indicator = 1;
25437 p->level--;
25438 return NULL;
25439 }
25440 goto done;
25441 }
25442 p->mark = _mark;
25443 D(fprintf(stderr, "%*c%s invalid_type_params[%d-%d]: %s failed!\n", p->level, ' ',
25444 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' ']'"));
25445 }
25446 _res = NULL;
25447 done:
25448 p->level--;
25449 return _res;
25450 }
25451
25452 // _loop0_1: NEWLINE
25453 static asdl_seq *
25454 _loop0_1_rule(Parser *p)
25455 {
25456 if (p->level++ == MAXSTACK) {
25457 _Pypegen_stack_overflow(p);
25458 }
25459 if (p->error_indicator) {
25460 p->level--;
25461 return NULL;
25462 }
25463 void *_res = NULL;
25464 int _mark = p->mark;
25465 void **_children = PyMem_Malloc(sizeof(void *));
25466 if (!_children) {
25467 p->error_indicator = 1;
25468 PyErr_NoMemory();
25469 p->level--;
25470 return NULL;
25471 }
25472 Py_ssize_t _children_capacity = 1;
25473 Py_ssize_t _n = 0;
25474 { // NEWLINE
25475 if (p->error_indicator) {
25476 p->level--;
25477 return NULL;
25478 }
25479 D(fprintf(stderr, "%*c> _loop0_1[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
25480 Token * newline_var;
25481 while (
25482 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
25483 )
25484 {
25485 _res = newline_var;
25486 if (_n == _children_capacity) {
25487 _children_capacity *= 2;
25488 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25489 if (!_new_children) {
25490 PyMem_Free(_children);
25491 p->error_indicator = 1;
25492 PyErr_NoMemory();
25493 p->level--;
25494 return NULL;
25495 }
25496 _children = _new_children;
25497 }
25498 _children[_n++] = _res;
25499 _mark = p->mark;
25500 }
25501 p->mark = _mark;
25502 D(fprintf(stderr, "%*c%s _loop0_1[%d-%d]: %s failed!\n", p->level, ' ',
25503 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
25504 }
25505 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25506 if (!_seq) {
25507 PyMem_Free(_children);
25508 p->error_indicator = 1;
25509 PyErr_NoMemory();
25510 p->level--;
25511 return NULL;
25512 }
25513 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25514 PyMem_Free(_children);
25515 p->level--;
25516 return _seq;
25517 }
25518
25519 // _loop0_2: NEWLINE
25520 static asdl_seq *
25521 _loop0_2_rule(Parser *p)
25522 {
25523 if (p->level++ == MAXSTACK) {
25524 _Pypegen_stack_overflow(p);
25525 }
25526 if (p->error_indicator) {
25527 p->level--;
25528 return NULL;
25529 }
25530 void *_res = NULL;
25531 int _mark = p->mark;
25532 void **_children = PyMem_Malloc(sizeof(void *));
25533 if (!_children) {
25534 p->error_indicator = 1;
25535 PyErr_NoMemory();
25536 p->level--;
25537 return NULL;
25538 }
25539 Py_ssize_t _children_capacity = 1;
25540 Py_ssize_t _n = 0;
25541 { // NEWLINE
25542 if (p->error_indicator) {
25543 p->level--;
25544 return NULL;
25545 }
25546 D(fprintf(stderr, "%*c> _loop0_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
25547 Token * newline_var;
25548 while (
25549 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
25550 )
25551 {
25552 _res = newline_var;
25553 if (_n == _children_capacity) {
25554 _children_capacity *= 2;
25555 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25556 if (!_new_children) {
25557 PyMem_Free(_children);
25558 p->error_indicator = 1;
25559 PyErr_NoMemory();
25560 p->level--;
25561 return NULL;
25562 }
25563 _children = _new_children;
25564 }
25565 _children[_n++] = _res;
25566 _mark = p->mark;
25567 }
25568 p->mark = _mark;
25569 D(fprintf(stderr, "%*c%s _loop0_2[%d-%d]: %s failed!\n", p->level, ' ',
25570 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
25571 }
25572 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25573 if (!_seq) {
25574 PyMem_Free(_children);
25575 p->error_indicator = 1;
25576 PyErr_NoMemory();
25577 p->level--;
25578 return NULL;
25579 }
25580 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25581 PyMem_Free(_children);
25582 p->level--;
25583 return _seq;
25584 }
25585
25586 // _loop1_3: statement
25587 static asdl_seq *
25588 _loop1_3_rule(Parser *p)
25589 {
25590 if (p->level++ == MAXSTACK) {
25591 _Pypegen_stack_overflow(p);
25592 }
25593 if (p->error_indicator) {
25594 p->level--;
25595 return NULL;
25596 }
25597 void *_res = NULL;
25598 int _mark = p->mark;
25599 void **_children = PyMem_Malloc(sizeof(void *));
25600 if (!_children) {
25601 p->error_indicator = 1;
25602 PyErr_NoMemory();
25603 p->level--;
25604 return NULL;
25605 }
25606 Py_ssize_t _children_capacity = 1;
25607 Py_ssize_t _n = 0;
25608 { // statement
25609 if (p->error_indicator) {
25610 p->level--;
25611 return NULL;
25612 }
25613 D(fprintf(stderr, "%*c> _loop1_3[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement"));
25614 asdl_stmt_seq* statement_var;
25615 while (
25616 (statement_var = statement_rule(p)) // statement
25617 )
25618 {
25619 _res = statement_var;
25620 if (_n == _children_capacity) {
25621 _children_capacity *= 2;
25622 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25623 if (!_new_children) {
25624 PyMem_Free(_children);
25625 p->error_indicator = 1;
25626 PyErr_NoMemory();
25627 p->level--;
25628 return NULL;
25629 }
25630 _children = _new_children;
25631 }
25632 _children[_n++] = _res;
25633 _mark = p->mark;
25634 }
25635 p->mark = _mark;
25636 D(fprintf(stderr, "%*c%s _loop1_3[%d-%d]: %s failed!\n", p->level, ' ',
25637 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement"));
25638 }
25639 if (_n == 0 || p->error_indicator) {
25640 PyMem_Free(_children);
25641 p->level--;
25642 return NULL;
25643 }
25644 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25645 if (!_seq) {
25646 PyMem_Free(_children);
25647 p->error_indicator = 1;
25648 PyErr_NoMemory();
25649 p->level--;
25650 return NULL;
25651 }
25652 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25653 PyMem_Free(_children);
25654 p->level--;
25655 return _seq;
25656 }
25657
25658 // _loop0_5: ';' simple_stmt
25659 static asdl_seq *
25660 _loop0_5_rule(Parser *p)
25661 {
25662 if (p->level++ == MAXSTACK) {
25663 _Pypegen_stack_overflow(p);
25664 }
25665 if (p->error_indicator) {
25666 p->level--;
25667 return NULL;
25668 }
25669 void *_res = NULL;
25670 int _mark = p->mark;
25671 void **_children = PyMem_Malloc(sizeof(void *));
25672 if (!_children) {
25673 p->error_indicator = 1;
25674 PyErr_NoMemory();
25675 p->level--;
25676 return NULL;
25677 }
25678 Py_ssize_t _children_capacity = 1;
25679 Py_ssize_t _n = 0;
25680 { // ';' simple_stmt
25681 if (p->error_indicator) {
25682 p->level--;
25683 return NULL;
25684 }
25685 D(fprintf(stderr, "%*c> _loop0_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';' simple_stmt"));
25686 Token * _literal;
25687 stmt_ty elem;
25688 while (
25689 (_literal = _PyPegen_expect_token(p, 13)) // token=';'
25690 &&
25691 (elem = simple_stmt_rule(p)) // simple_stmt
25692 )
25693 {
25694 _res = elem;
25695 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
25696 p->error_indicator = 1;
25697 PyMem_Free(_children);
25698 p->level--;
25699 return NULL;
25700 }
25701 if (_n == _children_capacity) {
25702 _children_capacity *= 2;
25703 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
25704 if (!_new_children) {
25705 PyMem_Free(_children);
25706 p->error_indicator = 1;
25707 PyErr_NoMemory();
25708 p->level--;
25709 return NULL;
25710 }
25711 _children = _new_children;
25712 }
25713 _children[_n++] = _res;
25714 _mark = p->mark;
25715 }
25716 p->mark = _mark;
25717 D(fprintf(stderr, "%*c%s _loop0_5[%d-%d]: %s failed!\n", p->level, ' ',
25718 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';' simple_stmt"));
25719 }
25720 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
25721 if (!_seq) {
25722 PyMem_Free(_children);
25723 p->error_indicator = 1;
25724 PyErr_NoMemory();
25725 p->level--;
25726 return NULL;
25727 }
25728 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
25729 PyMem_Free(_children);
25730 p->level--;
25731 return _seq;
25732 }
25733
25734 // _gather_4: simple_stmt _loop0_5
25735 static asdl_seq *
25736 _gather_4_rule(Parser *p)
25737 {
25738 if (p->level++ == MAXSTACK) {
25739 _Pypegen_stack_overflow(p);
25740 }
25741 if (p->error_indicator) {
25742 p->level--;
25743 return NULL;
25744 }
25745 asdl_seq * _res = NULL;
25746 int _mark = p->mark;
25747 { // simple_stmt _loop0_5
25748 if (p->error_indicator) {
25749 p->level--;
25750 return NULL;
25751 }
25752 D(fprintf(stderr, "%*c> _gather_4[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt _loop0_5"));
25753 stmt_ty elem;
25754 asdl_seq * seq;
25755 if (
25756 (elem = simple_stmt_rule(p)) // simple_stmt
25757 &&
25758 (seq = _loop0_5_rule(p)) // _loop0_5
25759 )
25760 {
25761 D(fprintf(stderr, "%*c+ _gather_4[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt _loop0_5"));
25762 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
25763 goto done;
25764 }
25765 p->mark = _mark;
25766 D(fprintf(stderr, "%*c%s _gather_4[%d-%d]: %s failed!\n", p->level, ' ',
25767 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt _loop0_5"));
25768 }
25769 _res = NULL;
25770 done:
25771 p->level--;
25772 return _res;
25773 }
25774
25775 // _tmp_6: 'import' | 'from'
25776 static void *
25777 _tmp_6_rule(Parser *p)
25778 {
25779 if (p->level++ == MAXSTACK) {
25780 _Pypegen_stack_overflow(p);
25781 }
25782 if (p->error_indicator) {
25783 p->level--;
25784 return NULL;
25785 }
25786 void * _res = NULL;
25787 int _mark = p->mark;
25788 { // 'import'
25789 if (p->error_indicator) {
25790 p->level--;
25791 return NULL;
25792 }
25793 D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'"));
25794 Token * _keyword;
25795 if (
25796 (_keyword = _PyPegen_expect_token(p, 622)) // token='import'
25797 )
25798 {
25799 D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'"));
25800 _res = _keyword;
25801 goto done;
25802 }
25803 p->mark = _mark;
25804 D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ',
25805 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import'"));
25806 }
25807 { // 'from'
25808 if (p->error_indicator) {
25809 p->level--;
25810 return NULL;
25811 }
25812 D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'"));
25813 Token * _keyword;
25814 if (
25815 (_keyword = _PyPegen_expect_token(p, 621)) // token='from'
25816 )
25817 {
25818 D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'"));
25819 _res = _keyword;
25820 goto done;
25821 }
25822 p->mark = _mark;
25823 D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ',
25824 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from'"));
25825 }
25826 _res = NULL;
25827 done:
25828 p->level--;
25829 return _res;
25830 }
25831
25832 // _tmp_7: 'def' | '@' | 'async'
25833 static void *
25834 _tmp_7_rule(Parser *p)
25835 {
25836 if (p->level++ == MAXSTACK) {
25837 _Pypegen_stack_overflow(p);
25838 }
25839 if (p->error_indicator) {
25840 p->level--;
25841 return NULL;
25842 }
25843 void * _res = NULL;
25844 int _mark = p->mark;
25845 { // 'def'
25846 if (p->error_indicator) {
25847 p->level--;
25848 return NULL;
25849 }
25850 D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'"));
25851 Token * _keyword;
25852 if (
25853 (_keyword = _PyPegen_expect_token(p, 675)) // token='def'
25854 )
25855 {
25856 D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'"));
25857 _res = _keyword;
25858 goto done;
25859 }
25860 p->mark = _mark;
25861 D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ',
25862 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def'"));
25863 }
25864 { // '@'
25865 if (p->error_indicator) {
25866 p->level--;
25867 return NULL;
25868 }
25869 D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
25870 Token * _literal;
25871 if (
25872 (_literal = _PyPegen_expect_token(p, 49)) // token='@'
25873 )
25874 {
25875 D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
25876 _res = _literal;
25877 goto done;
25878 }
25879 p->mark = _mark;
25880 D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ',
25881 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
25882 }
25883 { // 'async'
25884 if (p->error_indicator) {
25885 p->level--;
25886 return NULL;
25887 }
25888 D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'"));
25889 Token * _keyword;
25890 if (
25891 (_keyword = _PyPegen_expect_token(p, 674)) // token='async'
25892 )
25893 {
25894 D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'"));
25895 _res = _keyword;
25896 goto done;
25897 }
25898 p->mark = _mark;
25899 D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ',
25900 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'"));
25901 }
25902 _res = NULL;
25903 done:
25904 p->level--;
25905 return _res;
25906 }
25907
25908 // _tmp_8: 'class' | '@'
25909 static void *
25910 _tmp_8_rule(Parser *p)
25911 {
25912 if (p->level++ == MAXSTACK) {
25913 _Pypegen_stack_overflow(p);
25914 }
25915 if (p->error_indicator) {
25916 p->level--;
25917 return NULL;
25918 }
25919 void * _res = NULL;
25920 int _mark = p->mark;
25921 { // 'class'
25922 if (p->error_indicator) {
25923 p->level--;
25924 return NULL;
25925 }
25926 D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'"));
25927 Token * _keyword;
25928 if (
25929 (_keyword = _PyPegen_expect_token(p, 677)) // token='class'
25930 )
25931 {
25932 D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'"));
25933 _res = _keyword;
25934 goto done;
25935 }
25936 p->mark = _mark;
25937 D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ',
25938 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class'"));
25939 }
25940 { // '@'
25941 if (p->error_indicator) {
25942 p->level--;
25943 return NULL;
25944 }
25945 D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
25946 Token * _literal;
25947 if (
25948 (_literal = _PyPegen_expect_token(p, 49)) // token='@'
25949 )
25950 {
25951 D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
25952 _res = _literal;
25953 goto done;
25954 }
25955 p->mark = _mark;
25956 D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ',
25957 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
25958 }
25959 _res = NULL;
25960 done:
25961 p->level--;
25962 return _res;
25963 }
25964
25965 // _tmp_9: 'with' | 'async'
25966 static void *
25967 _tmp_9_rule(Parser *p)
25968 {
25969 if (p->level++ == MAXSTACK) {
25970 _Pypegen_stack_overflow(p);
25971 }
25972 if (p->error_indicator) {
25973 p->level--;
25974 return NULL;
25975 }
25976 void * _res = NULL;
25977 int _mark = p->mark;
25978 { // 'with'
25979 if (p->error_indicator) {
25980 p->level--;
25981 return NULL;
25982 }
25983 D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'"));
25984 Token * _keyword;
25985 if (
25986 (_keyword = _PyPegen_expect_token(p, 633)) // token='with'
25987 )
25988 {
25989 D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'"));
25990 _res = _keyword;
25991 goto done;
25992 }
25993 p->mark = _mark;
25994 D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ',
25995 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with'"));
25996 }
25997 { // 'async'
25998 if (p->error_indicator) {
25999 p->level--;
26000 return NULL;
26001 }
26002 D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'"));
26003 Token * _keyword;
26004 if (
26005 (_keyword = _PyPegen_expect_token(p, 674)) // token='async'
26006 )
26007 {
26008 D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'"));
26009 _res = _keyword;
26010 goto done;
26011 }
26012 p->mark = _mark;
26013 D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ',
26014 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'"));
26015 }
26016 _res = NULL;
26017 done:
26018 p->level--;
26019 return _res;
26020 }
26021
26022 // _tmp_10: 'for' | 'async'
26023 static void *
26024 _tmp_10_rule(Parser *p)
26025 {
26026 if (p->level++ == MAXSTACK) {
26027 _Pypegen_stack_overflow(p);
26028 }
26029 if (p->error_indicator) {
26030 p->level--;
26031 return NULL;
26032 }
26033 void * _res = NULL;
26034 int _mark = p->mark;
26035 { // 'for'
26036 if (p->error_indicator) {
26037 p->level--;
26038 return NULL;
26039 }
26040 D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'"));
26041 Token * _keyword;
26042 if (
26043 (_keyword = _PyPegen_expect_token(p, 670)) // token='for'
26044 )
26045 {
26046 D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'"));
26047 _res = _keyword;
26048 goto done;
26049 }
26050 p->mark = _mark;
26051 D(fprintf(stderr, "%*c%s _tmp_10[%d-%d]: %s failed!\n", p->level, ' ',
26052 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for'"));
26053 }
26054 { // 'async'
26055 if (p->error_indicator) {
26056 p->level--;
26057 return NULL;
26058 }
26059 D(fprintf(stderr, "%*c> _tmp_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'"));
26060 Token * _keyword;
26061 if (
26062 (_keyword = _PyPegen_expect_token(p, 674)) // token='async'
26063 )
26064 {
26065 D(fprintf(stderr, "%*c+ _tmp_10[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'"));
26066 _res = _keyword;
26067 goto done;
26068 }
26069 p->mark = _mark;
26070 D(fprintf(stderr, "%*c%s _tmp_10[%d-%d]: %s failed!\n", p->level, ' ',
26071 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'"));
26072 }
26073 _res = NULL;
26074 done:
26075 p->level--;
26076 return _res;
26077 }
26078
26079 // _tmp_11: '=' annotated_rhs
26080 static void *
26081 _tmp_11_rule(Parser *p)
26082 {
26083 if (p->level++ == MAXSTACK) {
26084 _Pypegen_stack_overflow(p);
26085 }
26086 if (p->error_indicator) {
26087 p->level--;
26088 return NULL;
26089 }
26090 void * _res = NULL;
26091 int _mark = p->mark;
26092 { // '=' annotated_rhs
26093 if (p->error_indicator) {
26094 p->level--;
26095 return NULL;
26096 }
26097 D(fprintf(stderr, "%*c> _tmp_11[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
26098 Token * _literal;
26099 expr_ty d;
26100 if (
26101 (_literal = _PyPegen_expect_token(p, 22)) // token='='
26102 &&
26103 (d = annotated_rhs_rule(p)) // annotated_rhs
26104 )
26105 {
26106 D(fprintf(stderr, "%*c+ _tmp_11[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
26107 _res = d;
26108 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
26109 p->error_indicator = 1;
26110 p->level--;
26111 return NULL;
26112 }
26113 goto done;
26114 }
26115 p->mark = _mark;
26116 D(fprintf(stderr, "%*c%s _tmp_11[%d-%d]: %s failed!\n", p->level, ' ',
26117 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs"));
26118 }
26119 _res = NULL;
26120 done:
26121 p->level--;
26122 return _res;
26123 }
26124
26125 // _tmp_12: '(' single_target ')' | single_subscript_attribute_target
26126 static void *
26127 _tmp_12_rule(Parser *p)
26128 {
26129 if (p->level++ == MAXSTACK) {
26130 _Pypegen_stack_overflow(p);
26131 }
26132 if (p->error_indicator) {
26133 p->level--;
26134 return NULL;
26135 }
26136 void * _res = NULL;
26137 int _mark = p->mark;
26138 { // '(' single_target ')'
26139 if (p->error_indicator) {
26140 p->level--;
26141 return NULL;
26142 }
26143 D(fprintf(stderr, "%*c> _tmp_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
26144 Token * _literal;
26145 Token * _literal_1;
26146 expr_ty b;
26147 if (
26148 (_literal = _PyPegen_expect_token(p, 7)) // token='('
26149 &&
26150 (b = single_target_rule(p)) // single_target
26151 &&
26152 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
26153 )
26154 {
26155 D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
26156 _res = b;
26157 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
26158 p->error_indicator = 1;
26159 p->level--;
26160 return NULL;
26161 }
26162 goto done;
26163 }
26164 p->mark = _mark;
26165 D(fprintf(stderr, "%*c%s _tmp_12[%d-%d]: %s failed!\n", p->level, ' ',
26166 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'"));
26167 }
26168 { // single_subscript_attribute_target
26169 if (p->error_indicator) {
26170 p->level--;
26171 return NULL;
26172 }
26173 D(fprintf(stderr, "%*c> _tmp_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
26174 expr_ty single_subscript_attribute_target_var;
26175 if (
26176 (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p)) // single_subscript_attribute_target
26177 )
26178 {
26179 D(fprintf(stderr, "%*c+ _tmp_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
26180 _res = single_subscript_attribute_target_var;
26181 goto done;
26182 }
26183 p->mark = _mark;
26184 D(fprintf(stderr, "%*c%s _tmp_12[%d-%d]: %s failed!\n", p->level, ' ',
26185 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target"));
26186 }
26187 _res = NULL;
26188 done:
26189 p->level--;
26190 return _res;
26191 }
26192
26193 // _tmp_13: '=' annotated_rhs
26194 static void *
26195 _tmp_13_rule(Parser *p)
26196 {
26197 if (p->level++ == MAXSTACK) {
26198 _Pypegen_stack_overflow(p);
26199 }
26200 if (p->error_indicator) {
26201 p->level--;
26202 return NULL;
26203 }
26204 void * _res = NULL;
26205 int _mark = p->mark;
26206 { // '=' annotated_rhs
26207 if (p->error_indicator) {
26208 p->level--;
26209 return NULL;
26210 }
26211 D(fprintf(stderr, "%*c> _tmp_13[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
26212 Token * _literal;
26213 expr_ty d;
26214 if (
26215 (_literal = _PyPegen_expect_token(p, 22)) // token='='
26216 &&
26217 (d = annotated_rhs_rule(p)) // annotated_rhs
26218 )
26219 {
26220 D(fprintf(stderr, "%*c+ _tmp_13[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
26221 _res = d;
26222 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
26223 p->error_indicator = 1;
26224 p->level--;
26225 return NULL;
26226 }
26227 goto done;
26228 }
26229 p->mark = _mark;
26230 D(fprintf(stderr, "%*c%s _tmp_13[%d-%d]: %s failed!\n", p->level, ' ',
26231 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs"));
26232 }
26233 _res = NULL;
26234 done:
26235 p->level--;
26236 return _res;
26237 }
26238
26239 // _loop1_14: (star_targets '=')
26240 static asdl_seq *
26241 _loop1_14_rule(Parser *p)
26242 {
26243 if (p->level++ == MAXSTACK) {
26244 _Pypegen_stack_overflow(p);
26245 }
26246 if (p->error_indicator) {
26247 p->level--;
26248 return NULL;
26249 }
26250 void *_res = NULL;
26251 int _mark = p->mark;
26252 void **_children = PyMem_Malloc(sizeof(void *));
26253 if (!_children) {
26254 p->error_indicator = 1;
26255 PyErr_NoMemory();
26256 p->level--;
26257 return NULL;
26258 }
26259 Py_ssize_t _children_capacity = 1;
26260 Py_ssize_t _n = 0;
26261 { // (star_targets '=')
26262 if (p->error_indicator) {
26263 p->level--;
26264 return NULL;
26265 }
26266 D(fprintf(stderr, "%*c> _loop1_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
26267 void *_tmp_245_var;
26268 while (
26269 (_tmp_245_var = _tmp_245_rule(p)) // star_targets '='
26270 )
26271 {
26272 _res = _tmp_245_var;
26273 if (_n == _children_capacity) {
26274 _children_capacity *= 2;
26275 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26276 if (!_new_children) {
26277 PyMem_Free(_children);
26278 p->error_indicator = 1;
26279 PyErr_NoMemory();
26280 p->level--;
26281 return NULL;
26282 }
26283 _children = _new_children;
26284 }
26285 _children[_n++] = _res;
26286 _mark = p->mark;
26287 }
26288 p->mark = _mark;
26289 D(fprintf(stderr, "%*c%s _loop1_14[%d-%d]: %s failed!\n", p->level, ' ',
26290 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));
26291 }
26292 if (_n == 0 || p->error_indicator) {
26293 PyMem_Free(_children);
26294 p->level--;
26295 return NULL;
26296 }
26297 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26298 if (!_seq) {
26299 PyMem_Free(_children);
26300 p->error_indicator = 1;
26301 PyErr_NoMemory();
26302 p->level--;
26303 return NULL;
26304 }
26305 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26306 PyMem_Free(_children);
26307 p->level--;
26308 return _seq;
26309 }
26310
26311 // _tmp_15: yield_expr | star_expressions
26312 static void *
26313 _tmp_15_rule(Parser *p)
26314 {
26315 if (p->level++ == MAXSTACK) {
26316 _Pypegen_stack_overflow(p);
26317 }
26318 if (p->error_indicator) {
26319 p->level--;
26320 return NULL;
26321 }
26322 void * _res = NULL;
26323 int _mark = p->mark;
26324 { // yield_expr
26325 if (p->error_indicator) {
26326 p->level--;
26327 return NULL;
26328 }
26329 D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
26330 expr_ty yield_expr_var;
26331 if (
26332 (yield_expr_var = yield_expr_rule(p)) // yield_expr
26333 )
26334 {
26335 D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
26336 _res = yield_expr_var;
26337 goto done;
26338 }
26339 p->mark = _mark;
26340 D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',
26341 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
26342 }
26343 { // star_expressions
26344 if (p->error_indicator) {
26345 p->level--;
26346 return NULL;
26347 }
26348 D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
26349 expr_ty star_expressions_var;
26350 if (
26351 (star_expressions_var = star_expressions_rule(p)) // star_expressions
26352 )
26353 {
26354 D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
26355 _res = star_expressions_var;
26356 goto done;
26357 }
26358 p->mark = _mark;
26359 D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',
26360 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
26361 }
26362 _res = NULL;
26363 done:
26364 p->level--;
26365 return _res;
26366 }
26367
26368 // _tmp_16: yield_expr | star_expressions
26369 static void *
26370 _tmp_16_rule(Parser *p)
26371 {
26372 if (p->level++ == MAXSTACK) {
26373 _Pypegen_stack_overflow(p);
26374 }
26375 if (p->error_indicator) {
26376 p->level--;
26377 return NULL;
26378 }
26379 void * _res = NULL;
26380 int _mark = p->mark;
26381 { // yield_expr
26382 if (p->error_indicator) {
26383 p->level--;
26384 return NULL;
26385 }
26386 D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
26387 expr_ty yield_expr_var;
26388 if (
26389 (yield_expr_var = yield_expr_rule(p)) // yield_expr
26390 )
26391 {
26392 D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
26393 _res = yield_expr_var;
26394 goto done;
26395 }
26396 p->mark = _mark;
26397 D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ',
26398 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
26399 }
26400 { // star_expressions
26401 if (p->error_indicator) {
26402 p->level--;
26403 return NULL;
26404 }
26405 D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
26406 expr_ty star_expressions_var;
26407 if (
26408 (star_expressions_var = star_expressions_rule(p)) // star_expressions
26409 )
26410 {
26411 D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
26412 _res = star_expressions_var;
26413 goto done;
26414 }
26415 p->mark = _mark;
26416 D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ',
26417 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
26418 }
26419 _res = NULL;
26420 done:
26421 p->level--;
26422 return _res;
26423 }
26424
26425 // _tmp_17: 'from' expression
26426 static void *
26427 _tmp_17_rule(Parser *p)
26428 {
26429 if (p->level++ == MAXSTACK) {
26430 _Pypegen_stack_overflow(p);
26431 }
26432 if (p->error_indicator) {
26433 p->level--;
26434 return NULL;
26435 }
26436 void * _res = NULL;
26437 int _mark = p->mark;
26438 { // 'from' expression
26439 if (p->error_indicator) {
26440 p->level--;
26441 return NULL;
26442 }
26443 D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' expression"));
26444 Token * _keyword;
26445 expr_ty z;
26446 if (
26447 (_keyword = _PyPegen_expect_token(p, 621)) // token='from'
26448 &&
26449 (z = expression_rule(p)) // expression
26450 )
26451 {
26452 D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' expression"));
26453 _res = z;
26454 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
26455 p->error_indicator = 1;
26456 p->level--;
26457 return NULL;
26458 }
26459 goto done;
26460 }
26461 p->mark = _mark;
26462 D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ',
26463 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' expression"));
26464 }
26465 _res = NULL;
26466 done:
26467 p->level--;
26468 return _res;
26469 }
26470
26471 // _loop0_19: ',' NAME
26472 static asdl_seq *
26473 _loop0_19_rule(Parser *p)
26474 {
26475 if (p->level++ == MAXSTACK) {
26476 _Pypegen_stack_overflow(p);
26477 }
26478 if (p->error_indicator) {
26479 p->level--;
26480 return NULL;
26481 }
26482 void *_res = NULL;
26483 int _mark = p->mark;
26484 void **_children = PyMem_Malloc(sizeof(void *));
26485 if (!_children) {
26486 p->error_indicator = 1;
26487 PyErr_NoMemory();
26488 p->level--;
26489 return NULL;
26490 }
26491 Py_ssize_t _children_capacity = 1;
26492 Py_ssize_t _n = 0;
26493 { // ',' NAME
26494 if (p->error_indicator) {
26495 p->level--;
26496 return NULL;
26497 }
26498 D(fprintf(stderr, "%*c> _loop0_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));
26499 Token * _literal;
26500 expr_ty elem;
26501 while (
26502 (_literal = _PyPegen_expect_token(p, 12)) // token=','
26503 &&
26504 (elem = _PyPegen_name_token(p)) // NAME
26505 )
26506 {
26507 _res = elem;
26508 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
26509 p->error_indicator = 1;
26510 PyMem_Free(_children);
26511 p->level--;
26512 return NULL;
26513 }
26514 if (_n == _children_capacity) {
26515 _children_capacity *= 2;
26516 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26517 if (!_new_children) {
26518 PyMem_Free(_children);
26519 p->error_indicator = 1;
26520 PyErr_NoMemory();
26521 p->level--;
26522 return NULL;
26523 }
26524 _children = _new_children;
26525 }
26526 _children[_n++] = _res;
26527 _mark = p->mark;
26528 }
26529 p->mark = _mark;
26530 D(fprintf(stderr, "%*c%s _loop0_19[%d-%d]: %s failed!\n", p->level, ' ',
26531 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME"));
26532 }
26533 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26534 if (!_seq) {
26535 PyMem_Free(_children);
26536 p->error_indicator = 1;
26537 PyErr_NoMemory();
26538 p->level--;
26539 return NULL;
26540 }
26541 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26542 PyMem_Free(_children);
26543 p->level--;
26544 return _seq;
26545 }
26546
26547 // _gather_18: NAME _loop0_19
26548 static asdl_seq *
26549 _gather_18_rule(Parser *p)
26550 {
26551 if (p->level++ == MAXSTACK) {
26552 _Pypegen_stack_overflow(p);
26553 }
26554 if (p->error_indicator) {
26555 p->level--;
26556 return NULL;
26557 }
26558 asdl_seq * _res = NULL;
26559 int _mark = p->mark;
26560 { // NAME _loop0_19
26561 if (p->error_indicator) {
26562 p->level--;
26563 return NULL;
26564 }
26565 D(fprintf(stderr, "%*c> _gather_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_19"));
26566 expr_ty elem;
26567 asdl_seq * seq;
26568 if (
26569 (elem = _PyPegen_name_token(p)) // NAME
26570 &&
26571 (seq = _loop0_19_rule(p)) // _loop0_19
26572 )
26573 {
26574 D(fprintf(stderr, "%*c+ _gather_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_19"));
26575 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
26576 goto done;
26577 }
26578 p->mark = _mark;
26579 D(fprintf(stderr, "%*c%s _gather_18[%d-%d]: %s failed!\n", p->level, ' ',
26580 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_19"));
26581 }
26582 _res = NULL;
26583 done:
26584 p->level--;
26585 return _res;
26586 }
26587
26588 // _loop0_21: ',' NAME
26589 static asdl_seq *
26590 _loop0_21_rule(Parser *p)
26591 {
26592 if (p->level++ == MAXSTACK) {
26593 _Pypegen_stack_overflow(p);
26594 }
26595 if (p->error_indicator) {
26596 p->level--;
26597 return NULL;
26598 }
26599 void *_res = NULL;
26600 int _mark = p->mark;
26601 void **_children = PyMem_Malloc(sizeof(void *));
26602 if (!_children) {
26603 p->error_indicator = 1;
26604 PyErr_NoMemory();
26605 p->level--;
26606 return NULL;
26607 }
26608 Py_ssize_t _children_capacity = 1;
26609 Py_ssize_t _n = 0;
26610 { // ',' NAME
26611 if (p->error_indicator) {
26612 p->level--;
26613 return NULL;
26614 }
26615 D(fprintf(stderr, "%*c> _loop0_21[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));
26616 Token * _literal;
26617 expr_ty elem;
26618 while (
26619 (_literal = _PyPegen_expect_token(p, 12)) // token=','
26620 &&
26621 (elem = _PyPegen_name_token(p)) // NAME
26622 )
26623 {
26624 _res = elem;
26625 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
26626 p->error_indicator = 1;
26627 PyMem_Free(_children);
26628 p->level--;
26629 return NULL;
26630 }
26631 if (_n == _children_capacity) {
26632 _children_capacity *= 2;
26633 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26634 if (!_new_children) {
26635 PyMem_Free(_children);
26636 p->error_indicator = 1;
26637 PyErr_NoMemory();
26638 p->level--;
26639 return NULL;
26640 }
26641 _children = _new_children;
26642 }
26643 _children[_n++] = _res;
26644 _mark = p->mark;
26645 }
26646 p->mark = _mark;
26647 D(fprintf(stderr, "%*c%s _loop0_21[%d-%d]: %s failed!\n", p->level, ' ',
26648 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME"));
26649 }
26650 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26651 if (!_seq) {
26652 PyMem_Free(_children);
26653 p->error_indicator = 1;
26654 PyErr_NoMemory();
26655 p->level--;
26656 return NULL;
26657 }
26658 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26659 PyMem_Free(_children);
26660 p->level--;
26661 return _seq;
26662 }
26663
26664 // _gather_20: NAME _loop0_21
26665 static asdl_seq *
26666 _gather_20_rule(Parser *p)
26667 {
26668 if (p->level++ == MAXSTACK) {
26669 _Pypegen_stack_overflow(p);
26670 }
26671 if (p->error_indicator) {
26672 p->level--;
26673 return NULL;
26674 }
26675 asdl_seq * _res = NULL;
26676 int _mark = p->mark;
26677 { // NAME _loop0_21
26678 if (p->error_indicator) {
26679 p->level--;
26680 return NULL;
26681 }
26682 D(fprintf(stderr, "%*c> _gather_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_21"));
26683 expr_ty elem;
26684 asdl_seq * seq;
26685 if (
26686 (elem = _PyPegen_name_token(p)) // NAME
26687 &&
26688 (seq = _loop0_21_rule(p)) // _loop0_21
26689 )
26690 {
26691 D(fprintf(stderr, "%*c+ _gather_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_21"));
26692 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
26693 goto done;
26694 }
26695 p->mark = _mark;
26696 D(fprintf(stderr, "%*c%s _gather_20[%d-%d]: %s failed!\n", p->level, ' ',
26697 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_21"));
26698 }
26699 _res = NULL;
26700 done:
26701 p->level--;
26702 return _res;
26703 }
26704
26705 // _tmp_22: ';' | NEWLINE
26706 static void *
26707 _tmp_22_rule(Parser *p)
26708 {
26709 if (p->level++ == MAXSTACK) {
26710 _Pypegen_stack_overflow(p);
26711 }
26712 if (p->error_indicator) {
26713 p->level--;
26714 return NULL;
26715 }
26716 void * _res = NULL;
26717 int _mark = p->mark;
26718 { // ';'
26719 if (p->error_indicator) {
26720 p->level--;
26721 return NULL;
26722 }
26723 D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'"));
26724 Token * _literal;
26725 if (
26726 (_literal = _PyPegen_expect_token(p, 13)) // token=';'
26727 )
26728 {
26729 D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'"));
26730 _res = _literal;
26731 goto done;
26732 }
26733 p->mark = _mark;
26734 D(fprintf(stderr, "%*c%s _tmp_22[%d-%d]: %s failed!\n", p->level, ' ',
26735 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'"));
26736 }
26737 { // NEWLINE
26738 if (p->error_indicator) {
26739 p->level--;
26740 return NULL;
26741 }
26742 D(fprintf(stderr, "%*c> _tmp_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
26743 Token * newline_var;
26744 if (
26745 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
26746 )
26747 {
26748 D(fprintf(stderr, "%*c+ _tmp_22[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
26749 _res = newline_var;
26750 goto done;
26751 }
26752 p->mark = _mark;
26753 D(fprintf(stderr, "%*c%s _tmp_22[%d-%d]: %s failed!\n", p->level, ' ',
26754 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
26755 }
26756 _res = NULL;
26757 done:
26758 p->level--;
26759 return _res;
26760 }
26761
26762 // _tmp_23: ',' expression
26763 static void *
26764 _tmp_23_rule(Parser *p)
26765 {
26766 if (p->level++ == MAXSTACK) {
26767 _Pypegen_stack_overflow(p);
26768 }
26769 if (p->error_indicator) {
26770 p->level--;
26771 return NULL;
26772 }
26773 void * _res = NULL;
26774 int _mark = p->mark;
26775 { // ',' expression
26776 if (p->error_indicator) {
26777 p->level--;
26778 return NULL;
26779 }
26780 D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
26781 Token * _literal;
26782 expr_ty z;
26783 if (
26784 (_literal = _PyPegen_expect_token(p, 12)) // token=','
26785 &&
26786 (z = expression_rule(p)) // expression
26787 )
26788 {
26789 D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression"));
26790 _res = z;
26791 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
26792 p->error_indicator = 1;
26793 p->level--;
26794 return NULL;
26795 }
26796 goto done;
26797 }
26798 p->mark = _mark;
26799 D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ',
26800 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
26801 }
26802 _res = NULL;
26803 done:
26804 p->level--;
26805 return _res;
26806 }
26807
26808 // _loop0_24: ('.' | '...')
26809 static asdl_seq *
26810 _loop0_24_rule(Parser *p)
26811 {
26812 if (p->level++ == MAXSTACK) {
26813 _Pypegen_stack_overflow(p);
26814 }
26815 if (p->error_indicator) {
26816 p->level--;
26817 return NULL;
26818 }
26819 void *_res = NULL;
26820 int _mark = p->mark;
26821 void **_children = PyMem_Malloc(sizeof(void *));
26822 if (!_children) {
26823 p->error_indicator = 1;
26824 PyErr_NoMemory();
26825 p->level--;
26826 return NULL;
26827 }
26828 Py_ssize_t _children_capacity = 1;
26829 Py_ssize_t _n = 0;
26830 { // ('.' | '...')
26831 if (p->error_indicator) {
26832 p->level--;
26833 return NULL;
26834 }
26835 D(fprintf(stderr, "%*c> _loop0_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
26836 void *_tmp_246_var;
26837 while (
26838 (_tmp_246_var = _tmp_246_rule(p)) // '.' | '...'
26839 )
26840 {
26841 _res = _tmp_246_var;
26842 if (_n == _children_capacity) {
26843 _children_capacity *= 2;
26844 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26845 if (!_new_children) {
26846 PyMem_Free(_children);
26847 p->error_indicator = 1;
26848 PyErr_NoMemory();
26849 p->level--;
26850 return NULL;
26851 }
26852 _children = _new_children;
26853 }
26854 _children[_n++] = _res;
26855 _mark = p->mark;
26856 }
26857 p->mark = _mark;
26858 D(fprintf(stderr, "%*c%s _loop0_24[%d-%d]: %s failed!\n", p->level, ' ',
26859 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')"));
26860 }
26861 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26862 if (!_seq) {
26863 PyMem_Free(_children);
26864 p->error_indicator = 1;
26865 PyErr_NoMemory();
26866 p->level--;
26867 return NULL;
26868 }
26869 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26870 PyMem_Free(_children);
26871 p->level--;
26872 return _seq;
26873 }
26874
26875 // _loop1_25: ('.' | '...')
26876 static asdl_seq *
26877 _loop1_25_rule(Parser *p)
26878 {
26879 if (p->level++ == MAXSTACK) {
26880 _Pypegen_stack_overflow(p);
26881 }
26882 if (p->error_indicator) {
26883 p->level--;
26884 return NULL;
26885 }
26886 void *_res = NULL;
26887 int _mark = p->mark;
26888 void **_children = PyMem_Malloc(sizeof(void *));
26889 if (!_children) {
26890 p->error_indicator = 1;
26891 PyErr_NoMemory();
26892 p->level--;
26893 return NULL;
26894 }
26895 Py_ssize_t _children_capacity = 1;
26896 Py_ssize_t _n = 0;
26897 { // ('.' | '...')
26898 if (p->error_indicator) {
26899 p->level--;
26900 return NULL;
26901 }
26902 D(fprintf(stderr, "%*c> _loop1_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
26903 void *_tmp_247_var;
26904 while (
26905 (_tmp_247_var = _tmp_247_rule(p)) // '.' | '...'
26906 )
26907 {
26908 _res = _tmp_247_var;
26909 if (_n == _children_capacity) {
26910 _children_capacity *= 2;
26911 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26912 if (!_new_children) {
26913 PyMem_Free(_children);
26914 p->error_indicator = 1;
26915 PyErr_NoMemory();
26916 p->level--;
26917 return NULL;
26918 }
26919 _children = _new_children;
26920 }
26921 _children[_n++] = _res;
26922 _mark = p->mark;
26923 }
26924 p->mark = _mark;
26925 D(fprintf(stderr, "%*c%s _loop1_25[%d-%d]: %s failed!\n", p->level, ' ',
26926 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')"));
26927 }
26928 if (_n == 0 || p->error_indicator) {
26929 PyMem_Free(_children);
26930 p->level--;
26931 return NULL;
26932 }
26933 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
26934 if (!_seq) {
26935 PyMem_Free(_children);
26936 p->error_indicator = 1;
26937 PyErr_NoMemory();
26938 p->level--;
26939 return NULL;
26940 }
26941 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
26942 PyMem_Free(_children);
26943 p->level--;
26944 return _seq;
26945 }
26946
26947 // _loop0_27: ',' import_from_as_name
26948 static asdl_seq *
26949 _loop0_27_rule(Parser *p)
26950 {
26951 if (p->level++ == MAXSTACK) {
26952 _Pypegen_stack_overflow(p);
26953 }
26954 if (p->error_indicator) {
26955 p->level--;
26956 return NULL;
26957 }
26958 void *_res = NULL;
26959 int _mark = p->mark;
26960 void **_children = PyMem_Malloc(sizeof(void *));
26961 if (!_children) {
26962 p->error_indicator = 1;
26963 PyErr_NoMemory();
26964 p->level--;
26965 return NULL;
26966 }
26967 Py_ssize_t _children_capacity = 1;
26968 Py_ssize_t _n = 0;
26969 { // ',' import_from_as_name
26970 if (p->error_indicator) {
26971 p->level--;
26972 return NULL;
26973 }
26974 D(fprintf(stderr, "%*c> _loop0_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' import_from_as_name"));
26975 Token * _literal;
26976 alias_ty elem;
26977 while (
26978 (_literal = _PyPegen_expect_token(p, 12)) // token=','
26979 &&
26980 (elem = import_from_as_name_rule(p)) // import_from_as_name
26981 )
26982 {
26983 _res = elem;
26984 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
26985 p->error_indicator = 1;
26986 PyMem_Free(_children);
26987 p->level--;
26988 return NULL;
26989 }
26990 if (_n == _children_capacity) {
26991 _children_capacity *= 2;
26992 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
26993 if (!_new_children) {
26994 PyMem_Free(_children);
26995 p->error_indicator = 1;
26996 PyErr_NoMemory();
26997 p->level--;
26998 return NULL;
26999 }
27000 _children = _new_children;
27001 }
27002 _children[_n++] = _res;
27003 _mark = p->mark;
27004 }
27005 p->mark = _mark;
27006 D(fprintf(stderr, "%*c%s _loop0_27[%d-%d]: %s failed!\n", p->level, ' ',
27007 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' import_from_as_name"));
27008 }
27009 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27010 if (!_seq) {
27011 PyMem_Free(_children);
27012 p->error_indicator = 1;
27013 PyErr_NoMemory();
27014 p->level--;
27015 return NULL;
27016 }
27017 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27018 PyMem_Free(_children);
27019 p->level--;
27020 return _seq;
27021 }
27022
27023 // _gather_26: import_from_as_name _loop0_27
27024 static asdl_seq *
27025 _gather_26_rule(Parser *p)
27026 {
27027 if (p->level++ == MAXSTACK) {
27028 _Pypegen_stack_overflow(p);
27029 }
27030 if (p->error_indicator) {
27031 p->level--;
27032 return NULL;
27033 }
27034 asdl_seq * _res = NULL;
27035 int _mark = p->mark;
27036 { // import_from_as_name _loop0_27
27037 if (p->error_indicator) {
27038 p->level--;
27039 return NULL;
27040 }
27041 D(fprintf(stderr, "%*c> _gather_26[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_27"));
27042 alias_ty elem;
27043 asdl_seq * seq;
27044 if (
27045 (elem = import_from_as_name_rule(p)) // import_from_as_name
27046 &&
27047 (seq = _loop0_27_rule(p)) // _loop0_27
27048 )
27049 {
27050 D(fprintf(stderr, "%*c+ _gather_26[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_27"));
27051 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
27052 goto done;
27053 }
27054 p->mark = _mark;
27055 D(fprintf(stderr, "%*c%s _gather_26[%d-%d]: %s failed!\n", p->level, ' ',
27056 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_name _loop0_27"));
27057 }
27058 _res = NULL;
27059 done:
27060 p->level--;
27061 return _res;
27062 }
27063
27064 // _tmp_28: 'as' NAME
27065 static void *
27066 _tmp_28_rule(Parser *p)
27067 {
27068 if (p->level++ == MAXSTACK) {
27069 _Pypegen_stack_overflow(p);
27070 }
27071 if (p->error_indicator) {
27072 p->level--;
27073 return NULL;
27074 }
27075 void * _res = NULL;
27076 int _mark = p->mark;
27077 { // 'as' NAME
27078 if (p->error_indicator) {
27079 p->level--;
27080 return NULL;
27081 }
27082 D(fprintf(stderr, "%*c> _tmp_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
27083 Token * _keyword;
27084 expr_ty z;
27085 if (
27086 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
27087 &&
27088 (z = _PyPegen_name_token(p)) // NAME
27089 )
27090 {
27091 D(fprintf(stderr, "%*c+ _tmp_28[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
27092 _res = z;
27093 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
27094 p->error_indicator = 1;
27095 p->level--;
27096 return NULL;
27097 }
27098 goto done;
27099 }
27100 p->mark = _mark;
27101 D(fprintf(stderr, "%*c%s _tmp_28[%d-%d]: %s failed!\n", p->level, ' ',
27102 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
27103 }
27104 _res = NULL;
27105 done:
27106 p->level--;
27107 return _res;
27108 }
27109
27110 // _loop0_30: ',' dotted_as_name
27111 static asdl_seq *
27112 _loop0_30_rule(Parser *p)
27113 {
27114 if (p->level++ == MAXSTACK) {
27115 _Pypegen_stack_overflow(p);
27116 }
27117 if (p->error_indicator) {
27118 p->level--;
27119 return NULL;
27120 }
27121 void *_res = NULL;
27122 int _mark = p->mark;
27123 void **_children = PyMem_Malloc(sizeof(void *));
27124 if (!_children) {
27125 p->error_indicator = 1;
27126 PyErr_NoMemory();
27127 p->level--;
27128 return NULL;
27129 }
27130 Py_ssize_t _children_capacity = 1;
27131 Py_ssize_t _n = 0;
27132 { // ',' dotted_as_name
27133 if (p->error_indicator) {
27134 p->level--;
27135 return NULL;
27136 }
27137 D(fprintf(stderr, "%*c> _loop0_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_as_name"));
27138 Token * _literal;
27139 alias_ty elem;
27140 while (
27141 (_literal = _PyPegen_expect_token(p, 12)) // token=','
27142 &&
27143 (elem = dotted_as_name_rule(p)) // dotted_as_name
27144 )
27145 {
27146 _res = elem;
27147 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
27148 p->error_indicator = 1;
27149 PyMem_Free(_children);
27150 p->level--;
27151 return NULL;
27152 }
27153 if (_n == _children_capacity) {
27154 _children_capacity *= 2;
27155 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27156 if (!_new_children) {
27157 PyMem_Free(_children);
27158 p->error_indicator = 1;
27159 PyErr_NoMemory();
27160 p->level--;
27161 return NULL;
27162 }
27163 _children = _new_children;
27164 }
27165 _children[_n++] = _res;
27166 _mark = p->mark;
27167 }
27168 p->mark = _mark;
27169 D(fprintf(stderr, "%*c%s _loop0_30[%d-%d]: %s failed!\n", p->level, ' ',
27170 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_as_name"));
27171 }
27172 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27173 if (!_seq) {
27174 PyMem_Free(_children);
27175 p->error_indicator = 1;
27176 PyErr_NoMemory();
27177 p->level--;
27178 return NULL;
27179 }
27180 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27181 PyMem_Free(_children);
27182 p->level--;
27183 return _seq;
27184 }
27185
27186 // _gather_29: dotted_as_name _loop0_30
27187 static asdl_seq *
27188 _gather_29_rule(Parser *p)
27189 {
27190 if (p->level++ == MAXSTACK) {
27191 _Pypegen_stack_overflow(p);
27192 }
27193 if (p->error_indicator) {
27194 p->level--;
27195 return NULL;
27196 }
27197 asdl_seq * _res = NULL;
27198 int _mark = p->mark;
27199 { // dotted_as_name _loop0_30
27200 if (p->error_indicator) {
27201 p->level--;
27202 return NULL;
27203 }
27204 D(fprintf(stderr, "%*c> _gather_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_30"));
27205 alias_ty elem;
27206 asdl_seq * seq;
27207 if (
27208 (elem = dotted_as_name_rule(p)) // dotted_as_name
27209 &&
27210 (seq = _loop0_30_rule(p)) // _loop0_30
27211 )
27212 {
27213 D(fprintf(stderr, "%*c+ _gather_29[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_30"));
27214 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
27215 goto done;
27216 }
27217 p->mark = _mark;
27218 D(fprintf(stderr, "%*c%s _gather_29[%d-%d]: %s failed!\n", p->level, ' ',
27219 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_as_name _loop0_30"));
27220 }
27221 _res = NULL;
27222 done:
27223 p->level--;
27224 return _res;
27225 }
27226
27227 // _tmp_31: 'as' NAME
27228 static void *
27229 _tmp_31_rule(Parser *p)
27230 {
27231 if (p->level++ == MAXSTACK) {
27232 _Pypegen_stack_overflow(p);
27233 }
27234 if (p->error_indicator) {
27235 p->level--;
27236 return NULL;
27237 }
27238 void * _res = NULL;
27239 int _mark = p->mark;
27240 { // 'as' NAME
27241 if (p->error_indicator) {
27242 p->level--;
27243 return NULL;
27244 }
27245 D(fprintf(stderr, "%*c> _tmp_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
27246 Token * _keyword;
27247 expr_ty z;
27248 if (
27249 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
27250 &&
27251 (z = _PyPegen_name_token(p)) // NAME
27252 )
27253 {
27254 D(fprintf(stderr, "%*c+ _tmp_31[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
27255 _res = z;
27256 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
27257 p->error_indicator = 1;
27258 p->level--;
27259 return NULL;
27260 }
27261 goto done;
27262 }
27263 p->mark = _mark;
27264 D(fprintf(stderr, "%*c%s _tmp_31[%d-%d]: %s failed!\n", p->level, ' ',
27265 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
27266 }
27267 _res = NULL;
27268 done:
27269 p->level--;
27270 return _res;
27271 }
27272
27273 // _loop1_32: ('@' named_expression NEWLINE)
27274 static asdl_seq *
27275 _loop1_32_rule(Parser *p)
27276 {
27277 if (p->level++ == MAXSTACK) {
27278 _Pypegen_stack_overflow(p);
27279 }
27280 if (p->error_indicator) {
27281 p->level--;
27282 return NULL;
27283 }
27284 void *_res = NULL;
27285 int _mark = p->mark;
27286 void **_children = PyMem_Malloc(sizeof(void *));
27287 if (!_children) {
27288 p->error_indicator = 1;
27289 PyErr_NoMemory();
27290 p->level--;
27291 return NULL;
27292 }
27293 Py_ssize_t _children_capacity = 1;
27294 Py_ssize_t _n = 0;
27295 { // ('@' named_expression NEWLINE)
27296 if (p->error_indicator) {
27297 p->level--;
27298 return NULL;
27299 }
27300 D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)"));
27301 void *_tmp_248_var;
27302 while (
27303 (_tmp_248_var = _tmp_248_rule(p)) // '@' named_expression NEWLINE
27304 )
27305 {
27306 _res = _tmp_248_var;
27307 if (_n == _children_capacity) {
27308 _children_capacity *= 2;
27309 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27310 if (!_new_children) {
27311 PyMem_Free(_children);
27312 p->error_indicator = 1;
27313 PyErr_NoMemory();
27314 p->level--;
27315 return NULL;
27316 }
27317 _children = _new_children;
27318 }
27319 _children[_n++] = _res;
27320 _mark = p->mark;
27321 }
27322 p->mark = _mark;
27323 D(fprintf(stderr, "%*c%s _loop1_32[%d-%d]: %s failed!\n", p->level, ' ',
27324 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('@' named_expression NEWLINE)"));
27325 }
27326 if (_n == 0 || p->error_indicator) {
27327 PyMem_Free(_children);
27328 p->level--;
27329 return NULL;
27330 }
27331 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27332 if (!_seq) {
27333 PyMem_Free(_children);
27334 p->error_indicator = 1;
27335 PyErr_NoMemory();
27336 p->level--;
27337 return NULL;
27338 }
27339 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27340 PyMem_Free(_children);
27341 p->level--;
27342 return _seq;
27343 }
27344
27345 // _tmp_33: '(' arguments? ')'
27346 static void *
27347 _tmp_33_rule(Parser *p)
27348 {
27349 if (p->level++ == MAXSTACK) {
27350 _Pypegen_stack_overflow(p);
27351 }
27352 if (p->error_indicator) {
27353 p->level--;
27354 return NULL;
27355 }
27356 void * _res = NULL;
27357 int _mark = p->mark;
27358 { // '(' arguments? ')'
27359 if (p->error_indicator) {
27360 p->level--;
27361 return NULL;
27362 }
27363 D(fprintf(stderr, "%*c> _tmp_33[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
27364 Token * _literal;
27365 Token * _literal_1;
27366 void *z;
27367 if (
27368 (_literal = _PyPegen_expect_token(p, 7)) // token='('
27369 &&
27370 (z = arguments_rule(p), !p->error_indicator) // arguments?
27371 &&
27372 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
27373 )
27374 {
27375 D(fprintf(stderr, "%*c+ _tmp_33[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
27376 _res = z;
27377 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
27378 p->error_indicator = 1;
27379 p->level--;
27380 return NULL;
27381 }
27382 goto done;
27383 }
27384 p->mark = _mark;
27385 D(fprintf(stderr, "%*c%s _tmp_33[%d-%d]: %s failed!\n", p->level, ' ',
27386 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'"));
27387 }
27388 _res = NULL;
27389 done:
27390 p->level--;
27391 return _res;
27392 }
27393
27394 // _tmp_34: '->' expression
27395 static void *
27396 _tmp_34_rule(Parser *p)
27397 {
27398 if (p->level++ == MAXSTACK) {
27399 _Pypegen_stack_overflow(p);
27400 }
27401 if (p->error_indicator) {
27402 p->level--;
27403 return NULL;
27404 }
27405 void * _res = NULL;
27406 int _mark = p->mark;
27407 { // '->' expression
27408 if (p->error_indicator) {
27409 p->level--;
27410 return NULL;
27411 }
27412 D(fprintf(stderr, "%*c> _tmp_34[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
27413 Token * _literal;
27414 expr_ty z;
27415 if (
27416 (_literal = _PyPegen_expect_token(p, 51)) // token='->'
27417 &&
27418 (z = expression_rule(p)) // expression
27419 )
27420 {
27421 D(fprintf(stderr, "%*c+ _tmp_34[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
27422 _res = z;
27423 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
27424 p->error_indicator = 1;
27425 p->level--;
27426 return NULL;
27427 }
27428 goto done;
27429 }
27430 p->mark = _mark;
27431 D(fprintf(stderr, "%*c%s _tmp_34[%d-%d]: %s failed!\n", p->level, ' ',
27432 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));
27433 }
27434 _res = NULL;
27435 done:
27436 p->level--;
27437 return _res;
27438 }
27439
27440 // _tmp_35: '->' expression
27441 static void *
27442 _tmp_35_rule(Parser *p)
27443 {
27444 if (p->level++ == MAXSTACK) {
27445 _Pypegen_stack_overflow(p);
27446 }
27447 if (p->error_indicator) {
27448 p->level--;
27449 return NULL;
27450 }
27451 void * _res = NULL;
27452 int _mark = p->mark;
27453 { // '->' expression
27454 if (p->error_indicator) {
27455 p->level--;
27456 return NULL;
27457 }
27458 D(fprintf(stderr, "%*c> _tmp_35[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
27459 Token * _literal;
27460 expr_ty z;
27461 if (
27462 (_literal = _PyPegen_expect_token(p, 51)) // token='->'
27463 &&
27464 (z = expression_rule(p)) // expression
27465 )
27466 {
27467 D(fprintf(stderr, "%*c+ _tmp_35[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
27468 _res = z;
27469 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
27470 p->error_indicator = 1;
27471 p->level--;
27472 return NULL;
27473 }
27474 goto done;
27475 }
27476 p->mark = _mark;
27477 D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ',
27478 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));
27479 }
27480 _res = NULL;
27481 done:
27482 p->level--;
27483 return _res;
27484 }
27485
27486 // _loop0_36: param_no_default
27487 static asdl_seq *
27488 _loop0_36_rule(Parser *p)
27489 {
27490 if (p->level++ == MAXSTACK) {
27491 _Pypegen_stack_overflow(p);
27492 }
27493 if (p->error_indicator) {
27494 p->level--;
27495 return NULL;
27496 }
27497 void *_res = NULL;
27498 int _mark = p->mark;
27499 void **_children = PyMem_Malloc(sizeof(void *));
27500 if (!_children) {
27501 p->error_indicator = 1;
27502 PyErr_NoMemory();
27503 p->level--;
27504 return NULL;
27505 }
27506 Py_ssize_t _children_capacity = 1;
27507 Py_ssize_t _n = 0;
27508 { // param_no_default
27509 if (p->error_indicator) {
27510 p->level--;
27511 return NULL;
27512 }
27513 D(fprintf(stderr, "%*c> _loop0_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
27514 arg_ty param_no_default_var;
27515 while (
27516 (param_no_default_var = param_no_default_rule(p)) // param_no_default
27517 )
27518 {
27519 _res = param_no_default_var;
27520 if (_n == _children_capacity) {
27521 _children_capacity *= 2;
27522 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27523 if (!_new_children) {
27524 PyMem_Free(_children);
27525 p->error_indicator = 1;
27526 PyErr_NoMemory();
27527 p->level--;
27528 return NULL;
27529 }
27530 _children = _new_children;
27531 }
27532 _children[_n++] = _res;
27533 _mark = p->mark;
27534 }
27535 p->mark = _mark;
27536 D(fprintf(stderr, "%*c%s _loop0_36[%d-%d]: %s failed!\n", p->level, ' ',
27537 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
27538 }
27539 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27540 if (!_seq) {
27541 PyMem_Free(_children);
27542 p->error_indicator = 1;
27543 PyErr_NoMemory();
27544 p->level--;
27545 return NULL;
27546 }
27547 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27548 PyMem_Free(_children);
27549 p->level--;
27550 return _seq;
27551 }
27552
27553 // _loop0_37: param_with_default
27554 static asdl_seq *
27555 _loop0_37_rule(Parser *p)
27556 {
27557 if (p->level++ == MAXSTACK) {
27558 _Pypegen_stack_overflow(p);
27559 }
27560 if (p->error_indicator) {
27561 p->level--;
27562 return NULL;
27563 }
27564 void *_res = NULL;
27565 int _mark = p->mark;
27566 void **_children = PyMem_Malloc(sizeof(void *));
27567 if (!_children) {
27568 p->error_indicator = 1;
27569 PyErr_NoMemory();
27570 p->level--;
27571 return NULL;
27572 }
27573 Py_ssize_t _children_capacity = 1;
27574 Py_ssize_t _n = 0;
27575 { // param_with_default
27576 if (p->error_indicator) {
27577 p->level--;
27578 return NULL;
27579 }
27580 D(fprintf(stderr, "%*c> _loop0_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
27581 NameDefaultPair* param_with_default_var;
27582 while (
27583 (param_with_default_var = param_with_default_rule(p)) // param_with_default
27584 )
27585 {
27586 _res = param_with_default_var;
27587 if (_n == _children_capacity) {
27588 _children_capacity *= 2;
27589 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27590 if (!_new_children) {
27591 PyMem_Free(_children);
27592 p->error_indicator = 1;
27593 PyErr_NoMemory();
27594 p->level--;
27595 return NULL;
27596 }
27597 _children = _new_children;
27598 }
27599 _children[_n++] = _res;
27600 _mark = p->mark;
27601 }
27602 p->mark = _mark;
27603 D(fprintf(stderr, "%*c%s _loop0_37[%d-%d]: %s failed!\n", p->level, ' ',
27604 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
27605 }
27606 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27607 if (!_seq) {
27608 PyMem_Free(_children);
27609 p->error_indicator = 1;
27610 PyErr_NoMemory();
27611 p->level--;
27612 return NULL;
27613 }
27614 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27615 PyMem_Free(_children);
27616 p->level--;
27617 return _seq;
27618 }
27619
27620 // _loop0_38: param_with_default
27621 static asdl_seq *
27622 _loop0_38_rule(Parser *p)
27623 {
27624 if (p->level++ == MAXSTACK) {
27625 _Pypegen_stack_overflow(p);
27626 }
27627 if (p->error_indicator) {
27628 p->level--;
27629 return NULL;
27630 }
27631 void *_res = NULL;
27632 int _mark = p->mark;
27633 void **_children = PyMem_Malloc(sizeof(void *));
27634 if (!_children) {
27635 p->error_indicator = 1;
27636 PyErr_NoMemory();
27637 p->level--;
27638 return NULL;
27639 }
27640 Py_ssize_t _children_capacity = 1;
27641 Py_ssize_t _n = 0;
27642 { // param_with_default
27643 if (p->error_indicator) {
27644 p->level--;
27645 return NULL;
27646 }
27647 D(fprintf(stderr, "%*c> _loop0_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
27648 NameDefaultPair* param_with_default_var;
27649 while (
27650 (param_with_default_var = param_with_default_rule(p)) // param_with_default
27651 )
27652 {
27653 _res = param_with_default_var;
27654 if (_n == _children_capacity) {
27655 _children_capacity *= 2;
27656 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27657 if (!_new_children) {
27658 PyMem_Free(_children);
27659 p->error_indicator = 1;
27660 PyErr_NoMemory();
27661 p->level--;
27662 return NULL;
27663 }
27664 _children = _new_children;
27665 }
27666 _children[_n++] = _res;
27667 _mark = p->mark;
27668 }
27669 p->mark = _mark;
27670 D(fprintf(stderr, "%*c%s _loop0_38[%d-%d]: %s failed!\n", p->level, ' ',
27671 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
27672 }
27673 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27674 if (!_seq) {
27675 PyMem_Free(_children);
27676 p->error_indicator = 1;
27677 PyErr_NoMemory();
27678 p->level--;
27679 return NULL;
27680 }
27681 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27682 PyMem_Free(_children);
27683 p->level--;
27684 return _seq;
27685 }
27686
27687 // _loop1_39: param_no_default
27688 static asdl_seq *
27689 _loop1_39_rule(Parser *p)
27690 {
27691 if (p->level++ == MAXSTACK) {
27692 _Pypegen_stack_overflow(p);
27693 }
27694 if (p->error_indicator) {
27695 p->level--;
27696 return NULL;
27697 }
27698 void *_res = NULL;
27699 int _mark = p->mark;
27700 void **_children = PyMem_Malloc(sizeof(void *));
27701 if (!_children) {
27702 p->error_indicator = 1;
27703 PyErr_NoMemory();
27704 p->level--;
27705 return NULL;
27706 }
27707 Py_ssize_t _children_capacity = 1;
27708 Py_ssize_t _n = 0;
27709 { // param_no_default
27710 if (p->error_indicator) {
27711 p->level--;
27712 return NULL;
27713 }
27714 D(fprintf(stderr, "%*c> _loop1_39[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
27715 arg_ty param_no_default_var;
27716 while (
27717 (param_no_default_var = param_no_default_rule(p)) // param_no_default
27718 )
27719 {
27720 _res = param_no_default_var;
27721 if (_n == _children_capacity) {
27722 _children_capacity *= 2;
27723 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27724 if (!_new_children) {
27725 PyMem_Free(_children);
27726 p->error_indicator = 1;
27727 PyErr_NoMemory();
27728 p->level--;
27729 return NULL;
27730 }
27731 _children = _new_children;
27732 }
27733 _children[_n++] = _res;
27734 _mark = p->mark;
27735 }
27736 p->mark = _mark;
27737 D(fprintf(stderr, "%*c%s _loop1_39[%d-%d]: %s failed!\n", p->level, ' ',
27738 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
27739 }
27740 if (_n == 0 || p->error_indicator) {
27741 PyMem_Free(_children);
27742 p->level--;
27743 return NULL;
27744 }
27745 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27746 if (!_seq) {
27747 PyMem_Free(_children);
27748 p->error_indicator = 1;
27749 PyErr_NoMemory();
27750 p->level--;
27751 return NULL;
27752 }
27753 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27754 PyMem_Free(_children);
27755 p->level--;
27756 return _seq;
27757 }
27758
27759 // _loop0_40: param_with_default
27760 static asdl_seq *
27761 _loop0_40_rule(Parser *p)
27762 {
27763 if (p->level++ == MAXSTACK) {
27764 _Pypegen_stack_overflow(p);
27765 }
27766 if (p->error_indicator) {
27767 p->level--;
27768 return NULL;
27769 }
27770 void *_res = NULL;
27771 int _mark = p->mark;
27772 void **_children = PyMem_Malloc(sizeof(void *));
27773 if (!_children) {
27774 p->error_indicator = 1;
27775 PyErr_NoMemory();
27776 p->level--;
27777 return NULL;
27778 }
27779 Py_ssize_t _children_capacity = 1;
27780 Py_ssize_t _n = 0;
27781 { // param_with_default
27782 if (p->error_indicator) {
27783 p->level--;
27784 return NULL;
27785 }
27786 D(fprintf(stderr, "%*c> _loop0_40[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
27787 NameDefaultPair* param_with_default_var;
27788 while (
27789 (param_with_default_var = param_with_default_rule(p)) // param_with_default
27790 )
27791 {
27792 _res = param_with_default_var;
27793 if (_n == _children_capacity) {
27794 _children_capacity *= 2;
27795 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27796 if (!_new_children) {
27797 PyMem_Free(_children);
27798 p->error_indicator = 1;
27799 PyErr_NoMemory();
27800 p->level--;
27801 return NULL;
27802 }
27803 _children = _new_children;
27804 }
27805 _children[_n++] = _res;
27806 _mark = p->mark;
27807 }
27808 p->mark = _mark;
27809 D(fprintf(stderr, "%*c%s _loop0_40[%d-%d]: %s failed!\n", p->level, ' ',
27810 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
27811 }
27812 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27813 if (!_seq) {
27814 PyMem_Free(_children);
27815 p->error_indicator = 1;
27816 PyErr_NoMemory();
27817 p->level--;
27818 return NULL;
27819 }
27820 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27821 PyMem_Free(_children);
27822 p->level--;
27823 return _seq;
27824 }
27825
27826 // _loop1_41: param_with_default
27827 static asdl_seq *
27828 _loop1_41_rule(Parser *p)
27829 {
27830 if (p->level++ == MAXSTACK) {
27831 _Pypegen_stack_overflow(p);
27832 }
27833 if (p->error_indicator) {
27834 p->level--;
27835 return NULL;
27836 }
27837 void *_res = NULL;
27838 int _mark = p->mark;
27839 void **_children = PyMem_Malloc(sizeof(void *));
27840 if (!_children) {
27841 p->error_indicator = 1;
27842 PyErr_NoMemory();
27843 p->level--;
27844 return NULL;
27845 }
27846 Py_ssize_t _children_capacity = 1;
27847 Py_ssize_t _n = 0;
27848 { // param_with_default
27849 if (p->error_indicator) {
27850 p->level--;
27851 return NULL;
27852 }
27853 D(fprintf(stderr, "%*c> _loop1_41[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
27854 NameDefaultPair* param_with_default_var;
27855 while (
27856 (param_with_default_var = param_with_default_rule(p)) // param_with_default
27857 )
27858 {
27859 _res = param_with_default_var;
27860 if (_n == _children_capacity) {
27861 _children_capacity *= 2;
27862 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27863 if (!_new_children) {
27864 PyMem_Free(_children);
27865 p->error_indicator = 1;
27866 PyErr_NoMemory();
27867 p->level--;
27868 return NULL;
27869 }
27870 _children = _new_children;
27871 }
27872 _children[_n++] = _res;
27873 _mark = p->mark;
27874 }
27875 p->mark = _mark;
27876 D(fprintf(stderr, "%*c%s _loop1_41[%d-%d]: %s failed!\n", p->level, ' ',
27877 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
27878 }
27879 if (_n == 0 || p->error_indicator) {
27880 PyMem_Free(_children);
27881 p->level--;
27882 return NULL;
27883 }
27884 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27885 if (!_seq) {
27886 PyMem_Free(_children);
27887 p->error_indicator = 1;
27888 PyErr_NoMemory();
27889 p->level--;
27890 return NULL;
27891 }
27892 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27893 PyMem_Free(_children);
27894 p->level--;
27895 return _seq;
27896 }
27897
27898 // _loop1_42: param_no_default
27899 static asdl_seq *
27900 _loop1_42_rule(Parser *p)
27901 {
27902 if (p->level++ == MAXSTACK) {
27903 _Pypegen_stack_overflow(p);
27904 }
27905 if (p->error_indicator) {
27906 p->level--;
27907 return NULL;
27908 }
27909 void *_res = NULL;
27910 int _mark = p->mark;
27911 void **_children = PyMem_Malloc(sizeof(void *));
27912 if (!_children) {
27913 p->error_indicator = 1;
27914 PyErr_NoMemory();
27915 p->level--;
27916 return NULL;
27917 }
27918 Py_ssize_t _children_capacity = 1;
27919 Py_ssize_t _n = 0;
27920 { // param_no_default
27921 if (p->error_indicator) {
27922 p->level--;
27923 return NULL;
27924 }
27925 D(fprintf(stderr, "%*c> _loop1_42[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
27926 arg_ty param_no_default_var;
27927 while (
27928 (param_no_default_var = param_no_default_rule(p)) // param_no_default
27929 )
27930 {
27931 _res = param_no_default_var;
27932 if (_n == _children_capacity) {
27933 _children_capacity *= 2;
27934 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
27935 if (!_new_children) {
27936 PyMem_Free(_children);
27937 p->error_indicator = 1;
27938 PyErr_NoMemory();
27939 p->level--;
27940 return NULL;
27941 }
27942 _children = _new_children;
27943 }
27944 _children[_n++] = _res;
27945 _mark = p->mark;
27946 }
27947 p->mark = _mark;
27948 D(fprintf(stderr, "%*c%s _loop1_42[%d-%d]: %s failed!\n", p->level, ' ',
27949 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
27950 }
27951 if (_n == 0 || p->error_indicator) {
27952 PyMem_Free(_children);
27953 p->level--;
27954 return NULL;
27955 }
27956 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
27957 if (!_seq) {
27958 PyMem_Free(_children);
27959 p->error_indicator = 1;
27960 PyErr_NoMemory();
27961 p->level--;
27962 return NULL;
27963 }
27964 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
27965 PyMem_Free(_children);
27966 p->level--;
27967 return _seq;
27968 }
27969
27970 // _loop1_43: param_no_default
27971 static asdl_seq *
27972 _loop1_43_rule(Parser *p)
27973 {
27974 if (p->level++ == MAXSTACK) {
27975 _Pypegen_stack_overflow(p);
27976 }
27977 if (p->error_indicator) {
27978 p->level--;
27979 return NULL;
27980 }
27981 void *_res = NULL;
27982 int _mark = p->mark;
27983 void **_children = PyMem_Malloc(sizeof(void *));
27984 if (!_children) {
27985 p->error_indicator = 1;
27986 PyErr_NoMemory();
27987 p->level--;
27988 return NULL;
27989 }
27990 Py_ssize_t _children_capacity = 1;
27991 Py_ssize_t _n = 0;
27992 { // param_no_default
27993 if (p->error_indicator) {
27994 p->level--;
27995 return NULL;
27996 }
27997 D(fprintf(stderr, "%*c> _loop1_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
27998 arg_ty param_no_default_var;
27999 while (
28000 (param_no_default_var = param_no_default_rule(p)) // param_no_default
28001 )
28002 {
28003 _res = param_no_default_var;
28004 if (_n == _children_capacity) {
28005 _children_capacity *= 2;
28006 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28007 if (!_new_children) {
28008 PyMem_Free(_children);
28009 p->error_indicator = 1;
28010 PyErr_NoMemory();
28011 p->level--;
28012 return NULL;
28013 }
28014 _children = _new_children;
28015 }
28016 _children[_n++] = _res;
28017 _mark = p->mark;
28018 }
28019 p->mark = _mark;
28020 D(fprintf(stderr, "%*c%s _loop1_43[%d-%d]: %s failed!\n", p->level, ' ',
28021 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
28022 }
28023 if (_n == 0 || p->error_indicator) {
28024 PyMem_Free(_children);
28025 p->level--;
28026 return NULL;
28027 }
28028 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28029 if (!_seq) {
28030 PyMem_Free(_children);
28031 p->error_indicator = 1;
28032 PyErr_NoMemory();
28033 p->level--;
28034 return NULL;
28035 }
28036 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28037 PyMem_Free(_children);
28038 p->level--;
28039 return _seq;
28040 }
28041
28042 // _loop0_44: param_no_default
28043 static asdl_seq *
28044 _loop0_44_rule(Parser *p)
28045 {
28046 if (p->level++ == MAXSTACK) {
28047 _Pypegen_stack_overflow(p);
28048 }
28049 if (p->error_indicator) {
28050 p->level--;
28051 return NULL;
28052 }
28053 void *_res = NULL;
28054 int _mark = p->mark;
28055 void **_children = PyMem_Malloc(sizeof(void *));
28056 if (!_children) {
28057 p->error_indicator = 1;
28058 PyErr_NoMemory();
28059 p->level--;
28060 return NULL;
28061 }
28062 Py_ssize_t _children_capacity = 1;
28063 Py_ssize_t _n = 0;
28064 { // param_no_default
28065 if (p->error_indicator) {
28066 p->level--;
28067 return NULL;
28068 }
28069 D(fprintf(stderr, "%*c> _loop0_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
28070 arg_ty param_no_default_var;
28071 while (
28072 (param_no_default_var = param_no_default_rule(p)) // param_no_default
28073 )
28074 {
28075 _res = param_no_default_var;
28076 if (_n == _children_capacity) {
28077 _children_capacity *= 2;
28078 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28079 if (!_new_children) {
28080 PyMem_Free(_children);
28081 p->error_indicator = 1;
28082 PyErr_NoMemory();
28083 p->level--;
28084 return NULL;
28085 }
28086 _children = _new_children;
28087 }
28088 _children[_n++] = _res;
28089 _mark = p->mark;
28090 }
28091 p->mark = _mark;
28092 D(fprintf(stderr, "%*c%s _loop0_44[%d-%d]: %s failed!\n", p->level, ' ',
28093 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
28094 }
28095 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28096 if (!_seq) {
28097 PyMem_Free(_children);
28098 p->error_indicator = 1;
28099 PyErr_NoMemory();
28100 p->level--;
28101 return NULL;
28102 }
28103 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28104 PyMem_Free(_children);
28105 p->level--;
28106 return _seq;
28107 }
28108
28109 // _loop1_45: param_with_default
28110 static asdl_seq *
28111 _loop1_45_rule(Parser *p)
28112 {
28113 if (p->level++ == MAXSTACK) {
28114 _Pypegen_stack_overflow(p);
28115 }
28116 if (p->error_indicator) {
28117 p->level--;
28118 return NULL;
28119 }
28120 void *_res = NULL;
28121 int _mark = p->mark;
28122 void **_children = PyMem_Malloc(sizeof(void *));
28123 if (!_children) {
28124 p->error_indicator = 1;
28125 PyErr_NoMemory();
28126 p->level--;
28127 return NULL;
28128 }
28129 Py_ssize_t _children_capacity = 1;
28130 Py_ssize_t _n = 0;
28131 { // param_with_default
28132 if (p->error_indicator) {
28133 p->level--;
28134 return NULL;
28135 }
28136 D(fprintf(stderr, "%*c> _loop1_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
28137 NameDefaultPair* param_with_default_var;
28138 while (
28139 (param_with_default_var = param_with_default_rule(p)) // param_with_default
28140 )
28141 {
28142 _res = param_with_default_var;
28143 if (_n == _children_capacity) {
28144 _children_capacity *= 2;
28145 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28146 if (!_new_children) {
28147 PyMem_Free(_children);
28148 p->error_indicator = 1;
28149 PyErr_NoMemory();
28150 p->level--;
28151 return NULL;
28152 }
28153 _children = _new_children;
28154 }
28155 _children[_n++] = _res;
28156 _mark = p->mark;
28157 }
28158 p->mark = _mark;
28159 D(fprintf(stderr, "%*c%s _loop1_45[%d-%d]: %s failed!\n", p->level, ' ',
28160 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
28161 }
28162 if (_n == 0 || p->error_indicator) {
28163 PyMem_Free(_children);
28164 p->level--;
28165 return NULL;
28166 }
28167 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28168 if (!_seq) {
28169 PyMem_Free(_children);
28170 p->error_indicator = 1;
28171 PyErr_NoMemory();
28172 p->level--;
28173 return NULL;
28174 }
28175 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28176 PyMem_Free(_children);
28177 p->level--;
28178 return _seq;
28179 }
28180
28181 // _loop0_46: param_no_default
28182 static asdl_seq *
28183 _loop0_46_rule(Parser *p)
28184 {
28185 if (p->level++ == MAXSTACK) {
28186 _Pypegen_stack_overflow(p);
28187 }
28188 if (p->error_indicator) {
28189 p->level--;
28190 return NULL;
28191 }
28192 void *_res = NULL;
28193 int _mark = p->mark;
28194 void **_children = PyMem_Malloc(sizeof(void *));
28195 if (!_children) {
28196 p->error_indicator = 1;
28197 PyErr_NoMemory();
28198 p->level--;
28199 return NULL;
28200 }
28201 Py_ssize_t _children_capacity = 1;
28202 Py_ssize_t _n = 0;
28203 { // param_no_default
28204 if (p->error_indicator) {
28205 p->level--;
28206 return NULL;
28207 }
28208 D(fprintf(stderr, "%*c> _loop0_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
28209 arg_ty param_no_default_var;
28210 while (
28211 (param_no_default_var = param_no_default_rule(p)) // param_no_default
28212 )
28213 {
28214 _res = param_no_default_var;
28215 if (_n == _children_capacity) {
28216 _children_capacity *= 2;
28217 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28218 if (!_new_children) {
28219 PyMem_Free(_children);
28220 p->error_indicator = 1;
28221 PyErr_NoMemory();
28222 p->level--;
28223 return NULL;
28224 }
28225 _children = _new_children;
28226 }
28227 _children[_n++] = _res;
28228 _mark = p->mark;
28229 }
28230 p->mark = _mark;
28231 D(fprintf(stderr, "%*c%s _loop0_46[%d-%d]: %s failed!\n", p->level, ' ',
28232 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
28233 }
28234 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28235 if (!_seq) {
28236 PyMem_Free(_children);
28237 p->error_indicator = 1;
28238 PyErr_NoMemory();
28239 p->level--;
28240 return NULL;
28241 }
28242 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28243 PyMem_Free(_children);
28244 p->level--;
28245 return _seq;
28246 }
28247
28248 // _loop1_47: param_with_default
28249 static asdl_seq *
28250 _loop1_47_rule(Parser *p)
28251 {
28252 if (p->level++ == MAXSTACK) {
28253 _Pypegen_stack_overflow(p);
28254 }
28255 if (p->error_indicator) {
28256 p->level--;
28257 return NULL;
28258 }
28259 void *_res = NULL;
28260 int _mark = p->mark;
28261 void **_children = PyMem_Malloc(sizeof(void *));
28262 if (!_children) {
28263 p->error_indicator = 1;
28264 PyErr_NoMemory();
28265 p->level--;
28266 return NULL;
28267 }
28268 Py_ssize_t _children_capacity = 1;
28269 Py_ssize_t _n = 0;
28270 { // param_with_default
28271 if (p->error_indicator) {
28272 p->level--;
28273 return NULL;
28274 }
28275 D(fprintf(stderr, "%*c> _loop1_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
28276 NameDefaultPair* param_with_default_var;
28277 while (
28278 (param_with_default_var = param_with_default_rule(p)) // param_with_default
28279 )
28280 {
28281 _res = param_with_default_var;
28282 if (_n == _children_capacity) {
28283 _children_capacity *= 2;
28284 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28285 if (!_new_children) {
28286 PyMem_Free(_children);
28287 p->error_indicator = 1;
28288 PyErr_NoMemory();
28289 p->level--;
28290 return NULL;
28291 }
28292 _children = _new_children;
28293 }
28294 _children[_n++] = _res;
28295 _mark = p->mark;
28296 }
28297 p->mark = _mark;
28298 D(fprintf(stderr, "%*c%s _loop1_47[%d-%d]: %s failed!\n", p->level, ' ',
28299 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
28300 }
28301 if (_n == 0 || p->error_indicator) {
28302 PyMem_Free(_children);
28303 p->level--;
28304 return NULL;
28305 }
28306 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28307 if (!_seq) {
28308 PyMem_Free(_children);
28309 p->error_indicator = 1;
28310 PyErr_NoMemory();
28311 p->level--;
28312 return NULL;
28313 }
28314 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28315 PyMem_Free(_children);
28316 p->level--;
28317 return _seq;
28318 }
28319
28320 // _loop0_48: param_maybe_default
28321 static asdl_seq *
28322 _loop0_48_rule(Parser *p)
28323 {
28324 if (p->level++ == MAXSTACK) {
28325 _Pypegen_stack_overflow(p);
28326 }
28327 if (p->error_indicator) {
28328 p->level--;
28329 return NULL;
28330 }
28331 void *_res = NULL;
28332 int _mark = p->mark;
28333 void **_children = PyMem_Malloc(sizeof(void *));
28334 if (!_children) {
28335 p->error_indicator = 1;
28336 PyErr_NoMemory();
28337 p->level--;
28338 return NULL;
28339 }
28340 Py_ssize_t _children_capacity = 1;
28341 Py_ssize_t _n = 0;
28342 { // param_maybe_default
28343 if (p->error_indicator) {
28344 p->level--;
28345 return NULL;
28346 }
28347 D(fprintf(stderr, "%*c> _loop0_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
28348 NameDefaultPair* param_maybe_default_var;
28349 while (
28350 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
28351 )
28352 {
28353 _res = param_maybe_default_var;
28354 if (_n == _children_capacity) {
28355 _children_capacity *= 2;
28356 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28357 if (!_new_children) {
28358 PyMem_Free(_children);
28359 p->error_indicator = 1;
28360 PyErr_NoMemory();
28361 p->level--;
28362 return NULL;
28363 }
28364 _children = _new_children;
28365 }
28366 _children[_n++] = _res;
28367 _mark = p->mark;
28368 }
28369 p->mark = _mark;
28370 D(fprintf(stderr, "%*c%s _loop0_48[%d-%d]: %s failed!\n", p->level, ' ',
28371 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
28372 }
28373 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28374 if (!_seq) {
28375 PyMem_Free(_children);
28376 p->error_indicator = 1;
28377 PyErr_NoMemory();
28378 p->level--;
28379 return NULL;
28380 }
28381 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28382 PyMem_Free(_children);
28383 p->level--;
28384 return _seq;
28385 }
28386
28387 // _loop0_49: param_maybe_default
28388 static asdl_seq *
28389 _loop0_49_rule(Parser *p)
28390 {
28391 if (p->level++ == MAXSTACK) {
28392 _Pypegen_stack_overflow(p);
28393 }
28394 if (p->error_indicator) {
28395 p->level--;
28396 return NULL;
28397 }
28398 void *_res = NULL;
28399 int _mark = p->mark;
28400 void **_children = PyMem_Malloc(sizeof(void *));
28401 if (!_children) {
28402 p->error_indicator = 1;
28403 PyErr_NoMemory();
28404 p->level--;
28405 return NULL;
28406 }
28407 Py_ssize_t _children_capacity = 1;
28408 Py_ssize_t _n = 0;
28409 { // param_maybe_default
28410 if (p->error_indicator) {
28411 p->level--;
28412 return NULL;
28413 }
28414 D(fprintf(stderr, "%*c> _loop0_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
28415 NameDefaultPair* param_maybe_default_var;
28416 while (
28417 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
28418 )
28419 {
28420 _res = param_maybe_default_var;
28421 if (_n == _children_capacity) {
28422 _children_capacity *= 2;
28423 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28424 if (!_new_children) {
28425 PyMem_Free(_children);
28426 p->error_indicator = 1;
28427 PyErr_NoMemory();
28428 p->level--;
28429 return NULL;
28430 }
28431 _children = _new_children;
28432 }
28433 _children[_n++] = _res;
28434 _mark = p->mark;
28435 }
28436 p->mark = _mark;
28437 D(fprintf(stderr, "%*c%s _loop0_49[%d-%d]: %s failed!\n", p->level, ' ',
28438 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
28439 }
28440 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28441 if (!_seq) {
28442 PyMem_Free(_children);
28443 p->error_indicator = 1;
28444 PyErr_NoMemory();
28445 p->level--;
28446 return NULL;
28447 }
28448 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28449 PyMem_Free(_children);
28450 p->level--;
28451 return _seq;
28452 }
28453
28454 // _loop1_50: param_maybe_default
28455 static asdl_seq *
28456 _loop1_50_rule(Parser *p)
28457 {
28458 if (p->level++ == MAXSTACK) {
28459 _Pypegen_stack_overflow(p);
28460 }
28461 if (p->error_indicator) {
28462 p->level--;
28463 return NULL;
28464 }
28465 void *_res = NULL;
28466 int _mark = p->mark;
28467 void **_children = PyMem_Malloc(sizeof(void *));
28468 if (!_children) {
28469 p->error_indicator = 1;
28470 PyErr_NoMemory();
28471 p->level--;
28472 return NULL;
28473 }
28474 Py_ssize_t _children_capacity = 1;
28475 Py_ssize_t _n = 0;
28476 { // param_maybe_default
28477 if (p->error_indicator) {
28478 p->level--;
28479 return NULL;
28480 }
28481 D(fprintf(stderr, "%*c> _loop1_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
28482 NameDefaultPair* param_maybe_default_var;
28483 while (
28484 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
28485 )
28486 {
28487 _res = param_maybe_default_var;
28488 if (_n == _children_capacity) {
28489 _children_capacity *= 2;
28490 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28491 if (!_new_children) {
28492 PyMem_Free(_children);
28493 p->error_indicator = 1;
28494 PyErr_NoMemory();
28495 p->level--;
28496 return NULL;
28497 }
28498 _children = _new_children;
28499 }
28500 _children[_n++] = _res;
28501 _mark = p->mark;
28502 }
28503 p->mark = _mark;
28504 D(fprintf(stderr, "%*c%s _loop1_50[%d-%d]: %s failed!\n", p->level, ' ',
28505 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
28506 }
28507 if (_n == 0 || p->error_indicator) {
28508 PyMem_Free(_children);
28509 p->level--;
28510 return NULL;
28511 }
28512 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28513 if (!_seq) {
28514 PyMem_Free(_children);
28515 p->error_indicator = 1;
28516 PyErr_NoMemory();
28517 p->level--;
28518 return NULL;
28519 }
28520 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28521 PyMem_Free(_children);
28522 p->level--;
28523 return _seq;
28524 }
28525
28526 // _loop0_52: ',' with_item
28527 static asdl_seq *
28528 _loop0_52_rule(Parser *p)
28529 {
28530 if (p->level++ == MAXSTACK) {
28531 _Pypegen_stack_overflow(p);
28532 }
28533 if (p->error_indicator) {
28534 p->level--;
28535 return NULL;
28536 }
28537 void *_res = NULL;
28538 int _mark = p->mark;
28539 void **_children = PyMem_Malloc(sizeof(void *));
28540 if (!_children) {
28541 p->error_indicator = 1;
28542 PyErr_NoMemory();
28543 p->level--;
28544 return NULL;
28545 }
28546 Py_ssize_t _children_capacity = 1;
28547 Py_ssize_t _n = 0;
28548 { // ',' with_item
28549 if (p->error_indicator) {
28550 p->level--;
28551 return NULL;
28552 }
28553 D(fprintf(stderr, "%*c> _loop0_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
28554 Token * _literal;
28555 withitem_ty elem;
28556 while (
28557 (_literal = _PyPegen_expect_token(p, 12)) // token=','
28558 &&
28559 (elem = with_item_rule(p)) // with_item
28560 )
28561 {
28562 _res = elem;
28563 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
28564 p->error_indicator = 1;
28565 PyMem_Free(_children);
28566 p->level--;
28567 return NULL;
28568 }
28569 if (_n == _children_capacity) {
28570 _children_capacity *= 2;
28571 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28572 if (!_new_children) {
28573 PyMem_Free(_children);
28574 p->error_indicator = 1;
28575 PyErr_NoMemory();
28576 p->level--;
28577 return NULL;
28578 }
28579 _children = _new_children;
28580 }
28581 _children[_n++] = _res;
28582 _mark = p->mark;
28583 }
28584 p->mark = _mark;
28585 D(fprintf(stderr, "%*c%s _loop0_52[%d-%d]: %s failed!\n", p->level, ' ',
28586 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));
28587 }
28588 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28589 if (!_seq) {
28590 PyMem_Free(_children);
28591 p->error_indicator = 1;
28592 PyErr_NoMemory();
28593 p->level--;
28594 return NULL;
28595 }
28596 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28597 PyMem_Free(_children);
28598 p->level--;
28599 return _seq;
28600 }
28601
28602 // _gather_51: with_item _loop0_52
28603 static asdl_seq *
28604 _gather_51_rule(Parser *p)
28605 {
28606 if (p->level++ == MAXSTACK) {
28607 _Pypegen_stack_overflow(p);
28608 }
28609 if (p->error_indicator) {
28610 p->level--;
28611 return NULL;
28612 }
28613 asdl_seq * _res = NULL;
28614 int _mark = p->mark;
28615 { // with_item _loop0_52
28616 if (p->error_indicator) {
28617 p->level--;
28618 return NULL;
28619 }
28620 D(fprintf(stderr, "%*c> _gather_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_52"));
28621 withitem_ty elem;
28622 asdl_seq * seq;
28623 if (
28624 (elem = with_item_rule(p)) // with_item
28625 &&
28626 (seq = _loop0_52_rule(p)) // _loop0_52
28627 )
28628 {
28629 D(fprintf(stderr, "%*c+ _gather_51[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_52"));
28630 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28631 goto done;
28632 }
28633 p->mark = _mark;
28634 D(fprintf(stderr, "%*c%s _gather_51[%d-%d]: %s failed!\n", p->level, ' ',
28635 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_52"));
28636 }
28637 _res = NULL;
28638 done:
28639 p->level--;
28640 return _res;
28641 }
28642
28643 // _loop0_54: ',' with_item
28644 static asdl_seq *
28645 _loop0_54_rule(Parser *p)
28646 {
28647 if (p->level++ == MAXSTACK) {
28648 _Pypegen_stack_overflow(p);
28649 }
28650 if (p->error_indicator) {
28651 p->level--;
28652 return NULL;
28653 }
28654 void *_res = NULL;
28655 int _mark = p->mark;
28656 void **_children = PyMem_Malloc(sizeof(void *));
28657 if (!_children) {
28658 p->error_indicator = 1;
28659 PyErr_NoMemory();
28660 p->level--;
28661 return NULL;
28662 }
28663 Py_ssize_t _children_capacity = 1;
28664 Py_ssize_t _n = 0;
28665 { // ',' with_item
28666 if (p->error_indicator) {
28667 p->level--;
28668 return NULL;
28669 }
28670 D(fprintf(stderr, "%*c> _loop0_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
28671 Token * _literal;
28672 withitem_ty elem;
28673 while (
28674 (_literal = _PyPegen_expect_token(p, 12)) // token=','
28675 &&
28676 (elem = with_item_rule(p)) // with_item
28677 )
28678 {
28679 _res = elem;
28680 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
28681 p->error_indicator = 1;
28682 PyMem_Free(_children);
28683 p->level--;
28684 return NULL;
28685 }
28686 if (_n == _children_capacity) {
28687 _children_capacity *= 2;
28688 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28689 if (!_new_children) {
28690 PyMem_Free(_children);
28691 p->error_indicator = 1;
28692 PyErr_NoMemory();
28693 p->level--;
28694 return NULL;
28695 }
28696 _children = _new_children;
28697 }
28698 _children[_n++] = _res;
28699 _mark = p->mark;
28700 }
28701 p->mark = _mark;
28702 D(fprintf(stderr, "%*c%s _loop0_54[%d-%d]: %s failed!\n", p->level, ' ',
28703 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));
28704 }
28705 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28706 if (!_seq) {
28707 PyMem_Free(_children);
28708 p->error_indicator = 1;
28709 PyErr_NoMemory();
28710 p->level--;
28711 return NULL;
28712 }
28713 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28714 PyMem_Free(_children);
28715 p->level--;
28716 return _seq;
28717 }
28718
28719 // _gather_53: with_item _loop0_54
28720 static asdl_seq *
28721 _gather_53_rule(Parser *p)
28722 {
28723 if (p->level++ == MAXSTACK) {
28724 _Pypegen_stack_overflow(p);
28725 }
28726 if (p->error_indicator) {
28727 p->level--;
28728 return NULL;
28729 }
28730 asdl_seq * _res = NULL;
28731 int _mark = p->mark;
28732 { // with_item _loop0_54
28733 if (p->error_indicator) {
28734 p->level--;
28735 return NULL;
28736 }
28737 D(fprintf(stderr, "%*c> _gather_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_54"));
28738 withitem_ty elem;
28739 asdl_seq * seq;
28740 if (
28741 (elem = with_item_rule(p)) // with_item
28742 &&
28743 (seq = _loop0_54_rule(p)) // _loop0_54
28744 )
28745 {
28746 D(fprintf(stderr, "%*c+ _gather_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_54"));
28747 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28748 goto done;
28749 }
28750 p->mark = _mark;
28751 D(fprintf(stderr, "%*c%s _gather_53[%d-%d]: %s failed!\n", p->level, ' ',
28752 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_54"));
28753 }
28754 _res = NULL;
28755 done:
28756 p->level--;
28757 return _res;
28758 }
28759
28760 // _loop0_56: ',' with_item
28761 static asdl_seq *
28762 _loop0_56_rule(Parser *p)
28763 {
28764 if (p->level++ == MAXSTACK) {
28765 _Pypegen_stack_overflow(p);
28766 }
28767 if (p->error_indicator) {
28768 p->level--;
28769 return NULL;
28770 }
28771 void *_res = NULL;
28772 int _mark = p->mark;
28773 void **_children = PyMem_Malloc(sizeof(void *));
28774 if (!_children) {
28775 p->error_indicator = 1;
28776 PyErr_NoMemory();
28777 p->level--;
28778 return NULL;
28779 }
28780 Py_ssize_t _children_capacity = 1;
28781 Py_ssize_t _n = 0;
28782 { // ',' with_item
28783 if (p->error_indicator) {
28784 p->level--;
28785 return NULL;
28786 }
28787 D(fprintf(stderr, "%*c> _loop0_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
28788 Token * _literal;
28789 withitem_ty elem;
28790 while (
28791 (_literal = _PyPegen_expect_token(p, 12)) // token=','
28792 &&
28793 (elem = with_item_rule(p)) // with_item
28794 )
28795 {
28796 _res = elem;
28797 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
28798 p->error_indicator = 1;
28799 PyMem_Free(_children);
28800 p->level--;
28801 return NULL;
28802 }
28803 if (_n == _children_capacity) {
28804 _children_capacity *= 2;
28805 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28806 if (!_new_children) {
28807 PyMem_Free(_children);
28808 p->error_indicator = 1;
28809 PyErr_NoMemory();
28810 p->level--;
28811 return NULL;
28812 }
28813 _children = _new_children;
28814 }
28815 _children[_n++] = _res;
28816 _mark = p->mark;
28817 }
28818 p->mark = _mark;
28819 D(fprintf(stderr, "%*c%s _loop0_56[%d-%d]: %s failed!\n", p->level, ' ',
28820 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));
28821 }
28822 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28823 if (!_seq) {
28824 PyMem_Free(_children);
28825 p->error_indicator = 1;
28826 PyErr_NoMemory();
28827 p->level--;
28828 return NULL;
28829 }
28830 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28831 PyMem_Free(_children);
28832 p->level--;
28833 return _seq;
28834 }
28835
28836 // _gather_55: with_item _loop0_56
28837 static asdl_seq *
28838 _gather_55_rule(Parser *p)
28839 {
28840 if (p->level++ == MAXSTACK) {
28841 _Pypegen_stack_overflow(p);
28842 }
28843 if (p->error_indicator) {
28844 p->level--;
28845 return NULL;
28846 }
28847 asdl_seq * _res = NULL;
28848 int _mark = p->mark;
28849 { // with_item _loop0_56
28850 if (p->error_indicator) {
28851 p->level--;
28852 return NULL;
28853 }
28854 D(fprintf(stderr, "%*c> _gather_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_56"));
28855 withitem_ty elem;
28856 asdl_seq * seq;
28857 if (
28858 (elem = with_item_rule(p)) // with_item
28859 &&
28860 (seq = _loop0_56_rule(p)) // _loop0_56
28861 )
28862 {
28863 D(fprintf(stderr, "%*c+ _gather_55[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_56"));
28864 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28865 goto done;
28866 }
28867 p->mark = _mark;
28868 D(fprintf(stderr, "%*c%s _gather_55[%d-%d]: %s failed!\n", p->level, ' ',
28869 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_56"));
28870 }
28871 _res = NULL;
28872 done:
28873 p->level--;
28874 return _res;
28875 }
28876
28877 // _loop0_58: ',' with_item
28878 static asdl_seq *
28879 _loop0_58_rule(Parser *p)
28880 {
28881 if (p->level++ == MAXSTACK) {
28882 _Pypegen_stack_overflow(p);
28883 }
28884 if (p->error_indicator) {
28885 p->level--;
28886 return NULL;
28887 }
28888 void *_res = NULL;
28889 int _mark = p->mark;
28890 void **_children = PyMem_Malloc(sizeof(void *));
28891 if (!_children) {
28892 p->error_indicator = 1;
28893 PyErr_NoMemory();
28894 p->level--;
28895 return NULL;
28896 }
28897 Py_ssize_t _children_capacity = 1;
28898 Py_ssize_t _n = 0;
28899 { // ',' with_item
28900 if (p->error_indicator) {
28901 p->level--;
28902 return NULL;
28903 }
28904 D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
28905 Token * _literal;
28906 withitem_ty elem;
28907 while (
28908 (_literal = _PyPegen_expect_token(p, 12)) // token=','
28909 &&
28910 (elem = with_item_rule(p)) // with_item
28911 )
28912 {
28913 _res = elem;
28914 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
28915 p->error_indicator = 1;
28916 PyMem_Free(_children);
28917 p->level--;
28918 return NULL;
28919 }
28920 if (_n == _children_capacity) {
28921 _children_capacity *= 2;
28922 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
28923 if (!_new_children) {
28924 PyMem_Free(_children);
28925 p->error_indicator = 1;
28926 PyErr_NoMemory();
28927 p->level--;
28928 return NULL;
28929 }
28930 _children = _new_children;
28931 }
28932 _children[_n++] = _res;
28933 _mark = p->mark;
28934 }
28935 p->mark = _mark;
28936 D(fprintf(stderr, "%*c%s _loop0_58[%d-%d]: %s failed!\n", p->level, ' ',
28937 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));
28938 }
28939 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
28940 if (!_seq) {
28941 PyMem_Free(_children);
28942 p->error_indicator = 1;
28943 PyErr_NoMemory();
28944 p->level--;
28945 return NULL;
28946 }
28947 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
28948 PyMem_Free(_children);
28949 p->level--;
28950 return _seq;
28951 }
28952
28953 // _gather_57: with_item _loop0_58
28954 static asdl_seq *
28955 _gather_57_rule(Parser *p)
28956 {
28957 if (p->level++ == MAXSTACK) {
28958 _Pypegen_stack_overflow(p);
28959 }
28960 if (p->error_indicator) {
28961 p->level--;
28962 return NULL;
28963 }
28964 asdl_seq * _res = NULL;
28965 int _mark = p->mark;
28966 { // with_item _loop0_58
28967 if (p->error_indicator) {
28968 p->level--;
28969 return NULL;
28970 }
28971 D(fprintf(stderr, "%*c> _gather_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_58"));
28972 withitem_ty elem;
28973 asdl_seq * seq;
28974 if (
28975 (elem = with_item_rule(p)) // with_item
28976 &&
28977 (seq = _loop0_58_rule(p)) // _loop0_58
28978 )
28979 {
28980 D(fprintf(stderr, "%*c+ _gather_57[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_58"));
28981 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
28982 goto done;
28983 }
28984 p->mark = _mark;
28985 D(fprintf(stderr, "%*c%s _gather_57[%d-%d]: %s failed!\n", p->level, ' ',
28986 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_58"));
28987 }
28988 _res = NULL;
28989 done:
28990 p->level--;
28991 return _res;
28992 }
28993
28994 // _tmp_59: ',' | ')' | ':'
28995 static void *
28996 _tmp_59_rule(Parser *p)
28997 {
28998 if (p->level++ == MAXSTACK) {
28999 _Pypegen_stack_overflow(p);
29000 }
29001 if (p->error_indicator) {
29002 p->level--;
29003 return NULL;
29004 }
29005 void * _res = NULL;
29006 int _mark = p->mark;
29007 { // ','
29008 if (p->error_indicator) {
29009 p->level--;
29010 return NULL;
29011 }
29012 D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
29013 Token * _literal;
29014 if (
29015 (_literal = _PyPegen_expect_token(p, 12)) // token=','
29016 )
29017 {
29018 D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
29019 _res = _literal;
29020 goto done;
29021 }
29022 p->mark = _mark;
29023 D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ',
29024 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
29025 }
29026 { // ')'
29027 if (p->error_indicator) {
29028 p->level--;
29029 return NULL;
29030 }
29031 D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
29032 Token * _literal;
29033 if (
29034 (_literal = _PyPegen_expect_token(p, 8)) // token=')'
29035 )
29036 {
29037 D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
29038 _res = _literal;
29039 goto done;
29040 }
29041 p->mark = _mark;
29042 D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ',
29043 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
29044 }
29045 { // ':'
29046 if (p->error_indicator) {
29047 p->level--;
29048 return NULL;
29049 }
29050 D(fprintf(stderr, "%*c> _tmp_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
29051 Token * _literal;
29052 if (
29053 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
29054 )
29055 {
29056 D(fprintf(stderr, "%*c+ _tmp_59[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
29057 _res = _literal;
29058 goto done;
29059 }
29060 p->mark = _mark;
29061 D(fprintf(stderr, "%*c%s _tmp_59[%d-%d]: %s failed!\n", p->level, ' ',
29062 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
29063 }
29064 _res = NULL;
29065 done:
29066 p->level--;
29067 return _res;
29068 }
29069
29070 // _loop1_60: except_block
29071 static asdl_seq *
29072 _loop1_60_rule(Parser *p)
29073 {
29074 if (p->level++ == MAXSTACK) {
29075 _Pypegen_stack_overflow(p);
29076 }
29077 if (p->error_indicator) {
29078 p->level--;
29079 return NULL;
29080 }
29081 void *_res = NULL;
29082 int _mark = p->mark;
29083 void **_children = PyMem_Malloc(sizeof(void *));
29084 if (!_children) {
29085 p->error_indicator = 1;
29086 PyErr_NoMemory();
29087 p->level--;
29088 return NULL;
29089 }
29090 Py_ssize_t _children_capacity = 1;
29091 Py_ssize_t _n = 0;
29092 { // except_block
29093 if (p->error_indicator) {
29094 p->level--;
29095 return NULL;
29096 }
29097 D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));
29098 excepthandler_ty except_block_var;
29099 while (
29100 (except_block_var = except_block_rule(p)) // except_block
29101 )
29102 {
29103 _res = except_block_var;
29104 if (_n == _children_capacity) {
29105 _children_capacity *= 2;
29106 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29107 if (!_new_children) {
29108 PyMem_Free(_children);
29109 p->error_indicator = 1;
29110 PyErr_NoMemory();
29111 p->level--;
29112 return NULL;
29113 }
29114 _children = _new_children;
29115 }
29116 _children[_n++] = _res;
29117 _mark = p->mark;
29118 }
29119 p->mark = _mark;
29120 D(fprintf(stderr, "%*c%s _loop1_60[%d-%d]: %s failed!\n", p->level, ' ',
29121 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block"));
29122 }
29123 if (_n == 0 || p->error_indicator) {
29124 PyMem_Free(_children);
29125 p->level--;
29126 return NULL;
29127 }
29128 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29129 if (!_seq) {
29130 PyMem_Free(_children);
29131 p->error_indicator = 1;
29132 PyErr_NoMemory();
29133 p->level--;
29134 return NULL;
29135 }
29136 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29137 PyMem_Free(_children);
29138 p->level--;
29139 return _seq;
29140 }
29141
29142 // _loop1_61: except_star_block
29143 static asdl_seq *
29144 _loop1_61_rule(Parser *p)
29145 {
29146 if (p->level++ == MAXSTACK) {
29147 _Pypegen_stack_overflow(p);
29148 }
29149 if (p->error_indicator) {
29150 p->level--;
29151 return NULL;
29152 }
29153 void *_res = NULL;
29154 int _mark = p->mark;
29155 void **_children = PyMem_Malloc(sizeof(void *));
29156 if (!_children) {
29157 p->error_indicator = 1;
29158 PyErr_NoMemory();
29159 p->level--;
29160 return NULL;
29161 }
29162 Py_ssize_t _children_capacity = 1;
29163 Py_ssize_t _n = 0;
29164 { // except_star_block
29165 if (p->error_indicator) {
29166 p->level--;
29167 return NULL;
29168 }
29169 D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block"));
29170 excepthandler_ty except_star_block_var;
29171 while (
29172 (except_star_block_var = except_star_block_rule(p)) // except_star_block
29173 )
29174 {
29175 _res = except_star_block_var;
29176 if (_n == _children_capacity) {
29177 _children_capacity *= 2;
29178 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29179 if (!_new_children) {
29180 PyMem_Free(_children);
29181 p->error_indicator = 1;
29182 PyErr_NoMemory();
29183 p->level--;
29184 return NULL;
29185 }
29186 _children = _new_children;
29187 }
29188 _children[_n++] = _res;
29189 _mark = p->mark;
29190 }
29191 p->mark = _mark;
29192 D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ',
29193 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_star_block"));
29194 }
29195 if (_n == 0 || p->error_indicator) {
29196 PyMem_Free(_children);
29197 p->level--;
29198 return NULL;
29199 }
29200 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29201 if (!_seq) {
29202 PyMem_Free(_children);
29203 p->error_indicator = 1;
29204 PyErr_NoMemory();
29205 p->level--;
29206 return NULL;
29207 }
29208 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29209 PyMem_Free(_children);
29210 p->level--;
29211 return _seq;
29212 }
29213
29214 // _tmp_62: 'as' NAME
29215 static void *
29216 _tmp_62_rule(Parser *p)
29217 {
29218 if (p->level++ == MAXSTACK) {
29219 _Pypegen_stack_overflow(p);
29220 }
29221 if (p->error_indicator) {
29222 p->level--;
29223 return NULL;
29224 }
29225 void * _res = NULL;
29226 int _mark = p->mark;
29227 { // 'as' NAME
29228 if (p->error_indicator) {
29229 p->level--;
29230 return NULL;
29231 }
29232 D(fprintf(stderr, "%*c> _tmp_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
29233 Token * _keyword;
29234 expr_ty z;
29235 if (
29236 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
29237 &&
29238 (z = _PyPegen_name_token(p)) // NAME
29239 )
29240 {
29241 D(fprintf(stderr, "%*c+ _tmp_62[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
29242 _res = z;
29243 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
29244 p->error_indicator = 1;
29245 p->level--;
29246 return NULL;
29247 }
29248 goto done;
29249 }
29250 p->mark = _mark;
29251 D(fprintf(stderr, "%*c%s _tmp_62[%d-%d]: %s failed!\n", p->level, ' ',
29252 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
29253 }
29254 _res = NULL;
29255 done:
29256 p->level--;
29257 return _res;
29258 }
29259
29260 // _tmp_63: 'as' NAME
29261 static void *
29262 _tmp_63_rule(Parser *p)
29263 {
29264 if (p->level++ == MAXSTACK) {
29265 _Pypegen_stack_overflow(p);
29266 }
29267 if (p->error_indicator) {
29268 p->level--;
29269 return NULL;
29270 }
29271 void * _res = NULL;
29272 int _mark = p->mark;
29273 { // 'as' NAME
29274 if (p->error_indicator) {
29275 p->level--;
29276 return NULL;
29277 }
29278 D(fprintf(stderr, "%*c> _tmp_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
29279 Token * _keyword;
29280 expr_ty z;
29281 if (
29282 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
29283 &&
29284 (z = _PyPegen_name_token(p)) // NAME
29285 )
29286 {
29287 D(fprintf(stderr, "%*c+ _tmp_63[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
29288 _res = z;
29289 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
29290 p->error_indicator = 1;
29291 p->level--;
29292 return NULL;
29293 }
29294 goto done;
29295 }
29296 p->mark = _mark;
29297 D(fprintf(stderr, "%*c%s _tmp_63[%d-%d]: %s failed!\n", p->level, ' ',
29298 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
29299 }
29300 _res = NULL;
29301 done:
29302 p->level--;
29303 return _res;
29304 }
29305
29306 // _loop1_64: case_block
29307 static asdl_seq *
29308 _loop1_64_rule(Parser *p)
29309 {
29310 if (p->level++ == MAXSTACK) {
29311 _Pypegen_stack_overflow(p);
29312 }
29313 if (p->error_indicator) {
29314 p->level--;
29315 return NULL;
29316 }
29317 void *_res = NULL;
29318 int _mark = p->mark;
29319 void **_children = PyMem_Malloc(sizeof(void *));
29320 if (!_children) {
29321 p->error_indicator = 1;
29322 PyErr_NoMemory();
29323 p->level--;
29324 return NULL;
29325 }
29326 Py_ssize_t _children_capacity = 1;
29327 Py_ssize_t _n = 0;
29328 { // case_block
29329 if (p->error_indicator) {
29330 p->level--;
29331 return NULL;
29332 }
29333 D(fprintf(stderr, "%*c> _loop1_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "case_block"));
29334 match_case_ty case_block_var;
29335 while (
29336 (case_block_var = case_block_rule(p)) // case_block
29337 )
29338 {
29339 _res = case_block_var;
29340 if (_n == _children_capacity) {
29341 _children_capacity *= 2;
29342 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29343 if (!_new_children) {
29344 PyMem_Free(_children);
29345 p->error_indicator = 1;
29346 PyErr_NoMemory();
29347 p->level--;
29348 return NULL;
29349 }
29350 _children = _new_children;
29351 }
29352 _children[_n++] = _res;
29353 _mark = p->mark;
29354 }
29355 p->mark = _mark;
29356 D(fprintf(stderr, "%*c%s _loop1_64[%d-%d]: %s failed!\n", p->level, ' ',
29357 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "case_block"));
29358 }
29359 if (_n == 0 || p->error_indicator) {
29360 PyMem_Free(_children);
29361 p->level--;
29362 return NULL;
29363 }
29364 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29365 if (!_seq) {
29366 PyMem_Free(_children);
29367 p->error_indicator = 1;
29368 PyErr_NoMemory();
29369 p->level--;
29370 return NULL;
29371 }
29372 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29373 PyMem_Free(_children);
29374 p->level--;
29375 return _seq;
29376 }
29377
29378 // _loop0_66: '|' closed_pattern
29379 static asdl_seq *
29380 _loop0_66_rule(Parser *p)
29381 {
29382 if (p->level++ == MAXSTACK) {
29383 _Pypegen_stack_overflow(p);
29384 }
29385 if (p->error_indicator) {
29386 p->level--;
29387 return NULL;
29388 }
29389 void *_res = NULL;
29390 int _mark = p->mark;
29391 void **_children = PyMem_Malloc(sizeof(void *));
29392 if (!_children) {
29393 p->error_indicator = 1;
29394 PyErr_NoMemory();
29395 p->level--;
29396 return NULL;
29397 }
29398 Py_ssize_t _children_capacity = 1;
29399 Py_ssize_t _n = 0;
29400 { // '|' closed_pattern
29401 if (p->error_indicator) {
29402 p->level--;
29403 return NULL;
29404 }
29405 D(fprintf(stderr, "%*c> _loop0_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|' closed_pattern"));
29406 Token * _literal;
29407 pattern_ty elem;
29408 while (
29409 (_literal = _PyPegen_expect_token(p, 18)) // token='|'
29410 &&
29411 (elem = closed_pattern_rule(p)) // closed_pattern
29412 )
29413 {
29414 _res = elem;
29415 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
29416 p->error_indicator = 1;
29417 PyMem_Free(_children);
29418 p->level--;
29419 return NULL;
29420 }
29421 if (_n == _children_capacity) {
29422 _children_capacity *= 2;
29423 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29424 if (!_new_children) {
29425 PyMem_Free(_children);
29426 p->error_indicator = 1;
29427 PyErr_NoMemory();
29428 p->level--;
29429 return NULL;
29430 }
29431 _children = _new_children;
29432 }
29433 _children[_n++] = _res;
29434 _mark = p->mark;
29435 }
29436 p->mark = _mark;
29437 D(fprintf(stderr, "%*c%s _loop0_66[%d-%d]: %s failed!\n", p->level, ' ',
29438 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|' closed_pattern"));
29439 }
29440 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29441 if (!_seq) {
29442 PyMem_Free(_children);
29443 p->error_indicator = 1;
29444 PyErr_NoMemory();
29445 p->level--;
29446 return NULL;
29447 }
29448 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29449 PyMem_Free(_children);
29450 p->level--;
29451 return _seq;
29452 }
29453
29454 // _gather_65: closed_pattern _loop0_66
29455 static asdl_seq *
29456 _gather_65_rule(Parser *p)
29457 {
29458 if (p->level++ == MAXSTACK) {
29459 _Pypegen_stack_overflow(p);
29460 }
29461 if (p->error_indicator) {
29462 p->level--;
29463 return NULL;
29464 }
29465 asdl_seq * _res = NULL;
29466 int _mark = p->mark;
29467 { // closed_pattern _loop0_66
29468 if (p->error_indicator) {
29469 p->level--;
29470 return NULL;
29471 }
29472 D(fprintf(stderr, "%*c> _gather_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "closed_pattern _loop0_66"));
29473 pattern_ty elem;
29474 asdl_seq * seq;
29475 if (
29476 (elem = closed_pattern_rule(p)) // closed_pattern
29477 &&
29478 (seq = _loop0_66_rule(p)) // _loop0_66
29479 )
29480 {
29481 D(fprintf(stderr, "%*c+ _gather_65[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "closed_pattern _loop0_66"));
29482 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
29483 goto done;
29484 }
29485 p->mark = _mark;
29486 D(fprintf(stderr, "%*c%s _gather_65[%d-%d]: %s failed!\n", p->level, ' ',
29487 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "closed_pattern _loop0_66"));
29488 }
29489 _res = NULL;
29490 done:
29491 p->level--;
29492 return _res;
29493 }
29494
29495 // _tmp_67: '+' | '-'
29496 static void *
29497 _tmp_67_rule(Parser *p)
29498 {
29499 if (p->level++ == MAXSTACK) {
29500 _Pypegen_stack_overflow(p);
29501 }
29502 if (p->error_indicator) {
29503 p->level--;
29504 return NULL;
29505 }
29506 void * _res = NULL;
29507 int _mark = p->mark;
29508 { // '+'
29509 if (p->error_indicator) {
29510 p->level--;
29511 return NULL;
29512 }
29513 D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'"));
29514 Token * _literal;
29515 if (
29516 (_literal = _PyPegen_expect_token(p, 14)) // token='+'
29517 )
29518 {
29519 D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'"));
29520 _res = _literal;
29521 goto done;
29522 }
29523 p->mark = _mark;
29524 D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ',
29525 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));
29526 }
29527 { // '-'
29528 if (p->error_indicator) {
29529 p->level--;
29530 return NULL;
29531 }
29532 D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'"));
29533 Token * _literal;
29534 if (
29535 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
29536 )
29537 {
29538 D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'"));
29539 _res = _literal;
29540 goto done;
29541 }
29542 p->mark = _mark;
29543 D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ',
29544 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));
29545 }
29546 _res = NULL;
29547 done:
29548 p->level--;
29549 return _res;
29550 }
29551
29552 // _tmp_68: '+' | '-'
29553 static void *
29554 _tmp_68_rule(Parser *p)
29555 {
29556 if (p->level++ == MAXSTACK) {
29557 _Pypegen_stack_overflow(p);
29558 }
29559 if (p->error_indicator) {
29560 p->level--;
29561 return NULL;
29562 }
29563 void * _res = NULL;
29564 int _mark = p->mark;
29565 { // '+'
29566 if (p->error_indicator) {
29567 p->level--;
29568 return NULL;
29569 }
29570 D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'"));
29571 Token * _literal;
29572 if (
29573 (_literal = _PyPegen_expect_token(p, 14)) // token='+'
29574 )
29575 {
29576 D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'"));
29577 _res = _literal;
29578 goto done;
29579 }
29580 p->mark = _mark;
29581 D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ',
29582 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));
29583 }
29584 { // '-'
29585 if (p->error_indicator) {
29586 p->level--;
29587 return NULL;
29588 }
29589 D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'"));
29590 Token * _literal;
29591 if (
29592 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
29593 )
29594 {
29595 D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'"));
29596 _res = _literal;
29597 goto done;
29598 }
29599 p->mark = _mark;
29600 D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ',
29601 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));
29602 }
29603 _res = NULL;
29604 done:
29605 p->level--;
29606 return _res;
29607 }
29608
29609 // _tmp_69: '.' | '(' | '='
29610 static void *
29611 _tmp_69_rule(Parser *p)
29612 {
29613 if (p->level++ == MAXSTACK) {
29614 _Pypegen_stack_overflow(p);
29615 }
29616 if (p->error_indicator) {
29617 p->level--;
29618 return NULL;
29619 }
29620 void * _res = NULL;
29621 int _mark = p->mark;
29622 { // '.'
29623 if (p->error_indicator) {
29624 p->level--;
29625 return NULL;
29626 }
29627 D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
29628 Token * _literal;
29629 if (
29630 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
29631 )
29632 {
29633 D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
29634 _res = _literal;
29635 goto done;
29636 }
29637 p->mark = _mark;
29638 D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ',
29639 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
29640 }
29641 { // '('
29642 if (p->error_indicator) {
29643 p->level--;
29644 return NULL;
29645 }
29646 D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
29647 Token * _literal;
29648 if (
29649 (_literal = _PyPegen_expect_token(p, 7)) // token='('
29650 )
29651 {
29652 D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
29653 _res = _literal;
29654 goto done;
29655 }
29656 p->mark = _mark;
29657 D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ',
29658 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));
29659 }
29660 { // '='
29661 if (p->error_indicator) {
29662 p->level--;
29663 return NULL;
29664 }
29665 D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
29666 Token * _literal;
29667 if (
29668 (_literal = _PyPegen_expect_token(p, 22)) // token='='
29669 )
29670 {
29671 D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));
29672 _res = _literal;
29673 goto done;
29674 }
29675 p->mark = _mark;
29676 D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ',
29677 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
29678 }
29679 _res = NULL;
29680 done:
29681 p->level--;
29682 return _res;
29683 }
29684
29685 // _tmp_70: '.' | '(' | '='
29686 static void *
29687 _tmp_70_rule(Parser *p)
29688 {
29689 if (p->level++ == MAXSTACK) {
29690 _Pypegen_stack_overflow(p);
29691 }
29692 if (p->error_indicator) {
29693 p->level--;
29694 return NULL;
29695 }
29696 void * _res = NULL;
29697 int _mark = p->mark;
29698 { // '.'
29699 if (p->error_indicator) {
29700 p->level--;
29701 return NULL;
29702 }
29703 D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
29704 Token * _literal;
29705 if (
29706 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
29707 )
29708 {
29709 D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
29710 _res = _literal;
29711 goto done;
29712 }
29713 p->mark = _mark;
29714 D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ',
29715 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
29716 }
29717 { // '('
29718 if (p->error_indicator) {
29719 p->level--;
29720 return NULL;
29721 }
29722 D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
29723 Token * _literal;
29724 if (
29725 (_literal = _PyPegen_expect_token(p, 7)) // token='('
29726 )
29727 {
29728 D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
29729 _res = _literal;
29730 goto done;
29731 }
29732 p->mark = _mark;
29733 D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ',
29734 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));
29735 }
29736 { // '='
29737 if (p->error_indicator) {
29738 p->level--;
29739 return NULL;
29740 }
29741 D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
29742 Token * _literal;
29743 if (
29744 (_literal = _PyPegen_expect_token(p, 22)) // token='='
29745 )
29746 {
29747 D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));
29748 _res = _literal;
29749 goto done;
29750 }
29751 p->mark = _mark;
29752 D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ',
29753 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
29754 }
29755 _res = NULL;
29756 done:
29757 p->level--;
29758 return _res;
29759 }
29760
29761 // _loop0_72: ',' maybe_star_pattern
29762 static asdl_seq *
29763 _loop0_72_rule(Parser *p)
29764 {
29765 if (p->level++ == MAXSTACK) {
29766 _Pypegen_stack_overflow(p);
29767 }
29768 if (p->error_indicator) {
29769 p->level--;
29770 return NULL;
29771 }
29772 void *_res = NULL;
29773 int _mark = p->mark;
29774 void **_children = PyMem_Malloc(sizeof(void *));
29775 if (!_children) {
29776 p->error_indicator = 1;
29777 PyErr_NoMemory();
29778 p->level--;
29779 return NULL;
29780 }
29781 Py_ssize_t _children_capacity = 1;
29782 Py_ssize_t _n = 0;
29783 { // ',' maybe_star_pattern
29784 if (p->error_indicator) {
29785 p->level--;
29786 return NULL;
29787 }
29788 D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' maybe_star_pattern"));
29789 Token * _literal;
29790 pattern_ty elem;
29791 while (
29792 (_literal = _PyPegen_expect_token(p, 12)) // token=','
29793 &&
29794 (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern
29795 )
29796 {
29797 _res = elem;
29798 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
29799 p->error_indicator = 1;
29800 PyMem_Free(_children);
29801 p->level--;
29802 return NULL;
29803 }
29804 if (_n == _children_capacity) {
29805 _children_capacity *= 2;
29806 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29807 if (!_new_children) {
29808 PyMem_Free(_children);
29809 p->error_indicator = 1;
29810 PyErr_NoMemory();
29811 p->level--;
29812 return NULL;
29813 }
29814 _children = _new_children;
29815 }
29816 _children[_n++] = _res;
29817 _mark = p->mark;
29818 }
29819 p->mark = _mark;
29820 D(fprintf(stderr, "%*c%s _loop0_72[%d-%d]: %s failed!\n", p->level, ' ',
29821 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' maybe_star_pattern"));
29822 }
29823 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29824 if (!_seq) {
29825 PyMem_Free(_children);
29826 p->error_indicator = 1;
29827 PyErr_NoMemory();
29828 p->level--;
29829 return NULL;
29830 }
29831 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29832 PyMem_Free(_children);
29833 p->level--;
29834 return _seq;
29835 }
29836
29837 // _gather_71: maybe_star_pattern _loop0_72
29838 static asdl_seq *
29839 _gather_71_rule(Parser *p)
29840 {
29841 if (p->level++ == MAXSTACK) {
29842 _Pypegen_stack_overflow(p);
29843 }
29844 if (p->error_indicator) {
29845 p->level--;
29846 return NULL;
29847 }
29848 asdl_seq * _res = NULL;
29849 int _mark = p->mark;
29850 { // maybe_star_pattern _loop0_72
29851 if (p->error_indicator) {
29852 p->level--;
29853 return NULL;
29854 }
29855 D(fprintf(stderr, "%*c> _gather_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_72"));
29856 pattern_ty elem;
29857 asdl_seq * seq;
29858 if (
29859 (elem = maybe_star_pattern_rule(p)) // maybe_star_pattern
29860 &&
29861 (seq = _loop0_72_rule(p)) // _loop0_72
29862 )
29863 {
29864 D(fprintf(stderr, "%*c+ _gather_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "maybe_star_pattern _loop0_72"));
29865 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
29866 goto done;
29867 }
29868 p->mark = _mark;
29869 D(fprintf(stderr, "%*c%s _gather_71[%d-%d]: %s failed!\n", p->level, ' ',
29870 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "maybe_star_pattern _loop0_72"));
29871 }
29872 _res = NULL;
29873 done:
29874 p->level--;
29875 return _res;
29876 }
29877
29878 // _loop0_74: ',' key_value_pattern
29879 static asdl_seq *
29880 _loop0_74_rule(Parser *p)
29881 {
29882 if (p->level++ == MAXSTACK) {
29883 _Pypegen_stack_overflow(p);
29884 }
29885 if (p->error_indicator) {
29886 p->level--;
29887 return NULL;
29888 }
29889 void *_res = NULL;
29890 int _mark = p->mark;
29891 void **_children = PyMem_Malloc(sizeof(void *));
29892 if (!_children) {
29893 p->error_indicator = 1;
29894 PyErr_NoMemory();
29895 p->level--;
29896 return NULL;
29897 }
29898 Py_ssize_t _children_capacity = 1;
29899 Py_ssize_t _n = 0;
29900 { // ',' key_value_pattern
29901 if (p->error_indicator) {
29902 p->level--;
29903 return NULL;
29904 }
29905 D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' key_value_pattern"));
29906 Token * _literal;
29907 KeyPatternPair* elem;
29908 while (
29909 (_literal = _PyPegen_expect_token(p, 12)) // token=','
29910 &&
29911 (elem = key_value_pattern_rule(p)) // key_value_pattern
29912 )
29913 {
29914 _res = elem;
29915 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
29916 p->error_indicator = 1;
29917 PyMem_Free(_children);
29918 p->level--;
29919 return NULL;
29920 }
29921 if (_n == _children_capacity) {
29922 _children_capacity *= 2;
29923 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
29924 if (!_new_children) {
29925 PyMem_Free(_children);
29926 p->error_indicator = 1;
29927 PyErr_NoMemory();
29928 p->level--;
29929 return NULL;
29930 }
29931 _children = _new_children;
29932 }
29933 _children[_n++] = _res;
29934 _mark = p->mark;
29935 }
29936 p->mark = _mark;
29937 D(fprintf(stderr, "%*c%s _loop0_74[%d-%d]: %s failed!\n", p->level, ' ',
29938 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' key_value_pattern"));
29939 }
29940 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
29941 if (!_seq) {
29942 PyMem_Free(_children);
29943 p->error_indicator = 1;
29944 PyErr_NoMemory();
29945 p->level--;
29946 return NULL;
29947 }
29948 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
29949 PyMem_Free(_children);
29950 p->level--;
29951 return _seq;
29952 }
29953
29954 // _gather_73: key_value_pattern _loop0_74
29955 static asdl_seq *
29956 _gather_73_rule(Parser *p)
29957 {
29958 if (p->level++ == MAXSTACK) {
29959 _Pypegen_stack_overflow(p);
29960 }
29961 if (p->error_indicator) {
29962 p->level--;
29963 return NULL;
29964 }
29965 asdl_seq * _res = NULL;
29966 int _mark = p->mark;
29967 { // key_value_pattern _loop0_74
29968 if (p->error_indicator) {
29969 p->level--;
29970 return NULL;
29971 }
29972 D(fprintf(stderr, "%*c> _gather_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_74"));
29973 KeyPatternPair* elem;
29974 asdl_seq * seq;
29975 if (
29976 (elem = key_value_pattern_rule(p)) // key_value_pattern
29977 &&
29978 (seq = _loop0_74_rule(p)) // _loop0_74
29979 )
29980 {
29981 D(fprintf(stderr, "%*c+ _gather_73[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "key_value_pattern _loop0_74"));
29982 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
29983 goto done;
29984 }
29985 p->mark = _mark;
29986 D(fprintf(stderr, "%*c%s _gather_73[%d-%d]: %s failed!\n", p->level, ' ',
29987 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "key_value_pattern _loop0_74"));
29988 }
29989 _res = NULL;
29990 done:
29991 p->level--;
29992 return _res;
29993 }
29994
29995 // _tmp_75: literal_expr | attr
29996 static void *
29997 _tmp_75_rule(Parser *p)
29998 {
29999 if (p->level++ == MAXSTACK) {
30000 _Pypegen_stack_overflow(p);
30001 }
30002 if (p->error_indicator) {
30003 p->level--;
30004 return NULL;
30005 }
30006 void * _res = NULL;
30007 int _mark = p->mark;
30008 { // literal_expr
30009 if (p->error_indicator) {
30010 p->level--;
30011 return NULL;
30012 }
30013 D(fprintf(stderr, "%*c> _tmp_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "literal_expr"));
30014 expr_ty literal_expr_var;
30015 if (
30016 (literal_expr_var = literal_expr_rule(p)) // literal_expr
30017 )
30018 {
30019 D(fprintf(stderr, "%*c+ _tmp_75[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "literal_expr"));
30020 _res = literal_expr_var;
30021 goto done;
30022 }
30023 p->mark = _mark;
30024 D(fprintf(stderr, "%*c%s _tmp_75[%d-%d]: %s failed!\n", p->level, ' ',
30025 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_expr"));
30026 }
30027 { // attr
30028 if (p->error_indicator) {
30029 p->level--;
30030 return NULL;
30031 }
30032 D(fprintf(stderr, "%*c> _tmp_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "attr"));
30033 expr_ty attr_var;
30034 if (
30035 (attr_var = attr_rule(p)) // attr
30036 )
30037 {
30038 D(fprintf(stderr, "%*c+ _tmp_75[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "attr"));
30039 _res = attr_var;
30040 goto done;
30041 }
30042 p->mark = _mark;
30043 D(fprintf(stderr, "%*c%s _tmp_75[%d-%d]: %s failed!\n", p->level, ' ',
30044 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr"));
30045 }
30046 _res = NULL;
30047 done:
30048 p->level--;
30049 return _res;
30050 }
30051
30052 // _loop0_77: ',' pattern
30053 static asdl_seq *
30054 _loop0_77_rule(Parser *p)
30055 {
30056 if (p->level++ == MAXSTACK) {
30057 _Pypegen_stack_overflow(p);
30058 }
30059 if (p->error_indicator) {
30060 p->level--;
30061 return NULL;
30062 }
30063 void *_res = NULL;
30064 int _mark = p->mark;
30065 void **_children = PyMem_Malloc(sizeof(void *));
30066 if (!_children) {
30067 p->error_indicator = 1;
30068 PyErr_NoMemory();
30069 p->level--;
30070 return NULL;
30071 }
30072 Py_ssize_t _children_capacity = 1;
30073 Py_ssize_t _n = 0;
30074 { // ',' pattern
30075 if (p->error_indicator) {
30076 p->level--;
30077 return NULL;
30078 }
30079 D(fprintf(stderr, "%*c> _loop0_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' pattern"));
30080 Token * _literal;
30081 pattern_ty elem;
30082 while (
30083 (_literal = _PyPegen_expect_token(p, 12)) // token=','
30084 &&
30085 (elem = pattern_rule(p)) // pattern
30086 )
30087 {
30088 _res = elem;
30089 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
30090 p->error_indicator = 1;
30091 PyMem_Free(_children);
30092 p->level--;
30093 return NULL;
30094 }
30095 if (_n == _children_capacity) {
30096 _children_capacity *= 2;
30097 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30098 if (!_new_children) {
30099 PyMem_Free(_children);
30100 p->error_indicator = 1;
30101 PyErr_NoMemory();
30102 p->level--;
30103 return NULL;
30104 }
30105 _children = _new_children;
30106 }
30107 _children[_n++] = _res;
30108 _mark = p->mark;
30109 }
30110 p->mark = _mark;
30111 D(fprintf(stderr, "%*c%s _loop0_77[%d-%d]: %s failed!\n", p->level, ' ',
30112 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' pattern"));
30113 }
30114 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30115 if (!_seq) {
30116 PyMem_Free(_children);
30117 p->error_indicator = 1;
30118 PyErr_NoMemory();
30119 p->level--;
30120 return NULL;
30121 }
30122 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30123 PyMem_Free(_children);
30124 p->level--;
30125 return _seq;
30126 }
30127
30128 // _gather_76: pattern _loop0_77
30129 static asdl_seq *
30130 _gather_76_rule(Parser *p)
30131 {
30132 if (p->level++ == MAXSTACK) {
30133 _Pypegen_stack_overflow(p);
30134 }
30135 if (p->error_indicator) {
30136 p->level--;
30137 return NULL;
30138 }
30139 asdl_seq * _res = NULL;
30140 int _mark = p->mark;
30141 { // pattern _loop0_77
30142 if (p->error_indicator) {
30143 p->level--;
30144 return NULL;
30145 }
30146 D(fprintf(stderr, "%*c> _gather_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pattern _loop0_77"));
30147 pattern_ty elem;
30148 asdl_seq * seq;
30149 if (
30150 (elem = pattern_rule(p)) // pattern
30151 &&
30152 (seq = _loop0_77_rule(p)) // _loop0_77
30153 )
30154 {
30155 D(fprintf(stderr, "%*c+ _gather_76[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pattern _loop0_77"));
30156 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
30157 goto done;
30158 }
30159 p->mark = _mark;
30160 D(fprintf(stderr, "%*c%s _gather_76[%d-%d]: %s failed!\n", p->level, ' ',
30161 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern _loop0_77"));
30162 }
30163 _res = NULL;
30164 done:
30165 p->level--;
30166 return _res;
30167 }
30168
30169 // _loop0_79: ',' keyword_pattern
30170 static asdl_seq *
30171 _loop0_79_rule(Parser *p)
30172 {
30173 if (p->level++ == MAXSTACK) {
30174 _Pypegen_stack_overflow(p);
30175 }
30176 if (p->error_indicator) {
30177 p->level--;
30178 return NULL;
30179 }
30180 void *_res = NULL;
30181 int _mark = p->mark;
30182 void **_children = PyMem_Malloc(sizeof(void *));
30183 if (!_children) {
30184 p->error_indicator = 1;
30185 PyErr_NoMemory();
30186 p->level--;
30187 return NULL;
30188 }
30189 Py_ssize_t _children_capacity = 1;
30190 Py_ssize_t _n = 0;
30191 { // ',' keyword_pattern
30192 if (p->error_indicator) {
30193 p->level--;
30194 return NULL;
30195 }
30196 D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' keyword_pattern"));
30197 Token * _literal;
30198 KeyPatternPair* elem;
30199 while (
30200 (_literal = _PyPegen_expect_token(p, 12)) // token=','
30201 &&
30202 (elem = keyword_pattern_rule(p)) // keyword_pattern
30203 )
30204 {
30205 _res = elem;
30206 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
30207 p->error_indicator = 1;
30208 PyMem_Free(_children);
30209 p->level--;
30210 return NULL;
30211 }
30212 if (_n == _children_capacity) {
30213 _children_capacity *= 2;
30214 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30215 if (!_new_children) {
30216 PyMem_Free(_children);
30217 p->error_indicator = 1;
30218 PyErr_NoMemory();
30219 p->level--;
30220 return NULL;
30221 }
30222 _children = _new_children;
30223 }
30224 _children[_n++] = _res;
30225 _mark = p->mark;
30226 }
30227 p->mark = _mark;
30228 D(fprintf(stderr, "%*c%s _loop0_79[%d-%d]: %s failed!\n", p->level, ' ',
30229 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' keyword_pattern"));
30230 }
30231 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30232 if (!_seq) {
30233 PyMem_Free(_children);
30234 p->error_indicator = 1;
30235 PyErr_NoMemory();
30236 p->level--;
30237 return NULL;
30238 }
30239 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30240 PyMem_Free(_children);
30241 p->level--;
30242 return _seq;
30243 }
30244
30245 // _gather_78: keyword_pattern _loop0_79
30246 static asdl_seq *
30247 _gather_78_rule(Parser *p)
30248 {
30249 if (p->level++ == MAXSTACK) {
30250 _Pypegen_stack_overflow(p);
30251 }
30252 if (p->error_indicator) {
30253 p->level--;
30254 return NULL;
30255 }
30256 asdl_seq * _res = NULL;
30257 int _mark = p->mark;
30258 { // keyword_pattern _loop0_79
30259 if (p->error_indicator) {
30260 p->level--;
30261 return NULL;
30262 }
30263 D(fprintf(stderr, "%*c> _gather_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_79"));
30264 KeyPatternPair* elem;
30265 asdl_seq * seq;
30266 if (
30267 (elem = keyword_pattern_rule(p)) // keyword_pattern
30268 &&
30269 (seq = _loop0_79_rule(p)) // _loop0_79
30270 )
30271 {
30272 D(fprintf(stderr, "%*c+ _gather_78[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "keyword_pattern _loop0_79"));
30273 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
30274 goto done;
30275 }
30276 p->mark = _mark;
30277 D(fprintf(stderr, "%*c%s _gather_78[%d-%d]: %s failed!\n", p->level, ' ',
30278 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "keyword_pattern _loop0_79"));
30279 }
30280 _res = NULL;
30281 done:
30282 p->level--;
30283 return _res;
30284 }
30285
30286 // _loop0_81: ',' type_param
30287 static asdl_seq *
30288 _loop0_81_rule(Parser *p)
30289 {
30290 if (p->level++ == MAXSTACK) {
30291 _Pypegen_stack_overflow(p);
30292 }
30293 if (p->error_indicator) {
30294 p->level--;
30295 return NULL;
30296 }
30297 void *_res = NULL;
30298 int _mark = p->mark;
30299 void **_children = PyMem_Malloc(sizeof(void *));
30300 if (!_children) {
30301 p->error_indicator = 1;
30302 PyErr_NoMemory();
30303 p->level--;
30304 return NULL;
30305 }
30306 Py_ssize_t _children_capacity = 1;
30307 Py_ssize_t _n = 0;
30308 { // ',' type_param
30309 if (p->error_indicator) {
30310 p->level--;
30311 return NULL;
30312 }
30313 D(fprintf(stderr, "%*c> _loop0_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' type_param"));
30314 Token * _literal;
30315 type_param_ty elem;
30316 while (
30317 (_literal = _PyPegen_expect_token(p, 12)) // token=','
30318 &&
30319 (elem = type_param_rule(p)) // type_param
30320 )
30321 {
30322 _res = elem;
30323 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
30324 p->error_indicator = 1;
30325 PyMem_Free(_children);
30326 p->level--;
30327 return NULL;
30328 }
30329 if (_n == _children_capacity) {
30330 _children_capacity *= 2;
30331 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30332 if (!_new_children) {
30333 PyMem_Free(_children);
30334 p->error_indicator = 1;
30335 PyErr_NoMemory();
30336 p->level--;
30337 return NULL;
30338 }
30339 _children = _new_children;
30340 }
30341 _children[_n++] = _res;
30342 _mark = p->mark;
30343 }
30344 p->mark = _mark;
30345 D(fprintf(stderr, "%*c%s _loop0_81[%d-%d]: %s failed!\n", p->level, ' ',
30346 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' type_param"));
30347 }
30348 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30349 if (!_seq) {
30350 PyMem_Free(_children);
30351 p->error_indicator = 1;
30352 PyErr_NoMemory();
30353 p->level--;
30354 return NULL;
30355 }
30356 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30357 PyMem_Free(_children);
30358 p->level--;
30359 return _seq;
30360 }
30361
30362 // _gather_80: type_param _loop0_81
30363 static asdl_seq *
30364 _gather_80_rule(Parser *p)
30365 {
30366 if (p->level++ == MAXSTACK) {
30367 _Pypegen_stack_overflow(p);
30368 }
30369 if (p->error_indicator) {
30370 p->level--;
30371 return NULL;
30372 }
30373 asdl_seq * _res = NULL;
30374 int _mark = p->mark;
30375 { // type_param _loop0_81
30376 if (p->error_indicator) {
30377 p->level--;
30378 return NULL;
30379 }
30380 D(fprintf(stderr, "%*c> _gather_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "type_param _loop0_81"));
30381 type_param_ty elem;
30382 asdl_seq * seq;
30383 if (
30384 (elem = type_param_rule(p)) // type_param
30385 &&
30386 (seq = _loop0_81_rule(p)) // _loop0_81
30387 )
30388 {
30389 D(fprintf(stderr, "%*c+ _gather_80[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "type_param _loop0_81"));
30390 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
30391 goto done;
30392 }
30393 p->mark = _mark;
30394 D(fprintf(stderr, "%*c%s _gather_80[%d-%d]: %s failed!\n", p->level, ' ',
30395 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "type_param _loop0_81"));
30396 }
30397 _res = NULL;
30398 done:
30399 p->level--;
30400 return _res;
30401 }
30402
30403 // _loop1_82: (',' expression)
30404 static asdl_seq *
30405 _loop1_82_rule(Parser *p)
30406 {
30407 if (p->level++ == MAXSTACK) {
30408 _Pypegen_stack_overflow(p);
30409 }
30410 if (p->error_indicator) {
30411 p->level--;
30412 return NULL;
30413 }
30414 void *_res = NULL;
30415 int _mark = p->mark;
30416 void **_children = PyMem_Malloc(sizeof(void *));
30417 if (!_children) {
30418 p->error_indicator = 1;
30419 PyErr_NoMemory();
30420 p->level--;
30421 return NULL;
30422 }
30423 Py_ssize_t _children_capacity = 1;
30424 Py_ssize_t _n = 0;
30425 { // (',' expression)
30426 if (p->error_indicator) {
30427 p->level--;
30428 return NULL;
30429 }
30430 D(fprintf(stderr, "%*c> _loop1_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)"));
30431 void *_tmp_249_var;
30432 while (
30433 (_tmp_249_var = _tmp_249_rule(p)) // ',' expression
30434 )
30435 {
30436 _res = _tmp_249_var;
30437 if (_n == _children_capacity) {
30438 _children_capacity *= 2;
30439 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30440 if (!_new_children) {
30441 PyMem_Free(_children);
30442 p->error_indicator = 1;
30443 PyErr_NoMemory();
30444 p->level--;
30445 return NULL;
30446 }
30447 _children = _new_children;
30448 }
30449 _children[_n++] = _res;
30450 _mark = p->mark;
30451 }
30452 p->mark = _mark;
30453 D(fprintf(stderr, "%*c%s _loop1_82[%d-%d]: %s failed!\n", p->level, ' ',
30454 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' expression)"));
30455 }
30456 if (_n == 0 || p->error_indicator) {
30457 PyMem_Free(_children);
30458 p->level--;
30459 return NULL;
30460 }
30461 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30462 if (!_seq) {
30463 PyMem_Free(_children);
30464 p->error_indicator = 1;
30465 PyErr_NoMemory();
30466 p->level--;
30467 return NULL;
30468 }
30469 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30470 PyMem_Free(_children);
30471 p->level--;
30472 return _seq;
30473 }
30474
30475 // _loop1_83: (',' star_expression)
30476 static asdl_seq *
30477 _loop1_83_rule(Parser *p)
30478 {
30479 if (p->level++ == MAXSTACK) {
30480 _Pypegen_stack_overflow(p);
30481 }
30482 if (p->error_indicator) {
30483 p->level--;
30484 return NULL;
30485 }
30486 void *_res = NULL;
30487 int _mark = p->mark;
30488 void **_children = PyMem_Malloc(sizeof(void *));
30489 if (!_children) {
30490 p->error_indicator = 1;
30491 PyErr_NoMemory();
30492 p->level--;
30493 return NULL;
30494 }
30495 Py_ssize_t _children_capacity = 1;
30496 Py_ssize_t _n = 0;
30497 { // (',' star_expression)
30498 if (p->error_indicator) {
30499 p->level--;
30500 return NULL;
30501 }
30502 D(fprintf(stderr, "%*c> _loop1_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)"));
30503 void *_tmp_250_var;
30504 while (
30505 (_tmp_250_var = _tmp_250_rule(p)) // ',' star_expression
30506 )
30507 {
30508 _res = _tmp_250_var;
30509 if (_n == _children_capacity) {
30510 _children_capacity *= 2;
30511 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30512 if (!_new_children) {
30513 PyMem_Free(_children);
30514 p->error_indicator = 1;
30515 PyErr_NoMemory();
30516 p->level--;
30517 return NULL;
30518 }
30519 _children = _new_children;
30520 }
30521 _children[_n++] = _res;
30522 _mark = p->mark;
30523 }
30524 p->mark = _mark;
30525 D(fprintf(stderr, "%*c%s _loop1_83[%d-%d]: %s failed!\n", p->level, ' ',
30526 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_expression)"));
30527 }
30528 if (_n == 0 || p->error_indicator) {
30529 PyMem_Free(_children);
30530 p->level--;
30531 return NULL;
30532 }
30533 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30534 if (!_seq) {
30535 PyMem_Free(_children);
30536 p->error_indicator = 1;
30537 PyErr_NoMemory();
30538 p->level--;
30539 return NULL;
30540 }
30541 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30542 PyMem_Free(_children);
30543 p->level--;
30544 return _seq;
30545 }
30546
30547 // _loop0_85: ',' star_named_expression
30548 static asdl_seq *
30549 _loop0_85_rule(Parser *p)
30550 {
30551 if (p->level++ == MAXSTACK) {
30552 _Pypegen_stack_overflow(p);
30553 }
30554 if (p->error_indicator) {
30555 p->level--;
30556 return NULL;
30557 }
30558 void *_res = NULL;
30559 int _mark = p->mark;
30560 void **_children = PyMem_Malloc(sizeof(void *));
30561 if (!_children) {
30562 p->error_indicator = 1;
30563 PyErr_NoMemory();
30564 p->level--;
30565 return NULL;
30566 }
30567 Py_ssize_t _children_capacity = 1;
30568 Py_ssize_t _n = 0;
30569 { // ',' star_named_expression
30570 if (p->error_indicator) {
30571 p->level--;
30572 return NULL;
30573 }
30574 D(fprintf(stderr, "%*c> _loop0_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_expression"));
30575 Token * _literal;
30576 expr_ty elem;
30577 while (
30578 (_literal = _PyPegen_expect_token(p, 12)) // token=','
30579 &&
30580 (elem = star_named_expression_rule(p)) // star_named_expression
30581 )
30582 {
30583 _res = elem;
30584 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
30585 p->error_indicator = 1;
30586 PyMem_Free(_children);
30587 p->level--;
30588 return NULL;
30589 }
30590 if (_n == _children_capacity) {
30591 _children_capacity *= 2;
30592 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30593 if (!_new_children) {
30594 PyMem_Free(_children);
30595 p->error_indicator = 1;
30596 PyErr_NoMemory();
30597 p->level--;
30598 return NULL;
30599 }
30600 _children = _new_children;
30601 }
30602 _children[_n++] = _res;
30603 _mark = p->mark;
30604 }
30605 p->mark = _mark;
30606 D(fprintf(stderr, "%*c%s _loop0_85[%d-%d]: %s failed!\n", p->level, ' ',
30607 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_named_expression"));
30608 }
30609 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30610 if (!_seq) {
30611 PyMem_Free(_children);
30612 p->error_indicator = 1;
30613 PyErr_NoMemory();
30614 p->level--;
30615 return NULL;
30616 }
30617 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30618 PyMem_Free(_children);
30619 p->level--;
30620 return _seq;
30621 }
30622
30623 // _gather_84: star_named_expression _loop0_85
30624 static asdl_seq *
30625 _gather_84_rule(Parser *p)
30626 {
30627 if (p->level++ == MAXSTACK) {
30628 _Pypegen_stack_overflow(p);
30629 }
30630 if (p->error_indicator) {
30631 p->level--;
30632 return NULL;
30633 }
30634 asdl_seq * _res = NULL;
30635 int _mark = p->mark;
30636 { // star_named_expression _loop0_85
30637 if (p->error_indicator) {
30638 p->level--;
30639 return NULL;
30640 }
30641 D(fprintf(stderr, "%*c> _gather_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_85"));
30642 expr_ty elem;
30643 asdl_seq * seq;
30644 if (
30645 (elem = star_named_expression_rule(p)) // star_named_expression
30646 &&
30647 (seq = _loop0_85_rule(p)) // _loop0_85
30648 )
30649 {
30650 D(fprintf(stderr, "%*c+ _gather_84[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_85"));
30651 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
30652 goto done;
30653 }
30654 p->mark = _mark;
30655 D(fprintf(stderr, "%*c%s _gather_84[%d-%d]: %s failed!\n", p->level, ' ',
30656 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression _loop0_85"));
30657 }
30658 _res = NULL;
30659 done:
30660 p->level--;
30661 return _res;
30662 }
30663
30664 // _loop1_86: ('or' conjunction)
30665 static asdl_seq *
30666 _loop1_86_rule(Parser *p)
30667 {
30668 if (p->level++ == MAXSTACK) {
30669 _Pypegen_stack_overflow(p);
30670 }
30671 if (p->error_indicator) {
30672 p->level--;
30673 return NULL;
30674 }
30675 void *_res = NULL;
30676 int _mark = p->mark;
30677 void **_children = PyMem_Malloc(sizeof(void *));
30678 if (!_children) {
30679 p->error_indicator = 1;
30680 PyErr_NoMemory();
30681 p->level--;
30682 return NULL;
30683 }
30684 Py_ssize_t _children_capacity = 1;
30685 Py_ssize_t _n = 0;
30686 { // ('or' conjunction)
30687 if (p->error_indicator) {
30688 p->level--;
30689 return NULL;
30690 }
30691 D(fprintf(stderr, "%*c> _loop1_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)"));
30692 void *_tmp_251_var;
30693 while (
30694 (_tmp_251_var = _tmp_251_rule(p)) // 'or' conjunction
30695 )
30696 {
30697 _res = _tmp_251_var;
30698 if (_n == _children_capacity) {
30699 _children_capacity *= 2;
30700 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30701 if (!_new_children) {
30702 PyMem_Free(_children);
30703 p->error_indicator = 1;
30704 PyErr_NoMemory();
30705 p->level--;
30706 return NULL;
30707 }
30708 _children = _new_children;
30709 }
30710 _children[_n++] = _res;
30711 _mark = p->mark;
30712 }
30713 p->mark = _mark;
30714 D(fprintf(stderr, "%*c%s _loop1_86[%d-%d]: %s failed!\n", p->level, ' ',
30715 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('or' conjunction)"));
30716 }
30717 if (_n == 0 || p->error_indicator) {
30718 PyMem_Free(_children);
30719 p->level--;
30720 return NULL;
30721 }
30722 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30723 if (!_seq) {
30724 PyMem_Free(_children);
30725 p->error_indicator = 1;
30726 PyErr_NoMemory();
30727 p->level--;
30728 return NULL;
30729 }
30730 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30731 PyMem_Free(_children);
30732 p->level--;
30733 return _seq;
30734 }
30735
30736 // _loop1_87: ('and' inversion)
30737 static asdl_seq *
30738 _loop1_87_rule(Parser *p)
30739 {
30740 if (p->level++ == MAXSTACK) {
30741 _Pypegen_stack_overflow(p);
30742 }
30743 if (p->error_indicator) {
30744 p->level--;
30745 return NULL;
30746 }
30747 void *_res = NULL;
30748 int _mark = p->mark;
30749 void **_children = PyMem_Malloc(sizeof(void *));
30750 if (!_children) {
30751 p->error_indicator = 1;
30752 PyErr_NoMemory();
30753 p->level--;
30754 return NULL;
30755 }
30756 Py_ssize_t _children_capacity = 1;
30757 Py_ssize_t _n = 0;
30758 { // ('and' inversion)
30759 if (p->error_indicator) {
30760 p->level--;
30761 return NULL;
30762 }
30763 D(fprintf(stderr, "%*c> _loop1_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)"));
30764 void *_tmp_252_var;
30765 while (
30766 (_tmp_252_var = _tmp_252_rule(p)) // 'and' inversion
30767 )
30768 {
30769 _res = _tmp_252_var;
30770 if (_n == _children_capacity) {
30771 _children_capacity *= 2;
30772 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30773 if (!_new_children) {
30774 PyMem_Free(_children);
30775 p->error_indicator = 1;
30776 PyErr_NoMemory();
30777 p->level--;
30778 return NULL;
30779 }
30780 _children = _new_children;
30781 }
30782 _children[_n++] = _res;
30783 _mark = p->mark;
30784 }
30785 p->mark = _mark;
30786 D(fprintf(stderr, "%*c%s _loop1_87[%d-%d]: %s failed!\n", p->level, ' ',
30787 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('and' inversion)"));
30788 }
30789 if (_n == 0 || p->error_indicator) {
30790 PyMem_Free(_children);
30791 p->level--;
30792 return NULL;
30793 }
30794 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30795 if (!_seq) {
30796 PyMem_Free(_children);
30797 p->error_indicator = 1;
30798 PyErr_NoMemory();
30799 p->level--;
30800 return NULL;
30801 }
30802 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30803 PyMem_Free(_children);
30804 p->level--;
30805 return _seq;
30806 }
30807
30808 // _loop1_88: compare_op_bitwise_or_pair
30809 static asdl_seq *
30810 _loop1_88_rule(Parser *p)
30811 {
30812 if (p->level++ == MAXSTACK) {
30813 _Pypegen_stack_overflow(p);
30814 }
30815 if (p->error_indicator) {
30816 p->level--;
30817 return NULL;
30818 }
30819 void *_res = NULL;
30820 int _mark = p->mark;
30821 void **_children = PyMem_Malloc(sizeof(void *));
30822 if (!_children) {
30823 p->error_indicator = 1;
30824 PyErr_NoMemory();
30825 p->level--;
30826 return NULL;
30827 }
30828 Py_ssize_t _children_capacity = 1;
30829 Py_ssize_t _n = 0;
30830 { // compare_op_bitwise_or_pair
30831 if (p->error_indicator) {
30832 p->level--;
30833 return NULL;
30834 }
30835 D(fprintf(stderr, "%*c> _loop1_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair"));
30836 CmpopExprPair* compare_op_bitwise_or_pair_var;
30837 while (
30838 (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p)) // compare_op_bitwise_or_pair
30839 )
30840 {
30841 _res = compare_op_bitwise_or_pair_var;
30842 if (_n == _children_capacity) {
30843 _children_capacity *= 2;
30844 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30845 if (!_new_children) {
30846 PyMem_Free(_children);
30847 p->error_indicator = 1;
30848 PyErr_NoMemory();
30849 p->level--;
30850 return NULL;
30851 }
30852 _children = _new_children;
30853 }
30854 _children[_n++] = _res;
30855 _mark = p->mark;
30856 }
30857 p->mark = _mark;
30858 D(fprintf(stderr, "%*c%s _loop1_88[%d-%d]: %s failed!\n", p->level, ' ',
30859 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compare_op_bitwise_or_pair"));
30860 }
30861 if (_n == 0 || p->error_indicator) {
30862 PyMem_Free(_children);
30863 p->level--;
30864 return NULL;
30865 }
30866 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30867 if (!_seq) {
30868 PyMem_Free(_children);
30869 p->error_indicator = 1;
30870 PyErr_NoMemory();
30871 p->level--;
30872 return NULL;
30873 }
30874 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30875 PyMem_Free(_children);
30876 p->level--;
30877 return _seq;
30878 }
30879
30880 // _tmp_89: '!='
30881 static void *
30882 _tmp_89_rule(Parser *p)
30883 {
30884 if (p->level++ == MAXSTACK) {
30885 _Pypegen_stack_overflow(p);
30886 }
30887 if (p->error_indicator) {
30888 p->level--;
30889 return NULL;
30890 }
30891 void * _res = NULL;
30892 int _mark = p->mark;
30893 { // '!='
30894 if (p->error_indicator) {
30895 p->level--;
30896 return NULL;
30897 }
30898 D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='"));
30899 Token * tok;
30900 if (
30901 (tok = _PyPegen_expect_token(p, 28)) // token='!='
30902 )
30903 {
30904 D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='"));
30905 _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok;
30906 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
30907 p->error_indicator = 1;
30908 p->level--;
30909 return NULL;
30910 }
30911 goto done;
30912 }
30913 p->mark = _mark;
30914 D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ',
30915 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='"));
30916 }
30917 _res = NULL;
30918 done:
30919 p->level--;
30920 return _res;
30921 }
30922
30923 // _loop0_91: ',' (slice | starred_expression)
30924 static asdl_seq *
30925 _loop0_91_rule(Parser *p)
30926 {
30927 if (p->level++ == MAXSTACK) {
30928 _Pypegen_stack_overflow(p);
30929 }
30930 if (p->error_indicator) {
30931 p->level--;
30932 return NULL;
30933 }
30934 void *_res = NULL;
30935 int _mark = p->mark;
30936 void **_children = PyMem_Malloc(sizeof(void *));
30937 if (!_children) {
30938 p->error_indicator = 1;
30939 PyErr_NoMemory();
30940 p->level--;
30941 return NULL;
30942 }
30943 Py_ssize_t _children_capacity = 1;
30944 Py_ssize_t _n = 0;
30945 { // ',' (slice | starred_expression)
30946 if (p->error_indicator) {
30947 p->level--;
30948 return NULL;
30949 }
30950 D(fprintf(stderr, "%*c> _loop0_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (slice | starred_expression)"));
30951 Token * _literal;
30952 void *elem;
30953 while (
30954 (_literal = _PyPegen_expect_token(p, 12)) // token=','
30955 &&
30956 (elem = _tmp_253_rule(p)) // slice | starred_expression
30957 )
30958 {
30959 _res = elem;
30960 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
30961 p->error_indicator = 1;
30962 PyMem_Free(_children);
30963 p->level--;
30964 return NULL;
30965 }
30966 if (_n == _children_capacity) {
30967 _children_capacity *= 2;
30968 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
30969 if (!_new_children) {
30970 PyMem_Free(_children);
30971 p->error_indicator = 1;
30972 PyErr_NoMemory();
30973 p->level--;
30974 return NULL;
30975 }
30976 _children = _new_children;
30977 }
30978 _children[_n++] = _res;
30979 _mark = p->mark;
30980 }
30981 p->mark = _mark;
30982 D(fprintf(stderr, "%*c%s _loop0_91[%d-%d]: %s failed!\n", p->level, ' ',
30983 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (slice | starred_expression)"));
30984 }
30985 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
30986 if (!_seq) {
30987 PyMem_Free(_children);
30988 p->error_indicator = 1;
30989 PyErr_NoMemory();
30990 p->level--;
30991 return NULL;
30992 }
30993 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
30994 PyMem_Free(_children);
30995 p->level--;
30996 return _seq;
30997 }
30998
30999 // _gather_90: (slice | starred_expression) _loop0_91
31000 static asdl_seq *
31001 _gather_90_rule(Parser *p)
31002 {
31003 if (p->level++ == MAXSTACK) {
31004 _Pypegen_stack_overflow(p);
31005 }
31006 if (p->error_indicator) {
31007 p->level--;
31008 return NULL;
31009 }
31010 asdl_seq * _res = NULL;
31011 int _mark = p->mark;
31012 { // (slice | starred_expression) _loop0_91
31013 if (p->error_indicator) {
31014 p->level--;
31015 return NULL;
31016 }
31017 D(fprintf(stderr, "%*c> _gather_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_91"));
31018 void *elem;
31019 asdl_seq * seq;
31020 if (
31021 (elem = _tmp_253_rule(p)) // slice | starred_expression
31022 &&
31023 (seq = _loop0_91_rule(p)) // _loop0_91
31024 )
31025 {
31026 D(fprintf(stderr, "%*c+ _gather_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_91"));
31027 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
31028 goto done;
31029 }
31030 p->mark = _mark;
31031 D(fprintf(stderr, "%*c%s _gather_90[%d-%d]: %s failed!\n", p->level, ' ',
31032 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slice | starred_expression) _loop0_91"));
31033 }
31034 _res = NULL;
31035 done:
31036 p->level--;
31037 return _res;
31038 }
31039
31040 // _tmp_92: ':' expression?
31041 static void *
31042 _tmp_92_rule(Parser *p)
31043 {
31044 if (p->level++ == MAXSTACK) {
31045 _Pypegen_stack_overflow(p);
31046 }
31047 if (p->error_indicator) {
31048 p->level--;
31049 return NULL;
31050 }
31051 void * _res = NULL;
31052 int _mark = p->mark;
31053 { // ':' expression?
31054 if (p->error_indicator) {
31055 p->level--;
31056 return NULL;
31057 }
31058 D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?"));
31059 Token * _literal;
31060 void *d;
31061 if (
31062 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
31063 &&
31064 (d = expression_rule(p), !p->error_indicator) // expression?
31065 )
31066 {
31067 D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?"));
31068 _res = d;
31069 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
31070 p->error_indicator = 1;
31071 p->level--;
31072 return NULL;
31073 }
31074 goto done;
31075 }
31076 p->mark = _mark;
31077 D(fprintf(stderr, "%*c%s _tmp_92[%d-%d]: %s failed!\n", p->level, ' ',
31078 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?"));
31079 }
31080 _res = NULL;
31081 done:
31082 p->level--;
31083 return _res;
31084 }
31085
31086 // _tmp_93: STRING | FSTRING_START
31087 static void *
31088 _tmp_93_rule(Parser *p)
31089 {
31090 if (p->level++ == MAXSTACK) {
31091 _Pypegen_stack_overflow(p);
31092 }
31093 if (p->error_indicator) {
31094 p->level--;
31095 return NULL;
31096 }
31097 void * _res = NULL;
31098 int _mark = p->mark;
31099 { // STRING
31100 if (p->error_indicator) {
31101 p->level--;
31102 return NULL;
31103 }
31104 D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING"));
31105 expr_ty string_var;
31106 if (
31107 (string_var = _PyPegen_string_token(p)) // STRING
31108 )
31109 {
31110 D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING"));
31111 _res = string_var;
31112 goto done;
31113 }
31114 p->mark = _mark;
31115 D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ',
31116 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING"));
31117 }
31118 { // FSTRING_START
31119 if (p->error_indicator) {
31120 p->level--;
31121 return NULL;
31122 }
31123 D(fprintf(stderr, "%*c> _tmp_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "FSTRING_START"));
31124 Token * fstring_start_var;
31125 if (
31126 (fstring_start_var = _PyPegen_expect_token(p, FSTRING_START)) // token='FSTRING_START'
31127 )
31128 {
31129 D(fprintf(stderr, "%*c+ _tmp_93[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "FSTRING_START"));
31130 _res = fstring_start_var;
31131 goto done;
31132 }
31133 p->mark = _mark;
31134 D(fprintf(stderr, "%*c%s _tmp_93[%d-%d]: %s failed!\n", p->level, ' ',
31135 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_START"));
31136 }
31137 _res = NULL;
31138 done:
31139 p->level--;
31140 return _res;
31141 }
31142
31143 // _tmp_94: tuple | group | genexp
31144 static void *
31145 _tmp_94_rule(Parser *p)
31146 {
31147 if (p->level++ == MAXSTACK) {
31148 _Pypegen_stack_overflow(p);
31149 }
31150 if (p->error_indicator) {
31151 p->level--;
31152 return NULL;
31153 }
31154 void * _res = NULL;
31155 int _mark = p->mark;
31156 { // tuple
31157 if (p->error_indicator) {
31158 p->level--;
31159 return NULL;
31160 }
31161 D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));
31162 expr_ty tuple_var;
31163 if (
31164 (tuple_var = tuple_rule(p)) // tuple
31165 )
31166 {
31167 D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
31168 _res = tuple_var;
31169 goto done;
31170 }
31171 p->mark = _mark;
31172 D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ',
31173 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));
31174 }
31175 { // group
31176 if (p->error_indicator) {
31177 p->level--;
31178 return NULL;
31179 }
31180 D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group"));
31181 expr_ty group_var;
31182 if (
31183 (group_var = group_rule(p)) // group
31184 )
31185 {
31186 D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group"));
31187 _res = group_var;
31188 goto done;
31189 }
31190 p->mark = _mark;
31191 D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ',
31192 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group"));
31193 }
31194 { // genexp
31195 if (p->error_indicator) {
31196 p->level--;
31197 return NULL;
31198 }
31199 D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp"));
31200 expr_ty genexp_var;
31201 if (
31202 (genexp_var = genexp_rule(p)) // genexp
31203 )
31204 {
31205 D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"));
31206 _res = genexp_var;
31207 goto done;
31208 }
31209 p->mark = _mark;
31210 D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ',
31211 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp"));
31212 }
31213 _res = NULL;
31214 done:
31215 p->level--;
31216 return _res;
31217 }
31218
31219 // _tmp_95: list | listcomp
31220 static void *
31221 _tmp_95_rule(Parser *p)
31222 {
31223 if (p->level++ == MAXSTACK) {
31224 _Pypegen_stack_overflow(p);
31225 }
31226 if (p->error_indicator) {
31227 p->level--;
31228 return NULL;
31229 }
31230 void * _res = NULL;
31231 int _mark = p->mark;
31232 { // list
31233 if (p->error_indicator) {
31234 p->level--;
31235 return NULL;
31236 }
31237 D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));
31238 expr_ty list_var;
31239 if (
31240 (list_var = list_rule(p)) // list
31241 )
31242 {
31243 D(fprintf(stderr, "%*c+ _tmp_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
31244 _res = list_var;
31245 goto done;
31246 }
31247 p->mark = _mark;
31248 D(fprintf(stderr, "%*c%s _tmp_95[%d-%d]: %s failed!\n", p->level, ' ',
31249 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));
31250 }
31251 { // listcomp
31252 if (p->error_indicator) {
31253 p->level--;
31254 return NULL;
31255 }
31256 D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp"));
31257 expr_ty listcomp_var;
31258 if (
31259 (listcomp_var = listcomp_rule(p)) // listcomp
31260 )
31261 {
31262 D(fprintf(stderr, "%*c+ _tmp_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp"));
31263 _res = listcomp_var;
31264 goto done;
31265 }
31266 p->mark = _mark;
31267 D(fprintf(stderr, "%*c%s _tmp_95[%d-%d]: %s failed!\n", p->level, ' ',
31268 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp"));
31269 }
31270 _res = NULL;
31271 done:
31272 p->level--;
31273 return _res;
31274 }
31275
31276 // _tmp_96: dict | set | dictcomp | setcomp
31277 static void *
31278 _tmp_96_rule(Parser *p)
31279 {
31280 if (p->level++ == MAXSTACK) {
31281 _Pypegen_stack_overflow(p);
31282 }
31283 if (p->error_indicator) {
31284 p->level--;
31285 return NULL;
31286 }
31287 void * _res = NULL;
31288 int _mark = p->mark;
31289 { // dict
31290 if (p->error_indicator) {
31291 p->level--;
31292 return NULL;
31293 }
31294 D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict"));
31295 expr_ty dict_var;
31296 if (
31297 (dict_var = dict_rule(p)) // dict
31298 )
31299 {
31300 D(fprintf(stderr, "%*c+ _tmp_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict"));
31301 _res = dict_var;
31302 goto done;
31303 }
31304 p->mark = _mark;
31305 D(fprintf(stderr, "%*c%s _tmp_96[%d-%d]: %s failed!\n", p->level, ' ',
31306 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict"));
31307 }
31308 { // set
31309 if (p->error_indicator) {
31310 p->level--;
31311 return NULL;
31312 }
31313 D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set"));
31314 expr_ty set_var;
31315 if (
31316 (set_var = set_rule(p)) // set
31317 )
31318 {
31319 D(fprintf(stderr, "%*c+ _tmp_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set"));
31320 _res = set_var;
31321 goto done;
31322 }
31323 p->mark = _mark;
31324 D(fprintf(stderr, "%*c%s _tmp_96[%d-%d]: %s failed!\n", p->level, ' ',
31325 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "set"));
31326 }
31327 { // dictcomp
31328 if (p->error_indicator) {
31329 p->level--;
31330 return NULL;
31331 }
31332 D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp"));
31333 expr_ty dictcomp_var;
31334 if (
31335 (dictcomp_var = dictcomp_rule(p)) // dictcomp
31336 )
31337 {
31338 D(fprintf(stderr, "%*c+ _tmp_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp"));
31339 _res = dictcomp_var;
31340 goto done;
31341 }
31342 p->mark = _mark;
31343 D(fprintf(stderr, "%*c%s _tmp_96[%d-%d]: %s failed!\n", p->level, ' ',
31344 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp"));
31345 }
31346 { // setcomp
31347 if (p->error_indicator) {
31348 p->level--;
31349 return NULL;
31350 }
31351 D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp"));
31352 expr_ty setcomp_var;
31353 if (
31354 (setcomp_var = setcomp_rule(p)) // setcomp
31355 )
31356 {
31357 D(fprintf(stderr, "%*c+ _tmp_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp"));
31358 _res = setcomp_var;
31359 goto done;
31360 }
31361 p->mark = _mark;
31362 D(fprintf(stderr, "%*c%s _tmp_96[%d-%d]: %s failed!\n", p->level, ' ',
31363 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp"));
31364 }
31365 _res = NULL;
31366 done:
31367 p->level--;
31368 return _res;
31369 }
31370
31371 // _tmp_97: yield_expr | named_expression
31372 static void *
31373 _tmp_97_rule(Parser *p)
31374 {
31375 if (p->level++ == MAXSTACK) {
31376 _Pypegen_stack_overflow(p);
31377 }
31378 if (p->error_indicator) {
31379 p->level--;
31380 return NULL;
31381 }
31382 void * _res = NULL;
31383 int _mark = p->mark;
31384 { // yield_expr
31385 if (p->error_indicator) {
31386 p->level--;
31387 return NULL;
31388 }
31389 D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
31390 expr_ty yield_expr_var;
31391 if (
31392 (yield_expr_var = yield_expr_rule(p)) // yield_expr
31393 )
31394 {
31395 D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
31396 _res = yield_expr_var;
31397 goto done;
31398 }
31399 p->mark = _mark;
31400 D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ',
31401 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
31402 }
31403 { // named_expression
31404 if (p->error_indicator) {
31405 p->level--;
31406 return NULL;
31407 }
31408 D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
31409 expr_ty named_expression_var;
31410 if (
31411 (named_expression_var = named_expression_rule(p)) // named_expression
31412 )
31413 {
31414 D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
31415 _res = named_expression_var;
31416 goto done;
31417 }
31418 p->mark = _mark;
31419 D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ',
31420 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
31421 }
31422 _res = NULL;
31423 done:
31424 p->level--;
31425 return _res;
31426 }
31427
31428 // _loop0_98: lambda_param_no_default
31429 static asdl_seq *
31430 _loop0_98_rule(Parser *p)
31431 {
31432 if (p->level++ == MAXSTACK) {
31433 _Pypegen_stack_overflow(p);
31434 }
31435 if (p->error_indicator) {
31436 p->level--;
31437 return NULL;
31438 }
31439 void *_res = NULL;
31440 int _mark = p->mark;
31441 void **_children = PyMem_Malloc(sizeof(void *));
31442 if (!_children) {
31443 p->error_indicator = 1;
31444 PyErr_NoMemory();
31445 p->level--;
31446 return NULL;
31447 }
31448 Py_ssize_t _children_capacity = 1;
31449 Py_ssize_t _n = 0;
31450 { // lambda_param_no_default
31451 if (p->error_indicator) {
31452 p->level--;
31453 return NULL;
31454 }
31455 D(fprintf(stderr, "%*c> _loop0_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
31456 arg_ty lambda_param_no_default_var;
31457 while (
31458 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
31459 )
31460 {
31461 _res = lambda_param_no_default_var;
31462 if (_n == _children_capacity) {
31463 _children_capacity *= 2;
31464 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31465 if (!_new_children) {
31466 PyMem_Free(_children);
31467 p->error_indicator = 1;
31468 PyErr_NoMemory();
31469 p->level--;
31470 return NULL;
31471 }
31472 _children = _new_children;
31473 }
31474 _children[_n++] = _res;
31475 _mark = p->mark;
31476 }
31477 p->mark = _mark;
31478 D(fprintf(stderr, "%*c%s _loop0_98[%d-%d]: %s failed!\n", p->level, ' ',
31479 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
31480 }
31481 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31482 if (!_seq) {
31483 PyMem_Free(_children);
31484 p->error_indicator = 1;
31485 PyErr_NoMemory();
31486 p->level--;
31487 return NULL;
31488 }
31489 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31490 PyMem_Free(_children);
31491 p->level--;
31492 return _seq;
31493 }
31494
31495 // _loop0_99: lambda_param_with_default
31496 static asdl_seq *
31497 _loop0_99_rule(Parser *p)
31498 {
31499 if (p->level++ == MAXSTACK) {
31500 _Pypegen_stack_overflow(p);
31501 }
31502 if (p->error_indicator) {
31503 p->level--;
31504 return NULL;
31505 }
31506 void *_res = NULL;
31507 int _mark = p->mark;
31508 void **_children = PyMem_Malloc(sizeof(void *));
31509 if (!_children) {
31510 p->error_indicator = 1;
31511 PyErr_NoMemory();
31512 p->level--;
31513 return NULL;
31514 }
31515 Py_ssize_t _children_capacity = 1;
31516 Py_ssize_t _n = 0;
31517 { // lambda_param_with_default
31518 if (p->error_indicator) {
31519 p->level--;
31520 return NULL;
31521 }
31522 D(fprintf(stderr, "%*c> _loop0_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
31523 NameDefaultPair* lambda_param_with_default_var;
31524 while (
31525 (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
31526 )
31527 {
31528 _res = lambda_param_with_default_var;
31529 if (_n == _children_capacity) {
31530 _children_capacity *= 2;
31531 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31532 if (!_new_children) {
31533 PyMem_Free(_children);
31534 p->error_indicator = 1;
31535 PyErr_NoMemory();
31536 p->level--;
31537 return NULL;
31538 }
31539 _children = _new_children;
31540 }
31541 _children[_n++] = _res;
31542 _mark = p->mark;
31543 }
31544 p->mark = _mark;
31545 D(fprintf(stderr, "%*c%s _loop0_99[%d-%d]: %s failed!\n", p->level, ' ',
31546 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
31547 }
31548 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31549 if (!_seq) {
31550 PyMem_Free(_children);
31551 p->error_indicator = 1;
31552 PyErr_NoMemory();
31553 p->level--;
31554 return NULL;
31555 }
31556 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31557 PyMem_Free(_children);
31558 p->level--;
31559 return _seq;
31560 }
31561
31562 // _loop0_100: lambda_param_with_default
31563 static asdl_seq *
31564 _loop0_100_rule(Parser *p)
31565 {
31566 if (p->level++ == MAXSTACK) {
31567 _Pypegen_stack_overflow(p);
31568 }
31569 if (p->error_indicator) {
31570 p->level--;
31571 return NULL;
31572 }
31573 void *_res = NULL;
31574 int _mark = p->mark;
31575 void **_children = PyMem_Malloc(sizeof(void *));
31576 if (!_children) {
31577 p->error_indicator = 1;
31578 PyErr_NoMemory();
31579 p->level--;
31580 return NULL;
31581 }
31582 Py_ssize_t _children_capacity = 1;
31583 Py_ssize_t _n = 0;
31584 { // lambda_param_with_default
31585 if (p->error_indicator) {
31586 p->level--;
31587 return NULL;
31588 }
31589 D(fprintf(stderr, "%*c> _loop0_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
31590 NameDefaultPair* lambda_param_with_default_var;
31591 while (
31592 (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
31593 )
31594 {
31595 _res = lambda_param_with_default_var;
31596 if (_n == _children_capacity) {
31597 _children_capacity *= 2;
31598 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31599 if (!_new_children) {
31600 PyMem_Free(_children);
31601 p->error_indicator = 1;
31602 PyErr_NoMemory();
31603 p->level--;
31604 return NULL;
31605 }
31606 _children = _new_children;
31607 }
31608 _children[_n++] = _res;
31609 _mark = p->mark;
31610 }
31611 p->mark = _mark;
31612 D(fprintf(stderr, "%*c%s _loop0_100[%d-%d]: %s failed!\n", p->level, ' ',
31613 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
31614 }
31615 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31616 if (!_seq) {
31617 PyMem_Free(_children);
31618 p->error_indicator = 1;
31619 PyErr_NoMemory();
31620 p->level--;
31621 return NULL;
31622 }
31623 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31624 PyMem_Free(_children);
31625 p->level--;
31626 return _seq;
31627 }
31628
31629 // _loop1_101: lambda_param_no_default
31630 static asdl_seq *
31631 _loop1_101_rule(Parser *p)
31632 {
31633 if (p->level++ == MAXSTACK) {
31634 _Pypegen_stack_overflow(p);
31635 }
31636 if (p->error_indicator) {
31637 p->level--;
31638 return NULL;
31639 }
31640 void *_res = NULL;
31641 int _mark = p->mark;
31642 void **_children = PyMem_Malloc(sizeof(void *));
31643 if (!_children) {
31644 p->error_indicator = 1;
31645 PyErr_NoMemory();
31646 p->level--;
31647 return NULL;
31648 }
31649 Py_ssize_t _children_capacity = 1;
31650 Py_ssize_t _n = 0;
31651 { // lambda_param_no_default
31652 if (p->error_indicator) {
31653 p->level--;
31654 return NULL;
31655 }
31656 D(fprintf(stderr, "%*c> _loop1_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
31657 arg_ty lambda_param_no_default_var;
31658 while (
31659 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
31660 )
31661 {
31662 _res = lambda_param_no_default_var;
31663 if (_n == _children_capacity) {
31664 _children_capacity *= 2;
31665 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31666 if (!_new_children) {
31667 PyMem_Free(_children);
31668 p->error_indicator = 1;
31669 PyErr_NoMemory();
31670 p->level--;
31671 return NULL;
31672 }
31673 _children = _new_children;
31674 }
31675 _children[_n++] = _res;
31676 _mark = p->mark;
31677 }
31678 p->mark = _mark;
31679 D(fprintf(stderr, "%*c%s _loop1_101[%d-%d]: %s failed!\n", p->level, ' ',
31680 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
31681 }
31682 if (_n == 0 || p->error_indicator) {
31683 PyMem_Free(_children);
31684 p->level--;
31685 return NULL;
31686 }
31687 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31688 if (!_seq) {
31689 PyMem_Free(_children);
31690 p->error_indicator = 1;
31691 PyErr_NoMemory();
31692 p->level--;
31693 return NULL;
31694 }
31695 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31696 PyMem_Free(_children);
31697 p->level--;
31698 return _seq;
31699 }
31700
31701 // _loop0_102: lambda_param_with_default
31702 static asdl_seq *
31703 _loop0_102_rule(Parser *p)
31704 {
31705 if (p->level++ == MAXSTACK) {
31706 _Pypegen_stack_overflow(p);
31707 }
31708 if (p->error_indicator) {
31709 p->level--;
31710 return NULL;
31711 }
31712 void *_res = NULL;
31713 int _mark = p->mark;
31714 void **_children = PyMem_Malloc(sizeof(void *));
31715 if (!_children) {
31716 p->error_indicator = 1;
31717 PyErr_NoMemory();
31718 p->level--;
31719 return NULL;
31720 }
31721 Py_ssize_t _children_capacity = 1;
31722 Py_ssize_t _n = 0;
31723 { // lambda_param_with_default
31724 if (p->error_indicator) {
31725 p->level--;
31726 return NULL;
31727 }
31728 D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
31729 NameDefaultPair* lambda_param_with_default_var;
31730 while (
31731 (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
31732 )
31733 {
31734 _res = lambda_param_with_default_var;
31735 if (_n == _children_capacity) {
31736 _children_capacity *= 2;
31737 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31738 if (!_new_children) {
31739 PyMem_Free(_children);
31740 p->error_indicator = 1;
31741 PyErr_NoMemory();
31742 p->level--;
31743 return NULL;
31744 }
31745 _children = _new_children;
31746 }
31747 _children[_n++] = _res;
31748 _mark = p->mark;
31749 }
31750 p->mark = _mark;
31751 D(fprintf(stderr, "%*c%s _loop0_102[%d-%d]: %s failed!\n", p->level, ' ',
31752 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
31753 }
31754 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31755 if (!_seq) {
31756 PyMem_Free(_children);
31757 p->error_indicator = 1;
31758 PyErr_NoMemory();
31759 p->level--;
31760 return NULL;
31761 }
31762 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31763 PyMem_Free(_children);
31764 p->level--;
31765 return _seq;
31766 }
31767
31768 // _loop1_103: lambda_param_with_default
31769 static asdl_seq *
31770 _loop1_103_rule(Parser *p)
31771 {
31772 if (p->level++ == MAXSTACK) {
31773 _Pypegen_stack_overflow(p);
31774 }
31775 if (p->error_indicator) {
31776 p->level--;
31777 return NULL;
31778 }
31779 void *_res = NULL;
31780 int _mark = p->mark;
31781 void **_children = PyMem_Malloc(sizeof(void *));
31782 if (!_children) {
31783 p->error_indicator = 1;
31784 PyErr_NoMemory();
31785 p->level--;
31786 return NULL;
31787 }
31788 Py_ssize_t _children_capacity = 1;
31789 Py_ssize_t _n = 0;
31790 { // lambda_param_with_default
31791 if (p->error_indicator) {
31792 p->level--;
31793 return NULL;
31794 }
31795 D(fprintf(stderr, "%*c> _loop1_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
31796 NameDefaultPair* lambda_param_with_default_var;
31797 while (
31798 (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
31799 )
31800 {
31801 _res = lambda_param_with_default_var;
31802 if (_n == _children_capacity) {
31803 _children_capacity *= 2;
31804 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31805 if (!_new_children) {
31806 PyMem_Free(_children);
31807 p->error_indicator = 1;
31808 PyErr_NoMemory();
31809 p->level--;
31810 return NULL;
31811 }
31812 _children = _new_children;
31813 }
31814 _children[_n++] = _res;
31815 _mark = p->mark;
31816 }
31817 p->mark = _mark;
31818 D(fprintf(stderr, "%*c%s _loop1_103[%d-%d]: %s failed!\n", p->level, ' ',
31819 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
31820 }
31821 if (_n == 0 || p->error_indicator) {
31822 PyMem_Free(_children);
31823 p->level--;
31824 return NULL;
31825 }
31826 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31827 if (!_seq) {
31828 PyMem_Free(_children);
31829 p->error_indicator = 1;
31830 PyErr_NoMemory();
31831 p->level--;
31832 return NULL;
31833 }
31834 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31835 PyMem_Free(_children);
31836 p->level--;
31837 return _seq;
31838 }
31839
31840 // _loop1_104: lambda_param_no_default
31841 static asdl_seq *
31842 _loop1_104_rule(Parser *p)
31843 {
31844 if (p->level++ == MAXSTACK) {
31845 _Pypegen_stack_overflow(p);
31846 }
31847 if (p->error_indicator) {
31848 p->level--;
31849 return NULL;
31850 }
31851 void *_res = NULL;
31852 int _mark = p->mark;
31853 void **_children = PyMem_Malloc(sizeof(void *));
31854 if (!_children) {
31855 p->error_indicator = 1;
31856 PyErr_NoMemory();
31857 p->level--;
31858 return NULL;
31859 }
31860 Py_ssize_t _children_capacity = 1;
31861 Py_ssize_t _n = 0;
31862 { // lambda_param_no_default
31863 if (p->error_indicator) {
31864 p->level--;
31865 return NULL;
31866 }
31867 D(fprintf(stderr, "%*c> _loop1_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
31868 arg_ty lambda_param_no_default_var;
31869 while (
31870 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
31871 )
31872 {
31873 _res = lambda_param_no_default_var;
31874 if (_n == _children_capacity) {
31875 _children_capacity *= 2;
31876 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31877 if (!_new_children) {
31878 PyMem_Free(_children);
31879 p->error_indicator = 1;
31880 PyErr_NoMemory();
31881 p->level--;
31882 return NULL;
31883 }
31884 _children = _new_children;
31885 }
31886 _children[_n++] = _res;
31887 _mark = p->mark;
31888 }
31889 p->mark = _mark;
31890 D(fprintf(stderr, "%*c%s _loop1_104[%d-%d]: %s failed!\n", p->level, ' ',
31891 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
31892 }
31893 if (_n == 0 || p->error_indicator) {
31894 PyMem_Free(_children);
31895 p->level--;
31896 return NULL;
31897 }
31898 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31899 if (!_seq) {
31900 PyMem_Free(_children);
31901 p->error_indicator = 1;
31902 PyErr_NoMemory();
31903 p->level--;
31904 return NULL;
31905 }
31906 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31907 PyMem_Free(_children);
31908 p->level--;
31909 return _seq;
31910 }
31911
31912 // _loop1_105: lambda_param_no_default
31913 static asdl_seq *
31914 _loop1_105_rule(Parser *p)
31915 {
31916 if (p->level++ == MAXSTACK) {
31917 _Pypegen_stack_overflow(p);
31918 }
31919 if (p->error_indicator) {
31920 p->level--;
31921 return NULL;
31922 }
31923 void *_res = NULL;
31924 int _mark = p->mark;
31925 void **_children = PyMem_Malloc(sizeof(void *));
31926 if (!_children) {
31927 p->error_indicator = 1;
31928 PyErr_NoMemory();
31929 p->level--;
31930 return NULL;
31931 }
31932 Py_ssize_t _children_capacity = 1;
31933 Py_ssize_t _n = 0;
31934 { // lambda_param_no_default
31935 if (p->error_indicator) {
31936 p->level--;
31937 return NULL;
31938 }
31939 D(fprintf(stderr, "%*c> _loop1_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
31940 arg_ty lambda_param_no_default_var;
31941 while (
31942 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
31943 )
31944 {
31945 _res = lambda_param_no_default_var;
31946 if (_n == _children_capacity) {
31947 _children_capacity *= 2;
31948 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
31949 if (!_new_children) {
31950 PyMem_Free(_children);
31951 p->error_indicator = 1;
31952 PyErr_NoMemory();
31953 p->level--;
31954 return NULL;
31955 }
31956 _children = _new_children;
31957 }
31958 _children[_n++] = _res;
31959 _mark = p->mark;
31960 }
31961 p->mark = _mark;
31962 D(fprintf(stderr, "%*c%s _loop1_105[%d-%d]: %s failed!\n", p->level, ' ',
31963 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
31964 }
31965 if (_n == 0 || p->error_indicator) {
31966 PyMem_Free(_children);
31967 p->level--;
31968 return NULL;
31969 }
31970 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
31971 if (!_seq) {
31972 PyMem_Free(_children);
31973 p->error_indicator = 1;
31974 PyErr_NoMemory();
31975 p->level--;
31976 return NULL;
31977 }
31978 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
31979 PyMem_Free(_children);
31980 p->level--;
31981 return _seq;
31982 }
31983
31984 // _loop0_106: lambda_param_no_default
31985 static asdl_seq *
31986 _loop0_106_rule(Parser *p)
31987 {
31988 if (p->level++ == MAXSTACK) {
31989 _Pypegen_stack_overflow(p);
31990 }
31991 if (p->error_indicator) {
31992 p->level--;
31993 return NULL;
31994 }
31995 void *_res = NULL;
31996 int _mark = p->mark;
31997 void **_children = PyMem_Malloc(sizeof(void *));
31998 if (!_children) {
31999 p->error_indicator = 1;
32000 PyErr_NoMemory();
32001 p->level--;
32002 return NULL;
32003 }
32004 Py_ssize_t _children_capacity = 1;
32005 Py_ssize_t _n = 0;
32006 { // lambda_param_no_default
32007 if (p->error_indicator) {
32008 p->level--;
32009 return NULL;
32010 }
32011 D(fprintf(stderr, "%*c> _loop0_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
32012 arg_ty lambda_param_no_default_var;
32013 while (
32014 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
32015 )
32016 {
32017 _res = lambda_param_no_default_var;
32018 if (_n == _children_capacity) {
32019 _children_capacity *= 2;
32020 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32021 if (!_new_children) {
32022 PyMem_Free(_children);
32023 p->error_indicator = 1;
32024 PyErr_NoMemory();
32025 p->level--;
32026 return NULL;
32027 }
32028 _children = _new_children;
32029 }
32030 _children[_n++] = _res;
32031 _mark = p->mark;
32032 }
32033 p->mark = _mark;
32034 D(fprintf(stderr, "%*c%s _loop0_106[%d-%d]: %s failed!\n", p->level, ' ',
32035 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
32036 }
32037 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32038 if (!_seq) {
32039 PyMem_Free(_children);
32040 p->error_indicator = 1;
32041 PyErr_NoMemory();
32042 p->level--;
32043 return NULL;
32044 }
32045 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32046 PyMem_Free(_children);
32047 p->level--;
32048 return _seq;
32049 }
32050
32051 // _loop1_107: lambda_param_with_default
32052 static asdl_seq *
32053 _loop1_107_rule(Parser *p)
32054 {
32055 if (p->level++ == MAXSTACK) {
32056 _Pypegen_stack_overflow(p);
32057 }
32058 if (p->error_indicator) {
32059 p->level--;
32060 return NULL;
32061 }
32062 void *_res = NULL;
32063 int _mark = p->mark;
32064 void **_children = PyMem_Malloc(sizeof(void *));
32065 if (!_children) {
32066 p->error_indicator = 1;
32067 PyErr_NoMemory();
32068 p->level--;
32069 return NULL;
32070 }
32071 Py_ssize_t _children_capacity = 1;
32072 Py_ssize_t _n = 0;
32073 { // lambda_param_with_default
32074 if (p->error_indicator) {
32075 p->level--;
32076 return NULL;
32077 }
32078 D(fprintf(stderr, "%*c> _loop1_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
32079 NameDefaultPair* lambda_param_with_default_var;
32080 while (
32081 (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
32082 )
32083 {
32084 _res = lambda_param_with_default_var;
32085 if (_n == _children_capacity) {
32086 _children_capacity *= 2;
32087 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32088 if (!_new_children) {
32089 PyMem_Free(_children);
32090 p->error_indicator = 1;
32091 PyErr_NoMemory();
32092 p->level--;
32093 return NULL;
32094 }
32095 _children = _new_children;
32096 }
32097 _children[_n++] = _res;
32098 _mark = p->mark;
32099 }
32100 p->mark = _mark;
32101 D(fprintf(stderr, "%*c%s _loop1_107[%d-%d]: %s failed!\n", p->level, ' ',
32102 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
32103 }
32104 if (_n == 0 || p->error_indicator) {
32105 PyMem_Free(_children);
32106 p->level--;
32107 return NULL;
32108 }
32109 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32110 if (!_seq) {
32111 PyMem_Free(_children);
32112 p->error_indicator = 1;
32113 PyErr_NoMemory();
32114 p->level--;
32115 return NULL;
32116 }
32117 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32118 PyMem_Free(_children);
32119 p->level--;
32120 return _seq;
32121 }
32122
32123 // _loop0_108: lambda_param_no_default
32124 static asdl_seq *
32125 _loop0_108_rule(Parser *p)
32126 {
32127 if (p->level++ == MAXSTACK) {
32128 _Pypegen_stack_overflow(p);
32129 }
32130 if (p->error_indicator) {
32131 p->level--;
32132 return NULL;
32133 }
32134 void *_res = NULL;
32135 int _mark = p->mark;
32136 void **_children = PyMem_Malloc(sizeof(void *));
32137 if (!_children) {
32138 p->error_indicator = 1;
32139 PyErr_NoMemory();
32140 p->level--;
32141 return NULL;
32142 }
32143 Py_ssize_t _children_capacity = 1;
32144 Py_ssize_t _n = 0;
32145 { // lambda_param_no_default
32146 if (p->error_indicator) {
32147 p->level--;
32148 return NULL;
32149 }
32150 D(fprintf(stderr, "%*c> _loop0_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
32151 arg_ty lambda_param_no_default_var;
32152 while (
32153 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
32154 )
32155 {
32156 _res = lambda_param_no_default_var;
32157 if (_n == _children_capacity) {
32158 _children_capacity *= 2;
32159 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32160 if (!_new_children) {
32161 PyMem_Free(_children);
32162 p->error_indicator = 1;
32163 PyErr_NoMemory();
32164 p->level--;
32165 return NULL;
32166 }
32167 _children = _new_children;
32168 }
32169 _children[_n++] = _res;
32170 _mark = p->mark;
32171 }
32172 p->mark = _mark;
32173 D(fprintf(stderr, "%*c%s _loop0_108[%d-%d]: %s failed!\n", p->level, ' ',
32174 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
32175 }
32176 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32177 if (!_seq) {
32178 PyMem_Free(_children);
32179 p->error_indicator = 1;
32180 PyErr_NoMemory();
32181 p->level--;
32182 return NULL;
32183 }
32184 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32185 PyMem_Free(_children);
32186 p->level--;
32187 return _seq;
32188 }
32189
32190 // _loop1_109: lambda_param_with_default
32191 static asdl_seq *
32192 _loop1_109_rule(Parser *p)
32193 {
32194 if (p->level++ == MAXSTACK) {
32195 _Pypegen_stack_overflow(p);
32196 }
32197 if (p->error_indicator) {
32198 p->level--;
32199 return NULL;
32200 }
32201 void *_res = NULL;
32202 int _mark = p->mark;
32203 void **_children = PyMem_Malloc(sizeof(void *));
32204 if (!_children) {
32205 p->error_indicator = 1;
32206 PyErr_NoMemory();
32207 p->level--;
32208 return NULL;
32209 }
32210 Py_ssize_t _children_capacity = 1;
32211 Py_ssize_t _n = 0;
32212 { // lambda_param_with_default
32213 if (p->error_indicator) {
32214 p->level--;
32215 return NULL;
32216 }
32217 D(fprintf(stderr, "%*c> _loop1_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
32218 NameDefaultPair* lambda_param_with_default_var;
32219 while (
32220 (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
32221 )
32222 {
32223 _res = lambda_param_with_default_var;
32224 if (_n == _children_capacity) {
32225 _children_capacity *= 2;
32226 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32227 if (!_new_children) {
32228 PyMem_Free(_children);
32229 p->error_indicator = 1;
32230 PyErr_NoMemory();
32231 p->level--;
32232 return NULL;
32233 }
32234 _children = _new_children;
32235 }
32236 _children[_n++] = _res;
32237 _mark = p->mark;
32238 }
32239 p->mark = _mark;
32240 D(fprintf(stderr, "%*c%s _loop1_109[%d-%d]: %s failed!\n", p->level, ' ',
32241 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
32242 }
32243 if (_n == 0 || p->error_indicator) {
32244 PyMem_Free(_children);
32245 p->level--;
32246 return NULL;
32247 }
32248 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32249 if (!_seq) {
32250 PyMem_Free(_children);
32251 p->error_indicator = 1;
32252 PyErr_NoMemory();
32253 p->level--;
32254 return NULL;
32255 }
32256 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32257 PyMem_Free(_children);
32258 p->level--;
32259 return _seq;
32260 }
32261
32262 // _loop0_110: lambda_param_maybe_default
32263 static asdl_seq *
32264 _loop0_110_rule(Parser *p)
32265 {
32266 if (p->level++ == MAXSTACK) {
32267 _Pypegen_stack_overflow(p);
32268 }
32269 if (p->error_indicator) {
32270 p->level--;
32271 return NULL;
32272 }
32273 void *_res = NULL;
32274 int _mark = p->mark;
32275 void **_children = PyMem_Malloc(sizeof(void *));
32276 if (!_children) {
32277 p->error_indicator = 1;
32278 PyErr_NoMemory();
32279 p->level--;
32280 return NULL;
32281 }
32282 Py_ssize_t _children_capacity = 1;
32283 Py_ssize_t _n = 0;
32284 { // lambda_param_maybe_default
32285 if (p->error_indicator) {
32286 p->level--;
32287 return NULL;
32288 }
32289 D(fprintf(stderr, "%*c> _loop0_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
32290 NameDefaultPair* lambda_param_maybe_default_var;
32291 while (
32292 (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
32293 )
32294 {
32295 _res = lambda_param_maybe_default_var;
32296 if (_n == _children_capacity) {
32297 _children_capacity *= 2;
32298 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32299 if (!_new_children) {
32300 PyMem_Free(_children);
32301 p->error_indicator = 1;
32302 PyErr_NoMemory();
32303 p->level--;
32304 return NULL;
32305 }
32306 _children = _new_children;
32307 }
32308 _children[_n++] = _res;
32309 _mark = p->mark;
32310 }
32311 p->mark = _mark;
32312 D(fprintf(stderr, "%*c%s _loop0_110[%d-%d]: %s failed!\n", p->level, ' ',
32313 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
32314 }
32315 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32316 if (!_seq) {
32317 PyMem_Free(_children);
32318 p->error_indicator = 1;
32319 PyErr_NoMemory();
32320 p->level--;
32321 return NULL;
32322 }
32323 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32324 PyMem_Free(_children);
32325 p->level--;
32326 return _seq;
32327 }
32328
32329 // _loop1_111: lambda_param_maybe_default
32330 static asdl_seq *
32331 _loop1_111_rule(Parser *p)
32332 {
32333 if (p->level++ == MAXSTACK) {
32334 _Pypegen_stack_overflow(p);
32335 }
32336 if (p->error_indicator) {
32337 p->level--;
32338 return NULL;
32339 }
32340 void *_res = NULL;
32341 int _mark = p->mark;
32342 void **_children = PyMem_Malloc(sizeof(void *));
32343 if (!_children) {
32344 p->error_indicator = 1;
32345 PyErr_NoMemory();
32346 p->level--;
32347 return NULL;
32348 }
32349 Py_ssize_t _children_capacity = 1;
32350 Py_ssize_t _n = 0;
32351 { // lambda_param_maybe_default
32352 if (p->error_indicator) {
32353 p->level--;
32354 return NULL;
32355 }
32356 D(fprintf(stderr, "%*c> _loop1_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
32357 NameDefaultPair* lambda_param_maybe_default_var;
32358 while (
32359 (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
32360 )
32361 {
32362 _res = lambda_param_maybe_default_var;
32363 if (_n == _children_capacity) {
32364 _children_capacity *= 2;
32365 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32366 if (!_new_children) {
32367 PyMem_Free(_children);
32368 p->error_indicator = 1;
32369 PyErr_NoMemory();
32370 p->level--;
32371 return NULL;
32372 }
32373 _children = _new_children;
32374 }
32375 _children[_n++] = _res;
32376 _mark = p->mark;
32377 }
32378 p->mark = _mark;
32379 D(fprintf(stderr, "%*c%s _loop1_111[%d-%d]: %s failed!\n", p->level, ' ',
32380 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
32381 }
32382 if (_n == 0 || p->error_indicator) {
32383 PyMem_Free(_children);
32384 p->level--;
32385 return NULL;
32386 }
32387 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32388 if (!_seq) {
32389 PyMem_Free(_children);
32390 p->error_indicator = 1;
32391 PyErr_NoMemory();
32392 p->level--;
32393 return NULL;
32394 }
32395 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32396 PyMem_Free(_children);
32397 p->level--;
32398 return _seq;
32399 }
32400
32401 // _loop0_112: fstring_format_spec
32402 static asdl_seq *
32403 _loop0_112_rule(Parser *p)
32404 {
32405 if (p->level++ == MAXSTACK) {
32406 _Pypegen_stack_overflow(p);
32407 }
32408 if (p->error_indicator) {
32409 p->level--;
32410 return NULL;
32411 }
32412 void *_res = NULL;
32413 int _mark = p->mark;
32414 void **_children = PyMem_Malloc(sizeof(void *));
32415 if (!_children) {
32416 p->error_indicator = 1;
32417 PyErr_NoMemory();
32418 p->level--;
32419 return NULL;
32420 }
32421 Py_ssize_t _children_capacity = 1;
32422 Py_ssize_t _n = 0;
32423 { // fstring_format_spec
32424 if (p->error_indicator) {
32425 p->level--;
32426 return NULL;
32427 }
32428 D(fprintf(stderr, "%*c> _loop0_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec"));
32429 expr_ty fstring_format_spec_var;
32430 while (
32431 (fstring_format_spec_var = fstring_format_spec_rule(p)) // fstring_format_spec
32432 )
32433 {
32434 _res = fstring_format_spec_var;
32435 if (_n == _children_capacity) {
32436 _children_capacity *= 2;
32437 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32438 if (!_new_children) {
32439 PyMem_Free(_children);
32440 p->error_indicator = 1;
32441 PyErr_NoMemory();
32442 p->level--;
32443 return NULL;
32444 }
32445 _children = _new_children;
32446 }
32447 _children[_n++] = _res;
32448 _mark = p->mark;
32449 }
32450 p->mark = _mark;
32451 D(fprintf(stderr, "%*c%s _loop0_112[%d-%d]: %s failed!\n", p->level, ' ',
32452 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_format_spec"));
32453 }
32454 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32455 if (!_seq) {
32456 PyMem_Free(_children);
32457 p->error_indicator = 1;
32458 PyErr_NoMemory();
32459 p->level--;
32460 return NULL;
32461 }
32462 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32463 PyMem_Free(_children);
32464 p->level--;
32465 return _seq;
32466 }
32467
32468 // _loop0_113: fstring_middle
32469 static asdl_seq *
32470 _loop0_113_rule(Parser *p)
32471 {
32472 if (p->level++ == MAXSTACK) {
32473 _Pypegen_stack_overflow(p);
32474 }
32475 if (p->error_indicator) {
32476 p->level--;
32477 return NULL;
32478 }
32479 void *_res = NULL;
32480 int _mark = p->mark;
32481 void **_children = PyMem_Malloc(sizeof(void *));
32482 if (!_children) {
32483 p->error_indicator = 1;
32484 PyErr_NoMemory();
32485 p->level--;
32486 return NULL;
32487 }
32488 Py_ssize_t _children_capacity = 1;
32489 Py_ssize_t _n = 0;
32490 { // fstring_middle
32491 if (p->error_indicator) {
32492 p->level--;
32493 return NULL;
32494 }
32495 D(fprintf(stderr, "%*c> _loop0_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_middle"));
32496 expr_ty fstring_middle_var;
32497 while (
32498 (fstring_middle_var = fstring_middle_rule(p)) // fstring_middle
32499 )
32500 {
32501 _res = fstring_middle_var;
32502 if (_n == _children_capacity) {
32503 _children_capacity *= 2;
32504 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32505 if (!_new_children) {
32506 PyMem_Free(_children);
32507 p->error_indicator = 1;
32508 PyErr_NoMemory();
32509 p->level--;
32510 return NULL;
32511 }
32512 _children = _new_children;
32513 }
32514 _children[_n++] = _res;
32515 _mark = p->mark;
32516 }
32517 p->mark = _mark;
32518 D(fprintf(stderr, "%*c%s _loop0_113[%d-%d]: %s failed!\n", p->level, ' ',
32519 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_middle"));
32520 }
32521 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32522 if (!_seq) {
32523 PyMem_Free(_children);
32524 p->error_indicator = 1;
32525 PyErr_NoMemory();
32526 p->level--;
32527 return NULL;
32528 }
32529 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32530 PyMem_Free(_children);
32531 p->level--;
32532 return _seq;
32533 }
32534
32535 // _loop1_114: (fstring | string)
32536 static asdl_seq *
32537 _loop1_114_rule(Parser *p)
32538 {
32539 if (p->level++ == MAXSTACK) {
32540 _Pypegen_stack_overflow(p);
32541 }
32542 if (p->error_indicator) {
32543 p->level--;
32544 return NULL;
32545 }
32546 void *_res = NULL;
32547 int _mark = p->mark;
32548 void **_children = PyMem_Malloc(sizeof(void *));
32549 if (!_children) {
32550 p->error_indicator = 1;
32551 PyErr_NoMemory();
32552 p->level--;
32553 return NULL;
32554 }
32555 Py_ssize_t _children_capacity = 1;
32556 Py_ssize_t _n = 0;
32557 { // (fstring | string)
32558 if (p->error_indicator) {
32559 p->level--;
32560 return NULL;
32561 }
32562 D(fprintf(stderr, "%*c> _loop1_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)"));
32563 void *_tmp_254_var;
32564 while (
32565 (_tmp_254_var = _tmp_254_rule(p)) // fstring | string
32566 )
32567 {
32568 _res = _tmp_254_var;
32569 if (_n == _children_capacity) {
32570 _children_capacity *= 2;
32571 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32572 if (!_new_children) {
32573 PyMem_Free(_children);
32574 p->error_indicator = 1;
32575 PyErr_NoMemory();
32576 p->level--;
32577 return NULL;
32578 }
32579 _children = _new_children;
32580 }
32581 _children[_n++] = _res;
32582 _mark = p->mark;
32583 }
32584 p->mark = _mark;
32585 D(fprintf(stderr, "%*c%s _loop1_114[%d-%d]: %s failed!\n", p->level, ' ',
32586 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string)"));
32587 }
32588 if (_n == 0 || p->error_indicator) {
32589 PyMem_Free(_children);
32590 p->level--;
32591 return NULL;
32592 }
32593 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32594 if (!_seq) {
32595 PyMem_Free(_children);
32596 p->error_indicator = 1;
32597 PyErr_NoMemory();
32598 p->level--;
32599 return NULL;
32600 }
32601 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32602 PyMem_Free(_children);
32603 p->level--;
32604 return _seq;
32605 }
32606
32607 // _tmp_115: star_named_expression ',' star_named_expressions?
32608 static void *
32609 _tmp_115_rule(Parser *p)
32610 {
32611 if (p->level++ == MAXSTACK) {
32612 _Pypegen_stack_overflow(p);
32613 }
32614 if (p->error_indicator) {
32615 p->level--;
32616 return NULL;
32617 }
32618 void * _res = NULL;
32619 int _mark = p->mark;
32620 { // star_named_expression ',' star_named_expressions?
32621 if (p->error_indicator) {
32622 p->level--;
32623 return NULL;
32624 }
32625 D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
32626 Token * _literal;
32627 expr_ty y;
32628 void *z;
32629 if (
32630 (y = star_named_expression_rule(p)) // star_named_expression
32631 &&
32632 (_literal = _PyPegen_expect_token(p, 12)) // token=','
32633 &&
32634 (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions?
32635 )
32636 {
32637 D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
32638 _res = _PyPegen_seq_insert_in_front ( p , y , z );
32639 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
32640 p->error_indicator = 1;
32641 p->level--;
32642 return NULL;
32643 }
32644 goto done;
32645 }
32646 p->mark = _mark;
32647 D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ',
32648 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
32649 }
32650 _res = NULL;
32651 done:
32652 p->level--;
32653 return _res;
32654 }
32655
32656 // _loop0_117: ',' double_starred_kvpair
32657 static asdl_seq *
32658 _loop0_117_rule(Parser *p)
32659 {
32660 if (p->level++ == MAXSTACK) {
32661 _Pypegen_stack_overflow(p);
32662 }
32663 if (p->error_indicator) {
32664 p->level--;
32665 return NULL;
32666 }
32667 void *_res = NULL;
32668 int _mark = p->mark;
32669 void **_children = PyMem_Malloc(sizeof(void *));
32670 if (!_children) {
32671 p->error_indicator = 1;
32672 PyErr_NoMemory();
32673 p->level--;
32674 return NULL;
32675 }
32676 Py_ssize_t _children_capacity = 1;
32677 Py_ssize_t _n = 0;
32678 { // ',' double_starred_kvpair
32679 if (p->error_indicator) {
32680 p->level--;
32681 return NULL;
32682 }
32683 D(fprintf(stderr, "%*c> _loop0_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair"));
32684 Token * _literal;
32685 KeyValuePair* elem;
32686 while (
32687 (_literal = _PyPegen_expect_token(p, 12)) // token=','
32688 &&
32689 (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
32690 )
32691 {
32692 _res = elem;
32693 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
32694 p->error_indicator = 1;
32695 PyMem_Free(_children);
32696 p->level--;
32697 return NULL;
32698 }
32699 if (_n == _children_capacity) {
32700 _children_capacity *= 2;
32701 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32702 if (!_new_children) {
32703 PyMem_Free(_children);
32704 p->error_indicator = 1;
32705 PyErr_NoMemory();
32706 p->level--;
32707 return NULL;
32708 }
32709 _children = _new_children;
32710 }
32711 _children[_n++] = _res;
32712 _mark = p->mark;
32713 }
32714 p->mark = _mark;
32715 D(fprintf(stderr, "%*c%s _loop0_117[%d-%d]: %s failed!\n", p->level, ' ',
32716 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair"));
32717 }
32718 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32719 if (!_seq) {
32720 PyMem_Free(_children);
32721 p->error_indicator = 1;
32722 PyErr_NoMemory();
32723 p->level--;
32724 return NULL;
32725 }
32726 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32727 PyMem_Free(_children);
32728 p->level--;
32729 return _seq;
32730 }
32731
32732 // _gather_116: double_starred_kvpair _loop0_117
32733 static asdl_seq *
32734 _gather_116_rule(Parser *p)
32735 {
32736 if (p->level++ == MAXSTACK) {
32737 _Pypegen_stack_overflow(p);
32738 }
32739 if (p->error_indicator) {
32740 p->level--;
32741 return NULL;
32742 }
32743 asdl_seq * _res = NULL;
32744 int _mark = p->mark;
32745 { // double_starred_kvpair _loop0_117
32746 if (p->error_indicator) {
32747 p->level--;
32748 return NULL;
32749 }
32750 D(fprintf(stderr, "%*c> _gather_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_117"));
32751 KeyValuePair* elem;
32752 asdl_seq * seq;
32753 if (
32754 (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
32755 &&
32756 (seq = _loop0_117_rule(p)) // _loop0_117
32757 )
32758 {
32759 D(fprintf(stderr, "%*c+ _gather_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_117"));
32760 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
32761 goto done;
32762 }
32763 p->mark = _mark;
32764 D(fprintf(stderr, "%*c%s _gather_116[%d-%d]: %s failed!\n", p->level, ' ',
32765 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_117"));
32766 }
32767 _res = NULL;
32768 done:
32769 p->level--;
32770 return _res;
32771 }
32772
32773 // _loop1_118: for_if_clause
32774 static asdl_seq *
32775 _loop1_118_rule(Parser *p)
32776 {
32777 if (p->level++ == MAXSTACK) {
32778 _Pypegen_stack_overflow(p);
32779 }
32780 if (p->error_indicator) {
32781 p->level--;
32782 return NULL;
32783 }
32784 void *_res = NULL;
32785 int _mark = p->mark;
32786 void **_children = PyMem_Malloc(sizeof(void *));
32787 if (!_children) {
32788 p->error_indicator = 1;
32789 PyErr_NoMemory();
32790 p->level--;
32791 return NULL;
32792 }
32793 Py_ssize_t _children_capacity = 1;
32794 Py_ssize_t _n = 0;
32795 { // for_if_clause
32796 if (p->error_indicator) {
32797 p->level--;
32798 return NULL;
32799 }
32800 D(fprintf(stderr, "%*c> _loop1_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause"));
32801 comprehension_ty for_if_clause_var;
32802 while (
32803 (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause
32804 )
32805 {
32806 _res = for_if_clause_var;
32807 if (_n == _children_capacity) {
32808 _children_capacity *= 2;
32809 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32810 if (!_new_children) {
32811 PyMem_Free(_children);
32812 p->error_indicator = 1;
32813 PyErr_NoMemory();
32814 p->level--;
32815 return NULL;
32816 }
32817 _children = _new_children;
32818 }
32819 _children[_n++] = _res;
32820 _mark = p->mark;
32821 }
32822 p->mark = _mark;
32823 D(fprintf(stderr, "%*c%s _loop1_118[%d-%d]: %s failed!\n", p->level, ' ',
32824 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause"));
32825 }
32826 if (_n == 0 || p->error_indicator) {
32827 PyMem_Free(_children);
32828 p->level--;
32829 return NULL;
32830 }
32831 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32832 if (!_seq) {
32833 PyMem_Free(_children);
32834 p->error_indicator = 1;
32835 PyErr_NoMemory();
32836 p->level--;
32837 return NULL;
32838 }
32839 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32840 PyMem_Free(_children);
32841 p->level--;
32842 return _seq;
32843 }
32844
32845 // _loop0_119: ('if' disjunction)
32846 static asdl_seq *
32847 _loop0_119_rule(Parser *p)
32848 {
32849 if (p->level++ == MAXSTACK) {
32850 _Pypegen_stack_overflow(p);
32851 }
32852 if (p->error_indicator) {
32853 p->level--;
32854 return NULL;
32855 }
32856 void *_res = NULL;
32857 int _mark = p->mark;
32858 void **_children = PyMem_Malloc(sizeof(void *));
32859 if (!_children) {
32860 p->error_indicator = 1;
32861 PyErr_NoMemory();
32862 p->level--;
32863 return NULL;
32864 }
32865 Py_ssize_t _children_capacity = 1;
32866 Py_ssize_t _n = 0;
32867 { // ('if' disjunction)
32868 if (p->error_indicator) {
32869 p->level--;
32870 return NULL;
32871 }
32872 D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
32873 void *_tmp_255_var;
32874 while (
32875 (_tmp_255_var = _tmp_255_rule(p)) // 'if' disjunction
32876 )
32877 {
32878 _res = _tmp_255_var;
32879 if (_n == _children_capacity) {
32880 _children_capacity *= 2;
32881 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32882 if (!_new_children) {
32883 PyMem_Free(_children);
32884 p->error_indicator = 1;
32885 PyErr_NoMemory();
32886 p->level--;
32887 return NULL;
32888 }
32889 _children = _new_children;
32890 }
32891 _children[_n++] = _res;
32892 _mark = p->mark;
32893 }
32894 p->mark = _mark;
32895 D(fprintf(stderr, "%*c%s _loop0_119[%d-%d]: %s failed!\n", p->level, ' ',
32896 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)"));
32897 }
32898 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32899 if (!_seq) {
32900 PyMem_Free(_children);
32901 p->error_indicator = 1;
32902 PyErr_NoMemory();
32903 p->level--;
32904 return NULL;
32905 }
32906 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32907 PyMem_Free(_children);
32908 p->level--;
32909 return _seq;
32910 }
32911
32912 // _loop0_120: ('if' disjunction)
32913 static asdl_seq *
32914 _loop0_120_rule(Parser *p)
32915 {
32916 if (p->level++ == MAXSTACK) {
32917 _Pypegen_stack_overflow(p);
32918 }
32919 if (p->error_indicator) {
32920 p->level--;
32921 return NULL;
32922 }
32923 void *_res = NULL;
32924 int _mark = p->mark;
32925 void **_children = PyMem_Malloc(sizeof(void *));
32926 if (!_children) {
32927 p->error_indicator = 1;
32928 PyErr_NoMemory();
32929 p->level--;
32930 return NULL;
32931 }
32932 Py_ssize_t _children_capacity = 1;
32933 Py_ssize_t _n = 0;
32934 { // ('if' disjunction)
32935 if (p->error_indicator) {
32936 p->level--;
32937 return NULL;
32938 }
32939 D(fprintf(stderr, "%*c> _loop0_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
32940 void *_tmp_256_var;
32941 while (
32942 (_tmp_256_var = _tmp_256_rule(p)) // 'if' disjunction
32943 )
32944 {
32945 _res = _tmp_256_var;
32946 if (_n == _children_capacity) {
32947 _children_capacity *= 2;
32948 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
32949 if (!_new_children) {
32950 PyMem_Free(_children);
32951 p->error_indicator = 1;
32952 PyErr_NoMemory();
32953 p->level--;
32954 return NULL;
32955 }
32956 _children = _new_children;
32957 }
32958 _children[_n++] = _res;
32959 _mark = p->mark;
32960 }
32961 p->mark = _mark;
32962 D(fprintf(stderr, "%*c%s _loop0_120[%d-%d]: %s failed!\n", p->level, ' ',
32963 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)"));
32964 }
32965 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
32966 if (!_seq) {
32967 PyMem_Free(_children);
32968 p->error_indicator = 1;
32969 PyErr_NoMemory();
32970 p->level--;
32971 return NULL;
32972 }
32973 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
32974 PyMem_Free(_children);
32975 p->level--;
32976 return _seq;
32977 }
32978
32979 // _tmp_121: bitwise_or ((',' bitwise_or))* ','?
32980 static void *
32981 _tmp_121_rule(Parser *p)
32982 {
32983 if (p->level++ == MAXSTACK) {
32984 _Pypegen_stack_overflow(p);
32985 }
32986 if (p->error_indicator) {
32987 p->level--;
32988 return NULL;
32989 }
32990 void * _res = NULL;
32991 int _mark = p->mark;
32992 { // bitwise_or ((',' bitwise_or))* ','?
32993 if (p->error_indicator) {
32994 p->level--;
32995 return NULL;
32996 }
32997 D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?"));
32998 asdl_seq * _loop0_257_var;
32999 void *_opt_var;
33000 UNUSED(_opt_var); // Silence compiler warnings
33001 expr_ty bitwise_or_var;
33002 if (
33003 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
33004 &&
33005 (_loop0_257_var = _loop0_257_rule(p)) // ((',' bitwise_or))*
33006 &&
33007 (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
33008 )
33009 {
33010 D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?"));
33011 _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_257_var, _opt_var);
33012 goto done;
33013 }
33014 p->mark = _mark;
33015 D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ',
33016 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?"));
33017 }
33018 _res = NULL;
33019 done:
33020 p->level--;
33021 return _res;
33022 }
33023
33024 // _tmp_122: assignment_expression | expression !':='
33025 static void *
33026 _tmp_122_rule(Parser *p)
33027 {
33028 if (p->level++ == MAXSTACK) {
33029 _Pypegen_stack_overflow(p);
33030 }
33031 if (p->error_indicator) {
33032 p->level--;
33033 return NULL;
33034 }
33035 void * _res = NULL;
33036 int _mark = p->mark;
33037 { // assignment_expression
33038 if (p->error_indicator) {
33039 p->level--;
33040 return NULL;
33041 }
33042 D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
33043 expr_ty assignment_expression_var;
33044 if (
33045 (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
33046 )
33047 {
33048 D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
33049 _res = assignment_expression_var;
33050 goto done;
33051 }
33052 p->mark = _mark;
33053 D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ',
33054 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));
33055 }
33056 { // expression !':='
33057 if (p->error_indicator) {
33058 p->level--;
33059 return NULL;
33060 }
33061 D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
33062 expr_ty expression_var;
33063 if (
33064 (expression_var = expression_rule(p)) // expression
33065 &&
33066 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
33067 )
33068 {
33069 D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
33070 _res = expression_var;
33071 goto done;
33072 }
33073 p->mark = _mark;
33074 D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ',
33075 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));
33076 }
33077 _res = NULL;
33078 done:
33079 p->level--;
33080 return _res;
33081 }
33082
33083 // _loop0_124: ',' (starred_expression | (assignment_expression | expression !':=') !'=')
33084 static asdl_seq *
33085 _loop0_124_rule(Parser *p)
33086 {
33087 if (p->level++ == MAXSTACK) {
33088 _Pypegen_stack_overflow(p);
33089 }
33090 if (p->error_indicator) {
33091 p->level--;
33092 return NULL;
33093 }
33094 void *_res = NULL;
33095 int _mark = p->mark;
33096 void **_children = PyMem_Malloc(sizeof(void *));
33097 if (!_children) {
33098 p->error_indicator = 1;
33099 PyErr_NoMemory();
33100 p->level--;
33101 return NULL;
33102 }
33103 Py_ssize_t _children_capacity = 1;
33104 Py_ssize_t _n = 0;
33105 { // ',' (starred_expression | (assignment_expression | expression !':=') !'=')
33106 if (p->error_indicator) {
33107 p->level--;
33108 return NULL;
33109 }
33110 D(fprintf(stderr, "%*c> _loop0_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')"));
33111 Token * _literal;
33112 void *elem;
33113 while (
33114 (_literal = _PyPegen_expect_token(p, 12)) // token=','
33115 &&
33116 (elem = _tmp_258_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'='
33117 )
33118 {
33119 _res = elem;
33120 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
33121 p->error_indicator = 1;
33122 PyMem_Free(_children);
33123 p->level--;
33124 return NULL;
33125 }
33126 if (_n == _children_capacity) {
33127 _children_capacity *= 2;
33128 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33129 if (!_new_children) {
33130 PyMem_Free(_children);
33131 p->error_indicator = 1;
33132 PyErr_NoMemory();
33133 p->level--;
33134 return NULL;
33135 }
33136 _children = _new_children;
33137 }
33138 _children[_n++] = _res;
33139 _mark = p->mark;
33140 }
33141 p->mark = _mark;
33142 D(fprintf(stderr, "%*c%s _loop0_124[%d-%d]: %s failed!\n", p->level, ' ',
33143 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')"));
33144 }
33145 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33146 if (!_seq) {
33147 PyMem_Free(_children);
33148 p->error_indicator = 1;
33149 PyErr_NoMemory();
33150 p->level--;
33151 return NULL;
33152 }
33153 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33154 PyMem_Free(_children);
33155 p->level--;
33156 return _seq;
33157 }
33158
33159 // _gather_123:
33160 // | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_124
33161 static asdl_seq *
33162 _gather_123_rule(Parser *p)
33163 {
33164 if (p->level++ == MAXSTACK) {
33165 _Pypegen_stack_overflow(p);
33166 }
33167 if (p->error_indicator) {
33168 p->level--;
33169 return NULL;
33170 }
33171 asdl_seq * _res = NULL;
33172 int _mark = p->mark;
33173 { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_124
33174 if (p->error_indicator) {
33175 p->level--;
33176 return NULL;
33177 }
33178 D(fprintf(stderr, "%*c> _gather_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_124"));
33179 void *elem;
33180 asdl_seq * seq;
33181 if (
33182 (elem = _tmp_258_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'='
33183 &&
33184 (seq = _loop0_124_rule(p)) // _loop0_124
33185 )
33186 {
33187 D(fprintf(stderr, "%*c+ _gather_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_124"));
33188 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
33189 goto done;
33190 }
33191 p->mark = _mark;
33192 D(fprintf(stderr, "%*c%s _gather_123[%d-%d]: %s failed!\n", p->level, ' ',
33193 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_124"));
33194 }
33195 _res = NULL;
33196 done:
33197 p->level--;
33198 return _res;
33199 }
33200
33201 // _tmp_125: ',' kwargs
33202 static void *
33203 _tmp_125_rule(Parser *p)
33204 {
33205 if (p->level++ == MAXSTACK) {
33206 _Pypegen_stack_overflow(p);
33207 }
33208 if (p->error_indicator) {
33209 p->level--;
33210 return NULL;
33211 }
33212 void * _res = NULL;
33213 int _mark = p->mark;
33214 { // ',' kwargs
33215 if (p->error_indicator) {
33216 p->level--;
33217 return NULL;
33218 }
33219 D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs"));
33220 Token * _literal;
33221 asdl_seq* k;
33222 if (
33223 (_literal = _PyPegen_expect_token(p, 12)) // token=','
33224 &&
33225 (k = kwargs_rule(p)) // kwargs
33226 )
33227 {
33228 D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs"));
33229 _res = k;
33230 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
33231 p->error_indicator = 1;
33232 p->level--;
33233 return NULL;
33234 }
33235 goto done;
33236 }
33237 p->mark = _mark;
33238 D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ',
33239 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs"));
33240 }
33241 _res = NULL;
33242 done:
33243 p->level--;
33244 return _res;
33245 }
33246
33247 // _loop0_127: ',' kwarg_or_starred
33248 static asdl_seq *
33249 _loop0_127_rule(Parser *p)
33250 {
33251 if (p->level++ == MAXSTACK) {
33252 _Pypegen_stack_overflow(p);
33253 }
33254 if (p->error_indicator) {
33255 p->level--;
33256 return NULL;
33257 }
33258 void *_res = NULL;
33259 int _mark = p->mark;
33260 void **_children = PyMem_Malloc(sizeof(void *));
33261 if (!_children) {
33262 p->error_indicator = 1;
33263 PyErr_NoMemory();
33264 p->level--;
33265 return NULL;
33266 }
33267 Py_ssize_t _children_capacity = 1;
33268 Py_ssize_t _n = 0;
33269 { // ',' kwarg_or_starred
33270 if (p->error_indicator) {
33271 p->level--;
33272 return NULL;
33273 }
33274 D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred"));
33275 Token * _literal;
33276 KeywordOrStarred* elem;
33277 while (
33278 (_literal = _PyPegen_expect_token(p, 12)) // token=','
33279 &&
33280 (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
33281 )
33282 {
33283 _res = elem;
33284 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
33285 p->error_indicator = 1;
33286 PyMem_Free(_children);
33287 p->level--;
33288 return NULL;
33289 }
33290 if (_n == _children_capacity) {
33291 _children_capacity *= 2;
33292 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33293 if (!_new_children) {
33294 PyMem_Free(_children);
33295 p->error_indicator = 1;
33296 PyErr_NoMemory();
33297 p->level--;
33298 return NULL;
33299 }
33300 _children = _new_children;
33301 }
33302 _children[_n++] = _res;
33303 _mark = p->mark;
33304 }
33305 p->mark = _mark;
33306 D(fprintf(stderr, "%*c%s _loop0_127[%d-%d]: %s failed!\n", p->level, ' ',
33307 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred"));
33308 }
33309 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33310 if (!_seq) {
33311 PyMem_Free(_children);
33312 p->error_indicator = 1;
33313 PyErr_NoMemory();
33314 p->level--;
33315 return NULL;
33316 }
33317 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33318 PyMem_Free(_children);
33319 p->level--;
33320 return _seq;
33321 }
33322
33323 // _gather_126: kwarg_or_starred _loop0_127
33324 static asdl_seq *
33325 _gather_126_rule(Parser *p)
33326 {
33327 if (p->level++ == MAXSTACK) {
33328 _Pypegen_stack_overflow(p);
33329 }
33330 if (p->error_indicator) {
33331 p->level--;
33332 return NULL;
33333 }
33334 asdl_seq * _res = NULL;
33335 int _mark = p->mark;
33336 { // kwarg_or_starred _loop0_127
33337 if (p->error_indicator) {
33338 p->level--;
33339 return NULL;
33340 }
33341 D(fprintf(stderr, "%*c> _gather_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_127"));
33342 KeywordOrStarred* elem;
33343 asdl_seq * seq;
33344 if (
33345 (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
33346 &&
33347 (seq = _loop0_127_rule(p)) // _loop0_127
33348 )
33349 {
33350 D(fprintf(stderr, "%*c+ _gather_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_127"));
33351 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
33352 goto done;
33353 }
33354 p->mark = _mark;
33355 D(fprintf(stderr, "%*c%s _gather_126[%d-%d]: %s failed!\n", p->level, ' ',
33356 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_127"));
33357 }
33358 _res = NULL;
33359 done:
33360 p->level--;
33361 return _res;
33362 }
33363
33364 // _loop0_129: ',' kwarg_or_double_starred
33365 static asdl_seq *
33366 _loop0_129_rule(Parser *p)
33367 {
33368 if (p->level++ == MAXSTACK) {
33369 _Pypegen_stack_overflow(p);
33370 }
33371 if (p->error_indicator) {
33372 p->level--;
33373 return NULL;
33374 }
33375 void *_res = NULL;
33376 int _mark = p->mark;
33377 void **_children = PyMem_Malloc(sizeof(void *));
33378 if (!_children) {
33379 p->error_indicator = 1;
33380 PyErr_NoMemory();
33381 p->level--;
33382 return NULL;
33383 }
33384 Py_ssize_t _children_capacity = 1;
33385 Py_ssize_t _n = 0;
33386 { // ',' kwarg_or_double_starred
33387 if (p->error_indicator) {
33388 p->level--;
33389 return NULL;
33390 }
33391 D(fprintf(stderr, "%*c> _loop0_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred"));
33392 Token * _literal;
33393 KeywordOrStarred* elem;
33394 while (
33395 (_literal = _PyPegen_expect_token(p, 12)) // token=','
33396 &&
33397 (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
33398 )
33399 {
33400 _res = elem;
33401 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
33402 p->error_indicator = 1;
33403 PyMem_Free(_children);
33404 p->level--;
33405 return NULL;
33406 }
33407 if (_n == _children_capacity) {
33408 _children_capacity *= 2;
33409 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33410 if (!_new_children) {
33411 PyMem_Free(_children);
33412 p->error_indicator = 1;
33413 PyErr_NoMemory();
33414 p->level--;
33415 return NULL;
33416 }
33417 _children = _new_children;
33418 }
33419 _children[_n++] = _res;
33420 _mark = p->mark;
33421 }
33422 p->mark = _mark;
33423 D(fprintf(stderr, "%*c%s _loop0_129[%d-%d]: %s failed!\n", p->level, ' ',
33424 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred"));
33425 }
33426 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33427 if (!_seq) {
33428 PyMem_Free(_children);
33429 p->error_indicator = 1;
33430 PyErr_NoMemory();
33431 p->level--;
33432 return NULL;
33433 }
33434 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33435 PyMem_Free(_children);
33436 p->level--;
33437 return _seq;
33438 }
33439
33440 // _gather_128: kwarg_or_double_starred _loop0_129
33441 static asdl_seq *
33442 _gather_128_rule(Parser *p)
33443 {
33444 if (p->level++ == MAXSTACK) {
33445 _Pypegen_stack_overflow(p);
33446 }
33447 if (p->error_indicator) {
33448 p->level--;
33449 return NULL;
33450 }
33451 asdl_seq * _res = NULL;
33452 int _mark = p->mark;
33453 { // kwarg_or_double_starred _loop0_129
33454 if (p->error_indicator) {
33455 p->level--;
33456 return NULL;
33457 }
33458 D(fprintf(stderr, "%*c> _gather_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_129"));
33459 KeywordOrStarred* elem;
33460 asdl_seq * seq;
33461 if (
33462 (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
33463 &&
33464 (seq = _loop0_129_rule(p)) // _loop0_129
33465 )
33466 {
33467 D(fprintf(stderr, "%*c+ _gather_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_129"));
33468 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
33469 goto done;
33470 }
33471 p->mark = _mark;
33472 D(fprintf(stderr, "%*c%s _gather_128[%d-%d]: %s failed!\n", p->level, ' ',
33473 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_129"));
33474 }
33475 _res = NULL;
33476 done:
33477 p->level--;
33478 return _res;
33479 }
33480
33481 // _loop0_131: ',' kwarg_or_starred
33482 static asdl_seq *
33483 _loop0_131_rule(Parser *p)
33484 {
33485 if (p->level++ == MAXSTACK) {
33486 _Pypegen_stack_overflow(p);
33487 }
33488 if (p->error_indicator) {
33489 p->level--;
33490 return NULL;
33491 }
33492 void *_res = NULL;
33493 int _mark = p->mark;
33494 void **_children = PyMem_Malloc(sizeof(void *));
33495 if (!_children) {
33496 p->error_indicator = 1;
33497 PyErr_NoMemory();
33498 p->level--;
33499 return NULL;
33500 }
33501 Py_ssize_t _children_capacity = 1;
33502 Py_ssize_t _n = 0;
33503 { // ',' kwarg_or_starred
33504 if (p->error_indicator) {
33505 p->level--;
33506 return NULL;
33507 }
33508 D(fprintf(stderr, "%*c> _loop0_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred"));
33509 Token * _literal;
33510 KeywordOrStarred* elem;
33511 while (
33512 (_literal = _PyPegen_expect_token(p, 12)) // token=','
33513 &&
33514 (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
33515 )
33516 {
33517 _res = elem;
33518 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
33519 p->error_indicator = 1;
33520 PyMem_Free(_children);
33521 p->level--;
33522 return NULL;
33523 }
33524 if (_n == _children_capacity) {
33525 _children_capacity *= 2;
33526 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33527 if (!_new_children) {
33528 PyMem_Free(_children);
33529 p->error_indicator = 1;
33530 PyErr_NoMemory();
33531 p->level--;
33532 return NULL;
33533 }
33534 _children = _new_children;
33535 }
33536 _children[_n++] = _res;
33537 _mark = p->mark;
33538 }
33539 p->mark = _mark;
33540 D(fprintf(stderr, "%*c%s _loop0_131[%d-%d]: %s failed!\n", p->level, ' ',
33541 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred"));
33542 }
33543 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33544 if (!_seq) {
33545 PyMem_Free(_children);
33546 p->error_indicator = 1;
33547 PyErr_NoMemory();
33548 p->level--;
33549 return NULL;
33550 }
33551 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33552 PyMem_Free(_children);
33553 p->level--;
33554 return _seq;
33555 }
33556
33557 // _gather_130: kwarg_or_starred _loop0_131
33558 static asdl_seq *
33559 _gather_130_rule(Parser *p)
33560 {
33561 if (p->level++ == MAXSTACK) {
33562 _Pypegen_stack_overflow(p);
33563 }
33564 if (p->error_indicator) {
33565 p->level--;
33566 return NULL;
33567 }
33568 asdl_seq * _res = NULL;
33569 int _mark = p->mark;
33570 { // kwarg_or_starred _loop0_131
33571 if (p->error_indicator) {
33572 p->level--;
33573 return NULL;
33574 }
33575 D(fprintf(stderr, "%*c> _gather_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_131"));
33576 KeywordOrStarred* elem;
33577 asdl_seq * seq;
33578 if (
33579 (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred
33580 &&
33581 (seq = _loop0_131_rule(p)) // _loop0_131
33582 )
33583 {
33584 D(fprintf(stderr, "%*c+ _gather_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_131"));
33585 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
33586 goto done;
33587 }
33588 p->mark = _mark;
33589 D(fprintf(stderr, "%*c%s _gather_130[%d-%d]: %s failed!\n", p->level, ' ',
33590 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_131"));
33591 }
33592 _res = NULL;
33593 done:
33594 p->level--;
33595 return _res;
33596 }
33597
33598 // _loop0_133: ',' kwarg_or_double_starred
33599 static asdl_seq *
33600 _loop0_133_rule(Parser *p)
33601 {
33602 if (p->level++ == MAXSTACK) {
33603 _Pypegen_stack_overflow(p);
33604 }
33605 if (p->error_indicator) {
33606 p->level--;
33607 return NULL;
33608 }
33609 void *_res = NULL;
33610 int _mark = p->mark;
33611 void **_children = PyMem_Malloc(sizeof(void *));
33612 if (!_children) {
33613 p->error_indicator = 1;
33614 PyErr_NoMemory();
33615 p->level--;
33616 return NULL;
33617 }
33618 Py_ssize_t _children_capacity = 1;
33619 Py_ssize_t _n = 0;
33620 { // ',' kwarg_or_double_starred
33621 if (p->error_indicator) {
33622 p->level--;
33623 return NULL;
33624 }
33625 D(fprintf(stderr, "%*c> _loop0_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred"));
33626 Token * _literal;
33627 KeywordOrStarred* elem;
33628 while (
33629 (_literal = _PyPegen_expect_token(p, 12)) // token=','
33630 &&
33631 (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
33632 )
33633 {
33634 _res = elem;
33635 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
33636 p->error_indicator = 1;
33637 PyMem_Free(_children);
33638 p->level--;
33639 return NULL;
33640 }
33641 if (_n == _children_capacity) {
33642 _children_capacity *= 2;
33643 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33644 if (!_new_children) {
33645 PyMem_Free(_children);
33646 p->error_indicator = 1;
33647 PyErr_NoMemory();
33648 p->level--;
33649 return NULL;
33650 }
33651 _children = _new_children;
33652 }
33653 _children[_n++] = _res;
33654 _mark = p->mark;
33655 }
33656 p->mark = _mark;
33657 D(fprintf(stderr, "%*c%s _loop0_133[%d-%d]: %s failed!\n", p->level, ' ',
33658 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred"));
33659 }
33660 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33661 if (!_seq) {
33662 PyMem_Free(_children);
33663 p->error_indicator = 1;
33664 PyErr_NoMemory();
33665 p->level--;
33666 return NULL;
33667 }
33668 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33669 PyMem_Free(_children);
33670 p->level--;
33671 return _seq;
33672 }
33673
33674 // _gather_132: kwarg_or_double_starred _loop0_133
33675 static asdl_seq *
33676 _gather_132_rule(Parser *p)
33677 {
33678 if (p->level++ == MAXSTACK) {
33679 _Pypegen_stack_overflow(p);
33680 }
33681 if (p->error_indicator) {
33682 p->level--;
33683 return NULL;
33684 }
33685 asdl_seq * _res = NULL;
33686 int _mark = p->mark;
33687 { // kwarg_or_double_starred _loop0_133
33688 if (p->error_indicator) {
33689 p->level--;
33690 return NULL;
33691 }
33692 D(fprintf(stderr, "%*c> _gather_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_133"));
33693 KeywordOrStarred* elem;
33694 asdl_seq * seq;
33695 if (
33696 (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred
33697 &&
33698 (seq = _loop0_133_rule(p)) // _loop0_133
33699 )
33700 {
33701 D(fprintf(stderr, "%*c+ _gather_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_133"));
33702 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
33703 goto done;
33704 }
33705 p->mark = _mark;
33706 D(fprintf(stderr, "%*c%s _gather_132[%d-%d]: %s failed!\n", p->level, ' ',
33707 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_133"));
33708 }
33709 _res = NULL;
33710 done:
33711 p->level--;
33712 return _res;
33713 }
33714
33715 // _loop0_134: (',' star_target)
33716 static asdl_seq *
33717 _loop0_134_rule(Parser *p)
33718 {
33719 if (p->level++ == MAXSTACK) {
33720 _Pypegen_stack_overflow(p);
33721 }
33722 if (p->error_indicator) {
33723 p->level--;
33724 return NULL;
33725 }
33726 void *_res = NULL;
33727 int _mark = p->mark;
33728 void **_children = PyMem_Malloc(sizeof(void *));
33729 if (!_children) {
33730 p->error_indicator = 1;
33731 PyErr_NoMemory();
33732 p->level--;
33733 return NULL;
33734 }
33735 Py_ssize_t _children_capacity = 1;
33736 Py_ssize_t _n = 0;
33737 { // (',' star_target)
33738 if (p->error_indicator) {
33739 p->level--;
33740 return NULL;
33741 }
33742 D(fprintf(stderr, "%*c> _loop0_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
33743 void *_tmp_259_var;
33744 while (
33745 (_tmp_259_var = _tmp_259_rule(p)) // ',' star_target
33746 )
33747 {
33748 _res = _tmp_259_var;
33749 if (_n == _children_capacity) {
33750 _children_capacity *= 2;
33751 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33752 if (!_new_children) {
33753 PyMem_Free(_children);
33754 p->error_indicator = 1;
33755 PyErr_NoMemory();
33756 p->level--;
33757 return NULL;
33758 }
33759 _children = _new_children;
33760 }
33761 _children[_n++] = _res;
33762 _mark = p->mark;
33763 }
33764 p->mark = _mark;
33765 D(fprintf(stderr, "%*c%s _loop0_134[%d-%d]: %s failed!\n", p->level, ' ',
33766 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)"));
33767 }
33768 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33769 if (!_seq) {
33770 PyMem_Free(_children);
33771 p->error_indicator = 1;
33772 PyErr_NoMemory();
33773 p->level--;
33774 return NULL;
33775 }
33776 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33777 PyMem_Free(_children);
33778 p->level--;
33779 return _seq;
33780 }
33781
33782 // _loop0_136: ',' star_target
33783 static asdl_seq *
33784 _loop0_136_rule(Parser *p)
33785 {
33786 if (p->level++ == MAXSTACK) {
33787 _Pypegen_stack_overflow(p);
33788 }
33789 if (p->error_indicator) {
33790 p->level--;
33791 return NULL;
33792 }
33793 void *_res = NULL;
33794 int _mark = p->mark;
33795 void **_children = PyMem_Malloc(sizeof(void *));
33796 if (!_children) {
33797 p->error_indicator = 1;
33798 PyErr_NoMemory();
33799 p->level--;
33800 return NULL;
33801 }
33802 Py_ssize_t _children_capacity = 1;
33803 Py_ssize_t _n = 0;
33804 { // ',' star_target
33805 if (p->error_indicator) {
33806 p->level--;
33807 return NULL;
33808 }
33809 D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
33810 Token * _literal;
33811 expr_ty elem;
33812 while (
33813 (_literal = _PyPegen_expect_token(p, 12)) // token=','
33814 &&
33815 (elem = star_target_rule(p)) // star_target
33816 )
33817 {
33818 _res = elem;
33819 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
33820 p->error_indicator = 1;
33821 PyMem_Free(_children);
33822 p->level--;
33823 return NULL;
33824 }
33825 if (_n == _children_capacity) {
33826 _children_capacity *= 2;
33827 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33828 if (!_new_children) {
33829 PyMem_Free(_children);
33830 p->error_indicator = 1;
33831 PyErr_NoMemory();
33832 p->level--;
33833 return NULL;
33834 }
33835 _children = _new_children;
33836 }
33837 _children[_n++] = _res;
33838 _mark = p->mark;
33839 }
33840 p->mark = _mark;
33841 D(fprintf(stderr, "%*c%s _loop0_136[%d-%d]: %s failed!\n", p->level, ' ',
33842 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));
33843 }
33844 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33845 if (!_seq) {
33846 PyMem_Free(_children);
33847 p->error_indicator = 1;
33848 PyErr_NoMemory();
33849 p->level--;
33850 return NULL;
33851 }
33852 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33853 PyMem_Free(_children);
33854 p->level--;
33855 return _seq;
33856 }
33857
33858 // _gather_135: star_target _loop0_136
33859 static asdl_seq *
33860 _gather_135_rule(Parser *p)
33861 {
33862 if (p->level++ == MAXSTACK) {
33863 _Pypegen_stack_overflow(p);
33864 }
33865 if (p->error_indicator) {
33866 p->level--;
33867 return NULL;
33868 }
33869 asdl_seq * _res = NULL;
33870 int _mark = p->mark;
33871 { // star_target _loop0_136
33872 if (p->error_indicator) {
33873 p->level--;
33874 return NULL;
33875 }
33876 D(fprintf(stderr, "%*c> _gather_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_136"));
33877 expr_ty elem;
33878 asdl_seq * seq;
33879 if (
33880 (elem = star_target_rule(p)) // star_target
33881 &&
33882 (seq = _loop0_136_rule(p)) // _loop0_136
33883 )
33884 {
33885 D(fprintf(stderr, "%*c+ _gather_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_136"));
33886 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
33887 goto done;
33888 }
33889 p->mark = _mark;
33890 D(fprintf(stderr, "%*c%s _gather_135[%d-%d]: %s failed!\n", p->level, ' ',
33891 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_136"));
33892 }
33893 _res = NULL;
33894 done:
33895 p->level--;
33896 return _res;
33897 }
33898
33899 // _loop1_137: (',' star_target)
33900 static asdl_seq *
33901 _loop1_137_rule(Parser *p)
33902 {
33903 if (p->level++ == MAXSTACK) {
33904 _Pypegen_stack_overflow(p);
33905 }
33906 if (p->error_indicator) {
33907 p->level--;
33908 return NULL;
33909 }
33910 void *_res = NULL;
33911 int _mark = p->mark;
33912 void **_children = PyMem_Malloc(sizeof(void *));
33913 if (!_children) {
33914 p->error_indicator = 1;
33915 PyErr_NoMemory();
33916 p->level--;
33917 return NULL;
33918 }
33919 Py_ssize_t _children_capacity = 1;
33920 Py_ssize_t _n = 0;
33921 { // (',' star_target)
33922 if (p->error_indicator) {
33923 p->level--;
33924 return NULL;
33925 }
33926 D(fprintf(stderr, "%*c> _loop1_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
33927 void *_tmp_260_var;
33928 while (
33929 (_tmp_260_var = _tmp_260_rule(p)) // ',' star_target
33930 )
33931 {
33932 _res = _tmp_260_var;
33933 if (_n == _children_capacity) {
33934 _children_capacity *= 2;
33935 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
33936 if (!_new_children) {
33937 PyMem_Free(_children);
33938 p->error_indicator = 1;
33939 PyErr_NoMemory();
33940 p->level--;
33941 return NULL;
33942 }
33943 _children = _new_children;
33944 }
33945 _children[_n++] = _res;
33946 _mark = p->mark;
33947 }
33948 p->mark = _mark;
33949 D(fprintf(stderr, "%*c%s _loop1_137[%d-%d]: %s failed!\n", p->level, ' ',
33950 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)"));
33951 }
33952 if (_n == 0 || p->error_indicator) {
33953 PyMem_Free(_children);
33954 p->level--;
33955 return NULL;
33956 }
33957 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
33958 if (!_seq) {
33959 PyMem_Free(_children);
33960 p->error_indicator = 1;
33961 PyErr_NoMemory();
33962 p->level--;
33963 return NULL;
33964 }
33965 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
33966 PyMem_Free(_children);
33967 p->level--;
33968 return _seq;
33969 }
33970
33971 // _tmp_138: !'*' star_target
33972 static void *
33973 _tmp_138_rule(Parser *p)
33974 {
33975 if (p->level++ == MAXSTACK) {
33976 _Pypegen_stack_overflow(p);
33977 }
33978 if (p->error_indicator) {
33979 p->level--;
33980 return NULL;
33981 }
33982 void * _res = NULL;
33983 int _mark = p->mark;
33984 { // !'*' star_target
33985 if (p->error_indicator) {
33986 p->level--;
33987 return NULL;
33988 }
33989 D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target"));
33990 expr_ty star_target_var;
33991 if (
33992 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*'
33993 &&
33994 (star_target_var = star_target_rule(p)) // star_target
33995 )
33996 {
33997 D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target"));
33998 _res = star_target_var;
33999 goto done;
34000 }
34001 p->mark = _mark;
34002 D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ',
34003 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target"));
34004 }
34005 _res = NULL;
34006 done:
34007 p->level--;
34008 return _res;
34009 }
34010
34011 // _loop0_140: ',' del_target
34012 static asdl_seq *
34013 _loop0_140_rule(Parser *p)
34014 {
34015 if (p->level++ == MAXSTACK) {
34016 _Pypegen_stack_overflow(p);
34017 }
34018 if (p->error_indicator) {
34019 p->level--;
34020 return NULL;
34021 }
34022 void *_res = NULL;
34023 int _mark = p->mark;
34024 void **_children = PyMem_Malloc(sizeof(void *));
34025 if (!_children) {
34026 p->error_indicator = 1;
34027 PyErr_NoMemory();
34028 p->level--;
34029 return NULL;
34030 }
34031 Py_ssize_t _children_capacity = 1;
34032 Py_ssize_t _n = 0;
34033 { // ',' del_target
34034 if (p->error_indicator) {
34035 p->level--;
34036 return NULL;
34037 }
34038 D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target"));
34039 Token * _literal;
34040 expr_ty elem;
34041 while (
34042 (_literal = _PyPegen_expect_token(p, 12)) // token=','
34043 &&
34044 (elem = del_target_rule(p)) // del_target
34045 )
34046 {
34047 _res = elem;
34048 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
34049 p->error_indicator = 1;
34050 PyMem_Free(_children);
34051 p->level--;
34052 return NULL;
34053 }
34054 if (_n == _children_capacity) {
34055 _children_capacity *= 2;
34056 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34057 if (!_new_children) {
34058 PyMem_Free(_children);
34059 p->error_indicator = 1;
34060 PyErr_NoMemory();
34061 p->level--;
34062 return NULL;
34063 }
34064 _children = _new_children;
34065 }
34066 _children[_n++] = _res;
34067 _mark = p->mark;
34068 }
34069 p->mark = _mark;
34070 D(fprintf(stderr, "%*c%s _loop0_140[%d-%d]: %s failed!\n", p->level, ' ',
34071 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' del_target"));
34072 }
34073 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34074 if (!_seq) {
34075 PyMem_Free(_children);
34076 p->error_indicator = 1;
34077 PyErr_NoMemory();
34078 p->level--;
34079 return NULL;
34080 }
34081 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34082 PyMem_Free(_children);
34083 p->level--;
34084 return _seq;
34085 }
34086
34087 // _gather_139: del_target _loop0_140
34088 static asdl_seq *
34089 _gather_139_rule(Parser *p)
34090 {
34091 if (p->level++ == MAXSTACK) {
34092 _Pypegen_stack_overflow(p);
34093 }
34094 if (p->error_indicator) {
34095 p->level--;
34096 return NULL;
34097 }
34098 asdl_seq * _res = NULL;
34099 int _mark = p->mark;
34100 { // del_target _loop0_140
34101 if (p->error_indicator) {
34102 p->level--;
34103 return NULL;
34104 }
34105 D(fprintf(stderr, "%*c> _gather_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_140"));
34106 expr_ty elem;
34107 asdl_seq * seq;
34108 if (
34109 (elem = del_target_rule(p)) // del_target
34110 &&
34111 (seq = _loop0_140_rule(p)) // _loop0_140
34112 )
34113 {
34114 D(fprintf(stderr, "%*c+ _gather_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_140"));
34115 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
34116 goto done;
34117 }
34118 p->mark = _mark;
34119 D(fprintf(stderr, "%*c%s _gather_139[%d-%d]: %s failed!\n", p->level, ' ',
34120 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_140"));
34121 }
34122 _res = NULL;
34123 done:
34124 p->level--;
34125 return _res;
34126 }
34127
34128 // _loop0_142: ',' expression
34129 static asdl_seq *
34130 _loop0_142_rule(Parser *p)
34131 {
34132 if (p->level++ == MAXSTACK) {
34133 _Pypegen_stack_overflow(p);
34134 }
34135 if (p->error_indicator) {
34136 p->level--;
34137 return NULL;
34138 }
34139 void *_res = NULL;
34140 int _mark = p->mark;
34141 void **_children = PyMem_Malloc(sizeof(void *));
34142 if (!_children) {
34143 p->error_indicator = 1;
34144 PyErr_NoMemory();
34145 p->level--;
34146 return NULL;
34147 }
34148 Py_ssize_t _children_capacity = 1;
34149 Py_ssize_t _n = 0;
34150 { // ',' expression
34151 if (p->error_indicator) {
34152 p->level--;
34153 return NULL;
34154 }
34155 D(fprintf(stderr, "%*c> _loop0_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
34156 Token * _literal;
34157 expr_ty elem;
34158 while (
34159 (_literal = _PyPegen_expect_token(p, 12)) // token=','
34160 &&
34161 (elem = expression_rule(p)) // expression
34162 )
34163 {
34164 _res = elem;
34165 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
34166 p->error_indicator = 1;
34167 PyMem_Free(_children);
34168 p->level--;
34169 return NULL;
34170 }
34171 if (_n == _children_capacity) {
34172 _children_capacity *= 2;
34173 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34174 if (!_new_children) {
34175 PyMem_Free(_children);
34176 p->error_indicator = 1;
34177 PyErr_NoMemory();
34178 p->level--;
34179 return NULL;
34180 }
34181 _children = _new_children;
34182 }
34183 _children[_n++] = _res;
34184 _mark = p->mark;
34185 }
34186 p->mark = _mark;
34187 D(fprintf(stderr, "%*c%s _loop0_142[%d-%d]: %s failed!\n", p->level, ' ',
34188 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
34189 }
34190 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34191 if (!_seq) {
34192 PyMem_Free(_children);
34193 p->error_indicator = 1;
34194 PyErr_NoMemory();
34195 p->level--;
34196 return NULL;
34197 }
34198 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34199 PyMem_Free(_children);
34200 p->level--;
34201 return _seq;
34202 }
34203
34204 // _gather_141: expression _loop0_142
34205 static asdl_seq *
34206 _gather_141_rule(Parser *p)
34207 {
34208 if (p->level++ == MAXSTACK) {
34209 _Pypegen_stack_overflow(p);
34210 }
34211 if (p->error_indicator) {
34212 p->level--;
34213 return NULL;
34214 }
34215 asdl_seq * _res = NULL;
34216 int _mark = p->mark;
34217 { // expression _loop0_142
34218 if (p->error_indicator) {
34219 p->level--;
34220 return NULL;
34221 }
34222 D(fprintf(stderr, "%*c> _gather_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_142"));
34223 expr_ty elem;
34224 asdl_seq * seq;
34225 if (
34226 (elem = expression_rule(p)) // expression
34227 &&
34228 (seq = _loop0_142_rule(p)) // _loop0_142
34229 )
34230 {
34231 D(fprintf(stderr, "%*c+ _gather_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_142"));
34232 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
34233 goto done;
34234 }
34235 p->mark = _mark;
34236 D(fprintf(stderr, "%*c%s _gather_141[%d-%d]: %s failed!\n", p->level, ' ',
34237 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_142"));
34238 }
34239 _res = NULL;
34240 done:
34241 p->level--;
34242 return _res;
34243 }
34244
34245 // _loop0_144: ',' expression
34246 static asdl_seq *
34247 _loop0_144_rule(Parser *p)
34248 {
34249 if (p->level++ == MAXSTACK) {
34250 _Pypegen_stack_overflow(p);
34251 }
34252 if (p->error_indicator) {
34253 p->level--;
34254 return NULL;
34255 }
34256 void *_res = NULL;
34257 int _mark = p->mark;
34258 void **_children = PyMem_Malloc(sizeof(void *));
34259 if (!_children) {
34260 p->error_indicator = 1;
34261 PyErr_NoMemory();
34262 p->level--;
34263 return NULL;
34264 }
34265 Py_ssize_t _children_capacity = 1;
34266 Py_ssize_t _n = 0;
34267 { // ',' expression
34268 if (p->error_indicator) {
34269 p->level--;
34270 return NULL;
34271 }
34272 D(fprintf(stderr, "%*c> _loop0_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
34273 Token * _literal;
34274 expr_ty elem;
34275 while (
34276 (_literal = _PyPegen_expect_token(p, 12)) // token=','
34277 &&
34278 (elem = expression_rule(p)) // expression
34279 )
34280 {
34281 _res = elem;
34282 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
34283 p->error_indicator = 1;
34284 PyMem_Free(_children);
34285 p->level--;
34286 return NULL;
34287 }
34288 if (_n == _children_capacity) {
34289 _children_capacity *= 2;
34290 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34291 if (!_new_children) {
34292 PyMem_Free(_children);
34293 p->error_indicator = 1;
34294 PyErr_NoMemory();
34295 p->level--;
34296 return NULL;
34297 }
34298 _children = _new_children;
34299 }
34300 _children[_n++] = _res;
34301 _mark = p->mark;
34302 }
34303 p->mark = _mark;
34304 D(fprintf(stderr, "%*c%s _loop0_144[%d-%d]: %s failed!\n", p->level, ' ',
34305 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
34306 }
34307 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34308 if (!_seq) {
34309 PyMem_Free(_children);
34310 p->error_indicator = 1;
34311 PyErr_NoMemory();
34312 p->level--;
34313 return NULL;
34314 }
34315 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34316 PyMem_Free(_children);
34317 p->level--;
34318 return _seq;
34319 }
34320
34321 // _gather_143: expression _loop0_144
34322 static asdl_seq *
34323 _gather_143_rule(Parser *p)
34324 {
34325 if (p->level++ == MAXSTACK) {
34326 _Pypegen_stack_overflow(p);
34327 }
34328 if (p->error_indicator) {
34329 p->level--;
34330 return NULL;
34331 }
34332 asdl_seq * _res = NULL;
34333 int _mark = p->mark;
34334 { // expression _loop0_144
34335 if (p->error_indicator) {
34336 p->level--;
34337 return NULL;
34338 }
34339 D(fprintf(stderr, "%*c> _gather_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_144"));
34340 expr_ty elem;
34341 asdl_seq * seq;
34342 if (
34343 (elem = expression_rule(p)) // expression
34344 &&
34345 (seq = _loop0_144_rule(p)) // _loop0_144
34346 )
34347 {
34348 D(fprintf(stderr, "%*c+ _gather_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_144"));
34349 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
34350 goto done;
34351 }
34352 p->mark = _mark;
34353 D(fprintf(stderr, "%*c%s _gather_143[%d-%d]: %s failed!\n", p->level, ' ',
34354 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_144"));
34355 }
34356 _res = NULL;
34357 done:
34358 p->level--;
34359 return _res;
34360 }
34361
34362 // _loop0_146: ',' expression
34363 static asdl_seq *
34364 _loop0_146_rule(Parser *p)
34365 {
34366 if (p->level++ == MAXSTACK) {
34367 _Pypegen_stack_overflow(p);
34368 }
34369 if (p->error_indicator) {
34370 p->level--;
34371 return NULL;
34372 }
34373 void *_res = NULL;
34374 int _mark = p->mark;
34375 void **_children = PyMem_Malloc(sizeof(void *));
34376 if (!_children) {
34377 p->error_indicator = 1;
34378 PyErr_NoMemory();
34379 p->level--;
34380 return NULL;
34381 }
34382 Py_ssize_t _children_capacity = 1;
34383 Py_ssize_t _n = 0;
34384 { // ',' expression
34385 if (p->error_indicator) {
34386 p->level--;
34387 return NULL;
34388 }
34389 D(fprintf(stderr, "%*c> _loop0_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
34390 Token * _literal;
34391 expr_ty elem;
34392 while (
34393 (_literal = _PyPegen_expect_token(p, 12)) // token=','
34394 &&
34395 (elem = expression_rule(p)) // expression
34396 )
34397 {
34398 _res = elem;
34399 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
34400 p->error_indicator = 1;
34401 PyMem_Free(_children);
34402 p->level--;
34403 return NULL;
34404 }
34405 if (_n == _children_capacity) {
34406 _children_capacity *= 2;
34407 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34408 if (!_new_children) {
34409 PyMem_Free(_children);
34410 p->error_indicator = 1;
34411 PyErr_NoMemory();
34412 p->level--;
34413 return NULL;
34414 }
34415 _children = _new_children;
34416 }
34417 _children[_n++] = _res;
34418 _mark = p->mark;
34419 }
34420 p->mark = _mark;
34421 D(fprintf(stderr, "%*c%s _loop0_146[%d-%d]: %s failed!\n", p->level, ' ',
34422 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
34423 }
34424 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34425 if (!_seq) {
34426 PyMem_Free(_children);
34427 p->error_indicator = 1;
34428 PyErr_NoMemory();
34429 p->level--;
34430 return NULL;
34431 }
34432 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34433 PyMem_Free(_children);
34434 p->level--;
34435 return _seq;
34436 }
34437
34438 // _gather_145: expression _loop0_146
34439 static asdl_seq *
34440 _gather_145_rule(Parser *p)
34441 {
34442 if (p->level++ == MAXSTACK) {
34443 _Pypegen_stack_overflow(p);
34444 }
34445 if (p->error_indicator) {
34446 p->level--;
34447 return NULL;
34448 }
34449 asdl_seq * _res = NULL;
34450 int _mark = p->mark;
34451 { // expression _loop0_146
34452 if (p->error_indicator) {
34453 p->level--;
34454 return NULL;
34455 }
34456 D(fprintf(stderr, "%*c> _gather_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_146"));
34457 expr_ty elem;
34458 asdl_seq * seq;
34459 if (
34460 (elem = expression_rule(p)) // expression
34461 &&
34462 (seq = _loop0_146_rule(p)) // _loop0_146
34463 )
34464 {
34465 D(fprintf(stderr, "%*c+ _gather_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_146"));
34466 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
34467 goto done;
34468 }
34469 p->mark = _mark;
34470 D(fprintf(stderr, "%*c%s _gather_145[%d-%d]: %s failed!\n", p->level, ' ',
34471 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_146"));
34472 }
34473 _res = NULL;
34474 done:
34475 p->level--;
34476 return _res;
34477 }
34478
34479 // _loop0_148: ',' expression
34480 static asdl_seq *
34481 _loop0_148_rule(Parser *p)
34482 {
34483 if (p->level++ == MAXSTACK) {
34484 _Pypegen_stack_overflow(p);
34485 }
34486 if (p->error_indicator) {
34487 p->level--;
34488 return NULL;
34489 }
34490 void *_res = NULL;
34491 int _mark = p->mark;
34492 void **_children = PyMem_Malloc(sizeof(void *));
34493 if (!_children) {
34494 p->error_indicator = 1;
34495 PyErr_NoMemory();
34496 p->level--;
34497 return NULL;
34498 }
34499 Py_ssize_t _children_capacity = 1;
34500 Py_ssize_t _n = 0;
34501 { // ',' expression
34502 if (p->error_indicator) {
34503 p->level--;
34504 return NULL;
34505 }
34506 D(fprintf(stderr, "%*c> _loop0_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
34507 Token * _literal;
34508 expr_ty elem;
34509 while (
34510 (_literal = _PyPegen_expect_token(p, 12)) // token=','
34511 &&
34512 (elem = expression_rule(p)) // expression
34513 )
34514 {
34515 _res = elem;
34516 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
34517 p->error_indicator = 1;
34518 PyMem_Free(_children);
34519 p->level--;
34520 return NULL;
34521 }
34522 if (_n == _children_capacity) {
34523 _children_capacity *= 2;
34524 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34525 if (!_new_children) {
34526 PyMem_Free(_children);
34527 p->error_indicator = 1;
34528 PyErr_NoMemory();
34529 p->level--;
34530 return NULL;
34531 }
34532 _children = _new_children;
34533 }
34534 _children[_n++] = _res;
34535 _mark = p->mark;
34536 }
34537 p->mark = _mark;
34538 D(fprintf(stderr, "%*c%s _loop0_148[%d-%d]: %s failed!\n", p->level, ' ',
34539 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
34540 }
34541 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34542 if (!_seq) {
34543 PyMem_Free(_children);
34544 p->error_indicator = 1;
34545 PyErr_NoMemory();
34546 p->level--;
34547 return NULL;
34548 }
34549 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34550 PyMem_Free(_children);
34551 p->level--;
34552 return _seq;
34553 }
34554
34555 // _gather_147: expression _loop0_148
34556 static asdl_seq *
34557 _gather_147_rule(Parser *p)
34558 {
34559 if (p->level++ == MAXSTACK) {
34560 _Pypegen_stack_overflow(p);
34561 }
34562 if (p->error_indicator) {
34563 p->level--;
34564 return NULL;
34565 }
34566 asdl_seq * _res = NULL;
34567 int _mark = p->mark;
34568 { // expression _loop0_148
34569 if (p->error_indicator) {
34570 p->level--;
34571 return NULL;
34572 }
34573 D(fprintf(stderr, "%*c> _gather_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_148"));
34574 expr_ty elem;
34575 asdl_seq * seq;
34576 if (
34577 (elem = expression_rule(p)) // expression
34578 &&
34579 (seq = _loop0_148_rule(p)) // _loop0_148
34580 )
34581 {
34582 D(fprintf(stderr, "%*c+ _gather_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_148"));
34583 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
34584 goto done;
34585 }
34586 p->mark = _mark;
34587 D(fprintf(stderr, "%*c%s _gather_147[%d-%d]: %s failed!\n", p->level, ' ',
34588 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_148"));
34589 }
34590 _res = NULL;
34591 done:
34592 p->level--;
34593 return _res;
34594 }
34595
34596 // _tmp_149: NEWLINE INDENT
34597 static void *
34598 _tmp_149_rule(Parser *p)
34599 {
34600 if (p->level++ == MAXSTACK) {
34601 _Pypegen_stack_overflow(p);
34602 }
34603 if (p->error_indicator) {
34604 p->level--;
34605 return NULL;
34606 }
34607 void * _res = NULL;
34608 int _mark = p->mark;
34609 { // NEWLINE INDENT
34610 if (p->error_indicator) {
34611 p->level--;
34612 return NULL;
34613 }
34614 D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT"));
34615 Token * indent_var;
34616 Token * newline_var;
34617 if (
34618 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
34619 &&
34620 (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT'
34621 )
34622 {
34623 D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT"));
34624 _res = _PyPegen_dummy_name(p, newline_var, indent_var);
34625 goto done;
34626 }
34627 p->mark = _mark;
34628 D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ',
34629 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT"));
34630 }
34631 _res = NULL;
34632 done:
34633 p->level--;
34634 return _res;
34635 }
34636
34637 // _tmp_150:
34638 // | (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)
34639 // | kwargs
34640 static void *
34641 _tmp_150_rule(Parser *p)
34642 {
34643 if (p->level++ == MAXSTACK) {
34644 _Pypegen_stack_overflow(p);
34645 }
34646 if (p->error_indicator) {
34647 p->level--;
34648 return NULL;
34649 }
34650 void * _res = NULL;
34651 int _mark = p->mark;
34652 { // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)
34653 if (p->error_indicator) {
34654 p->level--;
34655 return NULL;
34656 }
34657 D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)"));
34658 void *_tmp_261_var;
34659 if (
34660 (_tmp_261_var = _tmp_261_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs
34661 )
34662 {
34663 D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)"));
34664 _res = _tmp_261_var;
34665 goto done;
34666 }
34667 p->mark = _mark;
34668 D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ',
34669 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)"));
34670 }
34671 { // kwargs
34672 if (p->error_indicator) {
34673 p->level--;
34674 return NULL;
34675 }
34676 D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs"));
34677 asdl_seq* kwargs_var;
34678 if (
34679 (kwargs_var = kwargs_rule(p)) // kwargs
34680 )
34681 {
34682 D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs"));
34683 _res = kwargs_var;
34684 goto done;
34685 }
34686 p->mark = _mark;
34687 D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ',
34688 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs"));
34689 }
34690 _res = NULL;
34691 done:
34692 p->level--;
34693 return _res;
34694 }
34695
34696 // _loop0_152: ',' (starred_expression !'=')
34697 static asdl_seq *
34698 _loop0_152_rule(Parser *p)
34699 {
34700 if (p->level++ == MAXSTACK) {
34701 _Pypegen_stack_overflow(p);
34702 }
34703 if (p->error_indicator) {
34704 p->level--;
34705 return NULL;
34706 }
34707 void *_res = NULL;
34708 int _mark = p->mark;
34709 void **_children = PyMem_Malloc(sizeof(void *));
34710 if (!_children) {
34711 p->error_indicator = 1;
34712 PyErr_NoMemory();
34713 p->level--;
34714 return NULL;
34715 }
34716 Py_ssize_t _children_capacity = 1;
34717 Py_ssize_t _n = 0;
34718 { // ',' (starred_expression !'=')
34719 if (p->error_indicator) {
34720 p->level--;
34721 return NULL;
34722 }
34723 D(fprintf(stderr, "%*c> _loop0_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')"));
34724 Token * _literal;
34725 void *elem;
34726 while (
34727 (_literal = _PyPegen_expect_token(p, 12)) // token=','
34728 &&
34729 (elem = _tmp_262_rule(p)) // starred_expression !'='
34730 )
34731 {
34732 _res = elem;
34733 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
34734 p->error_indicator = 1;
34735 PyMem_Free(_children);
34736 p->level--;
34737 return NULL;
34738 }
34739 if (_n == _children_capacity) {
34740 _children_capacity *= 2;
34741 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
34742 if (!_new_children) {
34743 PyMem_Free(_children);
34744 p->error_indicator = 1;
34745 PyErr_NoMemory();
34746 p->level--;
34747 return NULL;
34748 }
34749 _children = _new_children;
34750 }
34751 _children[_n++] = _res;
34752 _mark = p->mark;
34753 }
34754 p->mark = _mark;
34755 D(fprintf(stderr, "%*c%s _loop0_152[%d-%d]: %s failed!\n", p->level, ' ',
34756 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression !'=')"));
34757 }
34758 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
34759 if (!_seq) {
34760 PyMem_Free(_children);
34761 p->error_indicator = 1;
34762 PyErr_NoMemory();
34763 p->level--;
34764 return NULL;
34765 }
34766 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
34767 PyMem_Free(_children);
34768 p->level--;
34769 return _seq;
34770 }
34771
34772 // _gather_151: (starred_expression !'=') _loop0_152
34773 static asdl_seq *
34774 _gather_151_rule(Parser *p)
34775 {
34776 if (p->level++ == MAXSTACK) {
34777 _Pypegen_stack_overflow(p);
34778 }
34779 if (p->error_indicator) {
34780 p->level--;
34781 return NULL;
34782 }
34783 asdl_seq * _res = NULL;
34784 int _mark = p->mark;
34785 { // (starred_expression !'=') _loop0_152
34786 if (p->error_indicator) {
34787 p->level--;
34788 return NULL;
34789 }
34790 D(fprintf(stderr, "%*c> _gather_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_152"));
34791 void *elem;
34792 asdl_seq * seq;
34793 if (
34794 (elem = _tmp_262_rule(p)) // starred_expression !'='
34795 &&
34796 (seq = _loop0_152_rule(p)) // _loop0_152
34797 )
34798 {
34799 D(fprintf(stderr, "%*c+ _gather_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_152"));
34800 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
34801 goto done;
34802 }
34803 p->mark = _mark;
34804 D(fprintf(stderr, "%*c%s _gather_151[%d-%d]: %s failed!\n", p->level, ' ',
34805 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_152"));
34806 }
34807 _res = NULL;
34808 done:
34809 p->level--;
34810 return _res;
34811 }
34812
34813 // _tmp_153: args | expression for_if_clauses
34814 static void *
34815 _tmp_153_rule(Parser *p)
34816 {
34817 if (p->level++ == MAXSTACK) {
34818 _Pypegen_stack_overflow(p);
34819 }
34820 if (p->error_indicator) {
34821 p->level--;
34822 return NULL;
34823 }
34824 void * _res = NULL;
34825 int _mark = p->mark;
34826 { // args
34827 if (p->error_indicator) {
34828 p->level--;
34829 return NULL;
34830 }
34831 D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args"));
34832 expr_ty args_var;
34833 if (
34834 (args_var = args_rule(p)) // args
34835 )
34836 {
34837 D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args"));
34838 _res = args_var;
34839 goto done;
34840 }
34841 p->mark = _mark;
34842 D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ',
34843 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args"));
34844 }
34845 { // expression for_if_clauses
34846 if (p->error_indicator) {
34847 p->level--;
34848 return NULL;
34849 }
34850 D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses"));
34851 expr_ty expression_var;
34852 asdl_comprehension_seq* for_if_clauses_var;
34853 if (
34854 (expression_var = expression_rule(p)) // expression
34855 &&
34856 (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses
34857 )
34858 {
34859 D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses"));
34860 _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var);
34861 goto done;
34862 }
34863 p->mark = _mark;
34864 D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ',
34865 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses"));
34866 }
34867 _res = NULL;
34868 done:
34869 p->level--;
34870 return _res;
34871 }
34872
34873 // _tmp_154: args ','
34874 static void *
34875 _tmp_154_rule(Parser *p)
34876 {
34877 if (p->level++ == MAXSTACK) {
34878 _Pypegen_stack_overflow(p);
34879 }
34880 if (p->error_indicator) {
34881 p->level--;
34882 return NULL;
34883 }
34884 void * _res = NULL;
34885 int _mark = p->mark;
34886 { // args ','
34887 if (p->error_indicator) {
34888 p->level--;
34889 return NULL;
34890 }
34891 D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','"));
34892 Token * _literal;
34893 expr_ty args_var;
34894 if (
34895 (args_var = args_rule(p)) // args
34896 &&
34897 (_literal = _PyPegen_expect_token(p, 12)) // token=','
34898 )
34899 {
34900 D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','"));
34901 _res = _PyPegen_dummy_name(p, args_var, _literal);
34902 goto done;
34903 }
34904 p->mark = _mark;
34905 D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ',
34906 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','"));
34907 }
34908 _res = NULL;
34909 done:
34910 p->level--;
34911 return _res;
34912 }
34913
34914 // _tmp_155: ',' | ')'
34915 static void *
34916 _tmp_155_rule(Parser *p)
34917 {
34918 if (p->level++ == MAXSTACK) {
34919 _Pypegen_stack_overflow(p);
34920 }
34921 if (p->error_indicator) {
34922 p->level--;
34923 return NULL;
34924 }
34925 void * _res = NULL;
34926 int _mark = p->mark;
34927 { // ','
34928 if (p->error_indicator) {
34929 p->level--;
34930 return NULL;
34931 }
34932 D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
34933 Token * _literal;
34934 if (
34935 (_literal = _PyPegen_expect_token(p, 12)) // token=','
34936 )
34937 {
34938 D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
34939 _res = _literal;
34940 goto done;
34941 }
34942 p->mark = _mark;
34943 D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ',
34944 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
34945 }
34946 { // ')'
34947 if (p->error_indicator) {
34948 p->level--;
34949 return NULL;
34950 }
34951 D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
34952 Token * _literal;
34953 if (
34954 (_literal = _PyPegen_expect_token(p, 8)) // token=')'
34955 )
34956 {
34957 D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
34958 _res = _literal;
34959 goto done;
34960 }
34961 p->mark = _mark;
34962 D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ',
34963 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
34964 }
34965 _res = NULL;
34966 done:
34967 p->level--;
34968 return _res;
34969 }
34970
34971 // _tmp_156: 'True' | 'False' | 'None'
34972 static void *
34973 _tmp_156_rule(Parser *p)
34974 {
34975 if (p->level++ == MAXSTACK) {
34976 _Pypegen_stack_overflow(p);
34977 }
34978 if (p->error_indicator) {
34979 p->level--;
34980 return NULL;
34981 }
34982 void * _res = NULL;
34983 int _mark = p->mark;
34984 { // 'True'
34985 if (p->error_indicator) {
34986 p->level--;
34987 return NULL;
34988 }
34989 D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
34990 Token * _keyword;
34991 if (
34992 (_keyword = _PyPegen_expect_token(p, 613)) // token='True'
34993 )
34994 {
34995 D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
34996 _res = _keyword;
34997 goto done;
34998 }
34999 p->mark = _mark;
35000 D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ',
35001 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
35002 }
35003 { // 'False'
35004 if (p->error_indicator) {
35005 p->level--;
35006 return NULL;
35007 }
35008 D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
35009 Token * _keyword;
35010 if (
35011 (_keyword = _PyPegen_expect_token(p, 615)) // token='False'
35012 )
35013 {
35014 D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
35015 _res = _keyword;
35016 goto done;
35017 }
35018 p->mark = _mark;
35019 D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ',
35020 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));
35021 }
35022 { // 'None'
35023 if (p->error_indicator) {
35024 p->level--;
35025 return NULL;
35026 }
35027 D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
35028 Token * _keyword;
35029 if (
35030 (_keyword = _PyPegen_expect_token(p, 614)) // token='None'
35031 )
35032 {
35033 D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
35034 _res = _keyword;
35035 goto done;
35036 }
35037 p->mark = _mark;
35038 D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ',
35039 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
35040 }
35041 _res = NULL;
35042 done:
35043 p->level--;
35044 return _res;
35045 }
35046
35047 // _tmp_157: NAME '='
35048 static void *
35049 _tmp_157_rule(Parser *p)
35050 {
35051 if (p->level++ == MAXSTACK) {
35052 _Pypegen_stack_overflow(p);
35053 }
35054 if (p->error_indicator) {
35055 p->level--;
35056 return NULL;
35057 }
35058 void * _res = NULL;
35059 int _mark = p->mark;
35060 { // NAME '='
35061 if (p->error_indicator) {
35062 p->level--;
35063 return NULL;
35064 }
35065 D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='"));
35066 Token * _literal;
35067 expr_ty name_var;
35068 if (
35069 (name_var = _PyPegen_name_token(p)) // NAME
35070 &&
35071 (_literal = _PyPegen_expect_token(p, 22)) // token='='
35072 )
35073 {
35074 D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='"));
35075 _res = _PyPegen_dummy_name(p, name_var, _literal);
35076 goto done;
35077 }
35078 p->mark = _mark;
35079 D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ',
35080 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='"));
35081 }
35082 _res = NULL;
35083 done:
35084 p->level--;
35085 return _res;
35086 }
35087
35088 // _tmp_158: NAME STRING | SOFT_KEYWORD
35089 static void *
35090 _tmp_158_rule(Parser *p)
35091 {
35092 if (p->level++ == MAXSTACK) {
35093 _Pypegen_stack_overflow(p);
35094 }
35095 if (p->error_indicator) {
35096 p->level--;
35097 return NULL;
35098 }
35099 void * _res = NULL;
35100 int _mark = p->mark;
35101 { // NAME STRING
35102 if (p->error_indicator) {
35103 p->level--;
35104 return NULL;
35105 }
35106 D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING"));
35107 expr_ty name_var;
35108 expr_ty string_var;
35109 if (
35110 (name_var = _PyPegen_name_token(p)) // NAME
35111 &&
35112 (string_var = _PyPegen_string_token(p)) // STRING
35113 )
35114 {
35115 D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING"));
35116 _res = _PyPegen_dummy_name(p, name_var, string_var);
35117 goto done;
35118 }
35119 p->mark = _mark;
35120 D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ',
35121 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME STRING"));
35122 }
35123 { // SOFT_KEYWORD
35124 if (p->error_indicator) {
35125 p->level--;
35126 return NULL;
35127 }
35128 D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD"));
35129 expr_ty soft_keyword_var;
35130 if (
35131 (soft_keyword_var = _PyPegen_soft_keyword_token(p)) // SOFT_KEYWORD
35132 )
35133 {
35134 D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD"));
35135 _res = soft_keyword_var;
35136 goto done;
35137 }
35138 p->mark = _mark;
35139 D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ',
35140 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "SOFT_KEYWORD"));
35141 }
35142 _res = NULL;
35143 done:
35144 p->level--;
35145 return _res;
35146 }
35147
35148 // _tmp_159: 'else' | ':'
35149 static void *
35150 _tmp_159_rule(Parser *p)
35151 {
35152 if (p->level++ == MAXSTACK) {
35153 _Pypegen_stack_overflow(p);
35154 }
35155 if (p->error_indicator) {
35156 p->level--;
35157 return NULL;
35158 }
35159 void * _res = NULL;
35160 int _mark = p->mark;
35161 { // 'else'
35162 if (p->error_indicator) {
35163 p->level--;
35164 return NULL;
35165 }
35166 D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'"));
35167 Token * _keyword;
35168 if (
35169 (_keyword = _PyPegen_expect_token(p, 663)) // token='else'
35170 )
35171 {
35172 D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'"));
35173 _res = _keyword;
35174 goto done;
35175 }
35176 p->mark = _mark;
35177 D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ',
35178 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'"));
35179 }
35180 { // ':'
35181 if (p->error_indicator) {
35182 p->level--;
35183 return NULL;
35184 }
35185 D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
35186 Token * _literal;
35187 if (
35188 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
35189 )
35190 {
35191 D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
35192 _res = _literal;
35193 goto done;
35194 }
35195 p->mark = _mark;
35196 D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ',
35197 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
35198 }
35199 _res = NULL;
35200 done:
35201 p->level--;
35202 return _res;
35203 }
35204
35205 // _tmp_160: '=' | ':='
35206 static void *
35207 _tmp_160_rule(Parser *p)
35208 {
35209 if (p->level++ == MAXSTACK) {
35210 _Pypegen_stack_overflow(p);
35211 }
35212 if (p->error_indicator) {
35213 p->level--;
35214 return NULL;
35215 }
35216 void * _res = NULL;
35217 int _mark = p->mark;
35218 { // '='
35219 if (p->error_indicator) {
35220 p->level--;
35221 return NULL;
35222 }
35223 D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
35224 Token * _literal;
35225 if (
35226 (_literal = _PyPegen_expect_token(p, 22)) // token='='
35227 )
35228 {
35229 D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));
35230 _res = _literal;
35231 goto done;
35232 }
35233 p->mark = _mark;
35234 D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ',
35235 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
35236 }
35237 { // ':='
35238 if (p->error_indicator) {
35239 p->level--;
35240 return NULL;
35241 }
35242 D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='"));
35243 Token * _literal;
35244 if (
35245 (_literal = _PyPegen_expect_token(p, 53)) // token=':='
35246 )
35247 {
35248 D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='"));
35249 _res = _literal;
35250 goto done;
35251 }
35252 p->mark = _mark;
35253 D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ',
35254 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='"));
35255 }
35256 _res = NULL;
35257 done:
35258 p->level--;
35259 return _res;
35260 }
35261
35262 // _tmp_161: list | tuple | genexp | 'True' | 'None' | 'False'
35263 static void *
35264 _tmp_161_rule(Parser *p)
35265 {
35266 if (p->level++ == MAXSTACK) {
35267 _Pypegen_stack_overflow(p);
35268 }
35269 if (p->error_indicator) {
35270 p->level--;
35271 return NULL;
35272 }
35273 void * _res = NULL;
35274 int _mark = p->mark;
35275 { // list
35276 if (p->error_indicator) {
35277 p->level--;
35278 return NULL;
35279 }
35280 D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));
35281 expr_ty list_var;
35282 if (
35283 (list_var = list_rule(p)) // list
35284 )
35285 {
35286 D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
35287 _res = list_var;
35288 goto done;
35289 }
35290 p->mark = _mark;
35291 D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ',
35292 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));
35293 }
35294 { // tuple
35295 if (p->error_indicator) {
35296 p->level--;
35297 return NULL;
35298 }
35299 D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));
35300 expr_ty tuple_var;
35301 if (
35302 (tuple_var = tuple_rule(p)) // tuple
35303 )
35304 {
35305 D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
35306 _res = tuple_var;
35307 goto done;
35308 }
35309 p->mark = _mark;
35310 D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ',
35311 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));
35312 }
35313 { // genexp
35314 if (p->error_indicator) {
35315 p->level--;
35316 return NULL;
35317 }
35318 D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp"));
35319 expr_ty genexp_var;
35320 if (
35321 (genexp_var = genexp_rule(p)) // genexp
35322 )
35323 {
35324 D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"));
35325 _res = genexp_var;
35326 goto done;
35327 }
35328 p->mark = _mark;
35329 D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ',
35330 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp"));
35331 }
35332 { // 'True'
35333 if (p->error_indicator) {
35334 p->level--;
35335 return NULL;
35336 }
35337 D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
35338 Token * _keyword;
35339 if (
35340 (_keyword = _PyPegen_expect_token(p, 613)) // token='True'
35341 )
35342 {
35343 D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
35344 _res = _keyword;
35345 goto done;
35346 }
35347 p->mark = _mark;
35348 D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ',
35349 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
35350 }
35351 { // 'None'
35352 if (p->error_indicator) {
35353 p->level--;
35354 return NULL;
35355 }
35356 D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
35357 Token * _keyword;
35358 if (
35359 (_keyword = _PyPegen_expect_token(p, 614)) // token='None'
35360 )
35361 {
35362 D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
35363 _res = _keyword;
35364 goto done;
35365 }
35366 p->mark = _mark;
35367 D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ',
35368 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
35369 }
35370 { // 'False'
35371 if (p->error_indicator) {
35372 p->level--;
35373 return NULL;
35374 }
35375 D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
35376 Token * _keyword;
35377 if (
35378 (_keyword = _PyPegen_expect_token(p, 615)) // token='False'
35379 )
35380 {
35381 D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
35382 _res = _keyword;
35383 goto done;
35384 }
35385 p->mark = _mark;
35386 D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ',
35387 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));
35388 }
35389 _res = NULL;
35390 done:
35391 p->level--;
35392 return _res;
35393 }
35394
35395 // _tmp_162: '=' | ':='
35396 static void *
35397 _tmp_162_rule(Parser *p)
35398 {
35399 if (p->level++ == MAXSTACK) {
35400 _Pypegen_stack_overflow(p);
35401 }
35402 if (p->error_indicator) {
35403 p->level--;
35404 return NULL;
35405 }
35406 void * _res = NULL;
35407 int _mark = p->mark;
35408 { // '='
35409 if (p->error_indicator) {
35410 p->level--;
35411 return NULL;
35412 }
35413 D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
35414 Token * _literal;
35415 if (
35416 (_literal = _PyPegen_expect_token(p, 22)) // token='='
35417 )
35418 {
35419 D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));
35420 _res = _literal;
35421 goto done;
35422 }
35423 p->mark = _mark;
35424 D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ',
35425 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
35426 }
35427 { // ':='
35428 if (p->error_indicator) {
35429 p->level--;
35430 return NULL;
35431 }
35432 D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='"));
35433 Token * _literal;
35434 if (
35435 (_literal = _PyPegen_expect_token(p, 53)) // token=':='
35436 )
35437 {
35438 D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='"));
35439 _res = _literal;
35440 goto done;
35441 }
35442 p->mark = _mark;
35443 D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ',
35444 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='"));
35445 }
35446 _res = NULL;
35447 done:
35448 p->level--;
35449 return _res;
35450 }
35451
35452 // _loop0_163: star_named_expressions
35453 static asdl_seq *
35454 _loop0_163_rule(Parser *p)
35455 {
35456 if (p->level++ == MAXSTACK) {
35457 _Pypegen_stack_overflow(p);
35458 }
35459 if (p->error_indicator) {
35460 p->level--;
35461 return NULL;
35462 }
35463 void *_res = NULL;
35464 int _mark = p->mark;
35465 void **_children = PyMem_Malloc(sizeof(void *));
35466 if (!_children) {
35467 p->error_indicator = 1;
35468 PyErr_NoMemory();
35469 p->level--;
35470 return NULL;
35471 }
35472 Py_ssize_t _children_capacity = 1;
35473 Py_ssize_t _n = 0;
35474 { // star_named_expressions
35475 if (p->error_indicator) {
35476 p->level--;
35477 return NULL;
35478 }
35479 D(fprintf(stderr, "%*c> _loop0_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions"));
35480 asdl_expr_seq* star_named_expressions_var;
35481 while (
35482 (star_named_expressions_var = star_named_expressions_rule(p)) // star_named_expressions
35483 )
35484 {
35485 _res = star_named_expressions_var;
35486 if (_n == _children_capacity) {
35487 _children_capacity *= 2;
35488 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35489 if (!_new_children) {
35490 PyMem_Free(_children);
35491 p->error_indicator = 1;
35492 PyErr_NoMemory();
35493 p->level--;
35494 return NULL;
35495 }
35496 _children = _new_children;
35497 }
35498 _children[_n++] = _res;
35499 _mark = p->mark;
35500 }
35501 p->mark = _mark;
35502 D(fprintf(stderr, "%*c%s _loop0_163[%d-%d]: %s failed!\n", p->level, ' ',
35503 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expressions"));
35504 }
35505 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35506 if (!_seq) {
35507 PyMem_Free(_children);
35508 p->error_indicator = 1;
35509 PyErr_NoMemory();
35510 p->level--;
35511 return NULL;
35512 }
35513 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35514 PyMem_Free(_children);
35515 p->level--;
35516 return _seq;
35517 }
35518
35519 // _loop0_164: (star_targets '=')
35520 static asdl_seq *
35521 _loop0_164_rule(Parser *p)
35522 {
35523 if (p->level++ == MAXSTACK) {
35524 _Pypegen_stack_overflow(p);
35525 }
35526 if (p->error_indicator) {
35527 p->level--;
35528 return NULL;
35529 }
35530 void *_res = NULL;
35531 int _mark = p->mark;
35532 void **_children = PyMem_Malloc(sizeof(void *));
35533 if (!_children) {
35534 p->error_indicator = 1;
35535 PyErr_NoMemory();
35536 p->level--;
35537 return NULL;
35538 }
35539 Py_ssize_t _children_capacity = 1;
35540 Py_ssize_t _n = 0;
35541 { // (star_targets '=')
35542 if (p->error_indicator) {
35543 p->level--;
35544 return NULL;
35545 }
35546 D(fprintf(stderr, "%*c> _loop0_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
35547 void *_tmp_263_var;
35548 while (
35549 (_tmp_263_var = _tmp_263_rule(p)) // star_targets '='
35550 )
35551 {
35552 _res = _tmp_263_var;
35553 if (_n == _children_capacity) {
35554 _children_capacity *= 2;
35555 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35556 if (!_new_children) {
35557 PyMem_Free(_children);
35558 p->error_indicator = 1;
35559 PyErr_NoMemory();
35560 p->level--;
35561 return NULL;
35562 }
35563 _children = _new_children;
35564 }
35565 _children[_n++] = _res;
35566 _mark = p->mark;
35567 }
35568 p->mark = _mark;
35569 D(fprintf(stderr, "%*c%s _loop0_164[%d-%d]: %s failed!\n", p->level, ' ',
35570 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));
35571 }
35572 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35573 if (!_seq) {
35574 PyMem_Free(_children);
35575 p->error_indicator = 1;
35576 PyErr_NoMemory();
35577 p->level--;
35578 return NULL;
35579 }
35580 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35581 PyMem_Free(_children);
35582 p->level--;
35583 return _seq;
35584 }
35585
35586 // _loop0_165: (star_targets '=')
35587 static asdl_seq *
35588 _loop0_165_rule(Parser *p)
35589 {
35590 if (p->level++ == MAXSTACK) {
35591 _Pypegen_stack_overflow(p);
35592 }
35593 if (p->error_indicator) {
35594 p->level--;
35595 return NULL;
35596 }
35597 void *_res = NULL;
35598 int _mark = p->mark;
35599 void **_children = PyMem_Malloc(sizeof(void *));
35600 if (!_children) {
35601 p->error_indicator = 1;
35602 PyErr_NoMemory();
35603 p->level--;
35604 return NULL;
35605 }
35606 Py_ssize_t _children_capacity = 1;
35607 Py_ssize_t _n = 0;
35608 { // (star_targets '=')
35609 if (p->error_indicator) {
35610 p->level--;
35611 return NULL;
35612 }
35613 D(fprintf(stderr, "%*c> _loop0_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
35614 void *_tmp_264_var;
35615 while (
35616 (_tmp_264_var = _tmp_264_rule(p)) // star_targets '='
35617 )
35618 {
35619 _res = _tmp_264_var;
35620 if (_n == _children_capacity) {
35621 _children_capacity *= 2;
35622 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35623 if (!_new_children) {
35624 PyMem_Free(_children);
35625 p->error_indicator = 1;
35626 PyErr_NoMemory();
35627 p->level--;
35628 return NULL;
35629 }
35630 _children = _new_children;
35631 }
35632 _children[_n++] = _res;
35633 _mark = p->mark;
35634 }
35635 p->mark = _mark;
35636 D(fprintf(stderr, "%*c%s _loop0_165[%d-%d]: %s failed!\n", p->level, ' ',
35637 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));
35638 }
35639 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35640 if (!_seq) {
35641 PyMem_Free(_children);
35642 p->error_indicator = 1;
35643 PyErr_NoMemory();
35644 p->level--;
35645 return NULL;
35646 }
35647 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35648 PyMem_Free(_children);
35649 p->level--;
35650 return _seq;
35651 }
35652
35653 // _tmp_166: '[' | '(' | '{'
35654 static void *
35655 _tmp_166_rule(Parser *p)
35656 {
35657 if (p->level++ == MAXSTACK) {
35658 _Pypegen_stack_overflow(p);
35659 }
35660 if (p->error_indicator) {
35661 p->level--;
35662 return NULL;
35663 }
35664 void * _res = NULL;
35665 int _mark = p->mark;
35666 { // '['
35667 if (p->error_indicator) {
35668 p->level--;
35669 return NULL;
35670 }
35671 D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
35672 Token * _literal;
35673 if (
35674 (_literal = _PyPegen_expect_token(p, 9)) // token='['
35675 )
35676 {
35677 D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
35678 _res = _literal;
35679 goto done;
35680 }
35681 p->mark = _mark;
35682 D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ',
35683 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));
35684 }
35685 { // '('
35686 if (p->error_indicator) {
35687 p->level--;
35688 return NULL;
35689 }
35690 D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
35691 Token * _literal;
35692 if (
35693 (_literal = _PyPegen_expect_token(p, 7)) // token='('
35694 )
35695 {
35696 D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
35697 _res = _literal;
35698 goto done;
35699 }
35700 p->mark = _mark;
35701 D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ',
35702 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));
35703 }
35704 { // '{'
35705 if (p->error_indicator) {
35706 p->level--;
35707 return NULL;
35708 }
35709 D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));
35710 Token * _literal;
35711 if (
35712 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
35713 )
35714 {
35715 D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));
35716 _res = _literal;
35717 goto done;
35718 }
35719 p->mark = _mark;
35720 D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ',
35721 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'"));
35722 }
35723 _res = NULL;
35724 done:
35725 p->level--;
35726 return _res;
35727 }
35728
35729 // _tmp_167: '[' | '{'
35730 static void *
35731 _tmp_167_rule(Parser *p)
35732 {
35733 if (p->level++ == MAXSTACK) {
35734 _Pypegen_stack_overflow(p);
35735 }
35736 if (p->error_indicator) {
35737 p->level--;
35738 return NULL;
35739 }
35740 void * _res = NULL;
35741 int _mark = p->mark;
35742 { // '['
35743 if (p->error_indicator) {
35744 p->level--;
35745 return NULL;
35746 }
35747 D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
35748 Token * _literal;
35749 if (
35750 (_literal = _PyPegen_expect_token(p, 9)) // token='['
35751 )
35752 {
35753 D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
35754 _res = _literal;
35755 goto done;
35756 }
35757 p->mark = _mark;
35758 D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ',
35759 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));
35760 }
35761 { // '{'
35762 if (p->error_indicator) {
35763 p->level--;
35764 return NULL;
35765 }
35766 D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));
35767 Token * _literal;
35768 if (
35769 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
35770 )
35771 {
35772 D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));
35773 _res = _literal;
35774 goto done;
35775 }
35776 p->mark = _mark;
35777 D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ',
35778 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'"));
35779 }
35780 _res = NULL;
35781 done:
35782 p->level--;
35783 return _res;
35784 }
35785
35786 // _tmp_168: '[' | '{'
35787 static void *
35788 _tmp_168_rule(Parser *p)
35789 {
35790 if (p->level++ == MAXSTACK) {
35791 _Pypegen_stack_overflow(p);
35792 }
35793 if (p->error_indicator) {
35794 p->level--;
35795 return NULL;
35796 }
35797 void * _res = NULL;
35798 int _mark = p->mark;
35799 { // '['
35800 if (p->error_indicator) {
35801 p->level--;
35802 return NULL;
35803 }
35804 D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
35805 Token * _literal;
35806 if (
35807 (_literal = _PyPegen_expect_token(p, 9)) // token='['
35808 )
35809 {
35810 D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
35811 _res = _literal;
35812 goto done;
35813 }
35814 p->mark = _mark;
35815 D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ',
35816 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));
35817 }
35818 { // '{'
35819 if (p->error_indicator) {
35820 p->level--;
35821 return NULL;
35822 }
35823 D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));
35824 Token * _literal;
35825 if (
35826 (_literal = _PyPegen_expect_token(p, 25)) // token='{'
35827 )
35828 {
35829 D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));
35830 _res = _literal;
35831 goto done;
35832 }
35833 p->mark = _mark;
35834 D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ',
35835 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'"));
35836 }
35837 _res = NULL;
35838 done:
35839 p->level--;
35840 return _res;
35841 }
35842
35843 // _tmp_169: slash_no_default | slash_with_default
35844 static void *
35845 _tmp_169_rule(Parser *p)
35846 {
35847 if (p->level++ == MAXSTACK) {
35848 _Pypegen_stack_overflow(p);
35849 }
35850 if (p->error_indicator) {
35851 p->level--;
35852 return NULL;
35853 }
35854 void * _res = NULL;
35855 int _mark = p->mark;
35856 { // slash_no_default
35857 if (p->error_indicator) {
35858 p->level--;
35859 return NULL;
35860 }
35861 D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default"));
35862 asdl_arg_seq* slash_no_default_var;
35863 if (
35864 (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default
35865 )
35866 {
35867 D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default"));
35868 _res = slash_no_default_var;
35869 goto done;
35870 }
35871 p->mark = _mark;
35872 D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ',
35873 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default"));
35874 }
35875 { // slash_with_default
35876 if (p->error_indicator) {
35877 p->level--;
35878 return NULL;
35879 }
35880 D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
35881 SlashWithDefault* slash_with_default_var;
35882 if (
35883 (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default
35884 )
35885 {
35886 D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
35887 _res = slash_with_default_var;
35888 goto done;
35889 }
35890 p->mark = _mark;
35891 D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ',
35892 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default"));
35893 }
35894 _res = NULL;
35895 done:
35896 p->level--;
35897 return _res;
35898 }
35899
35900 // _loop0_170: param_maybe_default
35901 static asdl_seq *
35902 _loop0_170_rule(Parser *p)
35903 {
35904 if (p->level++ == MAXSTACK) {
35905 _Pypegen_stack_overflow(p);
35906 }
35907 if (p->error_indicator) {
35908 p->level--;
35909 return NULL;
35910 }
35911 void *_res = NULL;
35912 int _mark = p->mark;
35913 void **_children = PyMem_Malloc(sizeof(void *));
35914 if (!_children) {
35915 p->error_indicator = 1;
35916 PyErr_NoMemory();
35917 p->level--;
35918 return NULL;
35919 }
35920 Py_ssize_t _children_capacity = 1;
35921 Py_ssize_t _n = 0;
35922 { // param_maybe_default
35923 if (p->error_indicator) {
35924 p->level--;
35925 return NULL;
35926 }
35927 D(fprintf(stderr, "%*c> _loop0_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
35928 NameDefaultPair* param_maybe_default_var;
35929 while (
35930 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
35931 )
35932 {
35933 _res = param_maybe_default_var;
35934 if (_n == _children_capacity) {
35935 _children_capacity *= 2;
35936 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
35937 if (!_new_children) {
35938 PyMem_Free(_children);
35939 p->error_indicator = 1;
35940 PyErr_NoMemory();
35941 p->level--;
35942 return NULL;
35943 }
35944 _children = _new_children;
35945 }
35946 _children[_n++] = _res;
35947 _mark = p->mark;
35948 }
35949 p->mark = _mark;
35950 D(fprintf(stderr, "%*c%s _loop0_170[%d-%d]: %s failed!\n", p->level, ' ',
35951 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
35952 }
35953 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
35954 if (!_seq) {
35955 PyMem_Free(_children);
35956 p->error_indicator = 1;
35957 PyErr_NoMemory();
35958 p->level--;
35959 return NULL;
35960 }
35961 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
35962 PyMem_Free(_children);
35963 p->level--;
35964 return _seq;
35965 }
35966
35967 // _loop0_171: param_no_default
35968 static asdl_seq *
35969 _loop0_171_rule(Parser *p)
35970 {
35971 if (p->level++ == MAXSTACK) {
35972 _Pypegen_stack_overflow(p);
35973 }
35974 if (p->error_indicator) {
35975 p->level--;
35976 return NULL;
35977 }
35978 void *_res = NULL;
35979 int _mark = p->mark;
35980 void **_children = PyMem_Malloc(sizeof(void *));
35981 if (!_children) {
35982 p->error_indicator = 1;
35983 PyErr_NoMemory();
35984 p->level--;
35985 return NULL;
35986 }
35987 Py_ssize_t _children_capacity = 1;
35988 Py_ssize_t _n = 0;
35989 { // param_no_default
35990 if (p->error_indicator) {
35991 p->level--;
35992 return NULL;
35993 }
35994 D(fprintf(stderr, "%*c> _loop0_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
35995 arg_ty param_no_default_var;
35996 while (
35997 (param_no_default_var = param_no_default_rule(p)) // param_no_default
35998 )
35999 {
36000 _res = param_no_default_var;
36001 if (_n == _children_capacity) {
36002 _children_capacity *= 2;
36003 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36004 if (!_new_children) {
36005 PyMem_Free(_children);
36006 p->error_indicator = 1;
36007 PyErr_NoMemory();
36008 p->level--;
36009 return NULL;
36010 }
36011 _children = _new_children;
36012 }
36013 _children[_n++] = _res;
36014 _mark = p->mark;
36015 }
36016 p->mark = _mark;
36017 D(fprintf(stderr, "%*c%s _loop0_171[%d-%d]: %s failed!\n", p->level, ' ',
36018 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
36019 }
36020 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36021 if (!_seq) {
36022 PyMem_Free(_children);
36023 p->error_indicator = 1;
36024 PyErr_NoMemory();
36025 p->level--;
36026 return NULL;
36027 }
36028 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36029 PyMem_Free(_children);
36030 p->level--;
36031 return _seq;
36032 }
36033
36034 // _loop0_172: param_no_default
36035 static asdl_seq *
36036 _loop0_172_rule(Parser *p)
36037 {
36038 if (p->level++ == MAXSTACK) {
36039 _Pypegen_stack_overflow(p);
36040 }
36041 if (p->error_indicator) {
36042 p->level--;
36043 return NULL;
36044 }
36045 void *_res = NULL;
36046 int _mark = p->mark;
36047 void **_children = PyMem_Malloc(sizeof(void *));
36048 if (!_children) {
36049 p->error_indicator = 1;
36050 PyErr_NoMemory();
36051 p->level--;
36052 return NULL;
36053 }
36054 Py_ssize_t _children_capacity = 1;
36055 Py_ssize_t _n = 0;
36056 { // param_no_default
36057 if (p->error_indicator) {
36058 p->level--;
36059 return NULL;
36060 }
36061 D(fprintf(stderr, "%*c> _loop0_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
36062 arg_ty param_no_default_var;
36063 while (
36064 (param_no_default_var = param_no_default_rule(p)) // param_no_default
36065 )
36066 {
36067 _res = param_no_default_var;
36068 if (_n == _children_capacity) {
36069 _children_capacity *= 2;
36070 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36071 if (!_new_children) {
36072 PyMem_Free(_children);
36073 p->error_indicator = 1;
36074 PyErr_NoMemory();
36075 p->level--;
36076 return NULL;
36077 }
36078 _children = _new_children;
36079 }
36080 _children[_n++] = _res;
36081 _mark = p->mark;
36082 }
36083 p->mark = _mark;
36084 D(fprintf(stderr, "%*c%s _loop0_172[%d-%d]: %s failed!\n", p->level, ' ',
36085 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
36086 }
36087 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36088 if (!_seq) {
36089 PyMem_Free(_children);
36090 p->error_indicator = 1;
36091 PyErr_NoMemory();
36092 p->level--;
36093 return NULL;
36094 }
36095 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36096 PyMem_Free(_children);
36097 p->level--;
36098 return _seq;
36099 }
36100
36101 // _loop1_173: param_no_default
36102 static asdl_seq *
36103 _loop1_173_rule(Parser *p)
36104 {
36105 if (p->level++ == MAXSTACK) {
36106 _Pypegen_stack_overflow(p);
36107 }
36108 if (p->error_indicator) {
36109 p->level--;
36110 return NULL;
36111 }
36112 void *_res = NULL;
36113 int _mark = p->mark;
36114 void **_children = PyMem_Malloc(sizeof(void *));
36115 if (!_children) {
36116 p->error_indicator = 1;
36117 PyErr_NoMemory();
36118 p->level--;
36119 return NULL;
36120 }
36121 Py_ssize_t _children_capacity = 1;
36122 Py_ssize_t _n = 0;
36123 { // param_no_default
36124 if (p->error_indicator) {
36125 p->level--;
36126 return NULL;
36127 }
36128 D(fprintf(stderr, "%*c> _loop1_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
36129 arg_ty param_no_default_var;
36130 while (
36131 (param_no_default_var = param_no_default_rule(p)) // param_no_default
36132 )
36133 {
36134 _res = param_no_default_var;
36135 if (_n == _children_capacity) {
36136 _children_capacity *= 2;
36137 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36138 if (!_new_children) {
36139 PyMem_Free(_children);
36140 p->error_indicator = 1;
36141 PyErr_NoMemory();
36142 p->level--;
36143 return NULL;
36144 }
36145 _children = _new_children;
36146 }
36147 _children[_n++] = _res;
36148 _mark = p->mark;
36149 }
36150 p->mark = _mark;
36151 D(fprintf(stderr, "%*c%s _loop1_173[%d-%d]: %s failed!\n", p->level, ' ',
36152 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
36153 }
36154 if (_n == 0 || p->error_indicator) {
36155 PyMem_Free(_children);
36156 p->level--;
36157 return NULL;
36158 }
36159 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36160 if (!_seq) {
36161 PyMem_Free(_children);
36162 p->error_indicator = 1;
36163 PyErr_NoMemory();
36164 p->level--;
36165 return NULL;
36166 }
36167 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36168 PyMem_Free(_children);
36169 p->level--;
36170 return _seq;
36171 }
36172
36173 // _tmp_174: slash_no_default | slash_with_default
36174 static void *
36175 _tmp_174_rule(Parser *p)
36176 {
36177 if (p->level++ == MAXSTACK) {
36178 _Pypegen_stack_overflow(p);
36179 }
36180 if (p->error_indicator) {
36181 p->level--;
36182 return NULL;
36183 }
36184 void * _res = NULL;
36185 int _mark = p->mark;
36186 { // slash_no_default
36187 if (p->error_indicator) {
36188 p->level--;
36189 return NULL;
36190 }
36191 D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default"));
36192 asdl_arg_seq* slash_no_default_var;
36193 if (
36194 (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default
36195 )
36196 {
36197 D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default"));
36198 _res = slash_no_default_var;
36199 goto done;
36200 }
36201 p->mark = _mark;
36202 D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ',
36203 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default"));
36204 }
36205 { // slash_with_default
36206 if (p->error_indicator) {
36207 p->level--;
36208 return NULL;
36209 }
36210 D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
36211 SlashWithDefault* slash_with_default_var;
36212 if (
36213 (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default
36214 )
36215 {
36216 D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
36217 _res = slash_with_default_var;
36218 goto done;
36219 }
36220 p->mark = _mark;
36221 D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ',
36222 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default"));
36223 }
36224 _res = NULL;
36225 done:
36226 p->level--;
36227 return _res;
36228 }
36229
36230 // _loop0_175: param_maybe_default
36231 static asdl_seq *
36232 _loop0_175_rule(Parser *p)
36233 {
36234 if (p->level++ == MAXSTACK) {
36235 _Pypegen_stack_overflow(p);
36236 }
36237 if (p->error_indicator) {
36238 p->level--;
36239 return NULL;
36240 }
36241 void *_res = NULL;
36242 int _mark = p->mark;
36243 void **_children = PyMem_Malloc(sizeof(void *));
36244 if (!_children) {
36245 p->error_indicator = 1;
36246 PyErr_NoMemory();
36247 p->level--;
36248 return NULL;
36249 }
36250 Py_ssize_t _children_capacity = 1;
36251 Py_ssize_t _n = 0;
36252 { // param_maybe_default
36253 if (p->error_indicator) {
36254 p->level--;
36255 return NULL;
36256 }
36257 D(fprintf(stderr, "%*c> _loop0_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
36258 NameDefaultPair* param_maybe_default_var;
36259 while (
36260 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
36261 )
36262 {
36263 _res = param_maybe_default_var;
36264 if (_n == _children_capacity) {
36265 _children_capacity *= 2;
36266 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36267 if (!_new_children) {
36268 PyMem_Free(_children);
36269 p->error_indicator = 1;
36270 PyErr_NoMemory();
36271 p->level--;
36272 return NULL;
36273 }
36274 _children = _new_children;
36275 }
36276 _children[_n++] = _res;
36277 _mark = p->mark;
36278 }
36279 p->mark = _mark;
36280 D(fprintf(stderr, "%*c%s _loop0_175[%d-%d]: %s failed!\n", p->level, ' ',
36281 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
36282 }
36283 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36284 if (!_seq) {
36285 PyMem_Free(_children);
36286 p->error_indicator = 1;
36287 PyErr_NoMemory();
36288 p->level--;
36289 return NULL;
36290 }
36291 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36292 PyMem_Free(_children);
36293 p->level--;
36294 return _seq;
36295 }
36296
36297 // _tmp_176: ',' | param_no_default
36298 static void *
36299 _tmp_176_rule(Parser *p)
36300 {
36301 if (p->level++ == MAXSTACK) {
36302 _Pypegen_stack_overflow(p);
36303 }
36304 if (p->error_indicator) {
36305 p->level--;
36306 return NULL;
36307 }
36308 void * _res = NULL;
36309 int _mark = p->mark;
36310 { // ','
36311 if (p->error_indicator) {
36312 p->level--;
36313 return NULL;
36314 }
36315 D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
36316 Token * _literal;
36317 if (
36318 (_literal = _PyPegen_expect_token(p, 12)) // token=','
36319 )
36320 {
36321 D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
36322 _res = _literal;
36323 goto done;
36324 }
36325 p->mark = _mark;
36326 D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
36327 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
36328 }
36329 { // param_no_default
36330 if (p->error_indicator) {
36331 p->level--;
36332 return NULL;
36333 }
36334 D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
36335 arg_ty param_no_default_var;
36336 if (
36337 (param_no_default_var = param_no_default_rule(p)) // param_no_default
36338 )
36339 {
36340 D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default"));
36341 _res = param_no_default_var;
36342 goto done;
36343 }
36344 p->mark = _mark;
36345 D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
36346 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
36347 }
36348 _res = NULL;
36349 done:
36350 p->level--;
36351 return _res;
36352 }
36353
36354 // _loop0_177: param_maybe_default
36355 static asdl_seq *
36356 _loop0_177_rule(Parser *p)
36357 {
36358 if (p->level++ == MAXSTACK) {
36359 _Pypegen_stack_overflow(p);
36360 }
36361 if (p->error_indicator) {
36362 p->level--;
36363 return NULL;
36364 }
36365 void *_res = NULL;
36366 int _mark = p->mark;
36367 void **_children = PyMem_Malloc(sizeof(void *));
36368 if (!_children) {
36369 p->error_indicator = 1;
36370 PyErr_NoMemory();
36371 p->level--;
36372 return NULL;
36373 }
36374 Py_ssize_t _children_capacity = 1;
36375 Py_ssize_t _n = 0;
36376 { // param_maybe_default
36377 if (p->error_indicator) {
36378 p->level--;
36379 return NULL;
36380 }
36381 D(fprintf(stderr, "%*c> _loop0_177[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
36382 NameDefaultPair* param_maybe_default_var;
36383 while (
36384 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
36385 )
36386 {
36387 _res = param_maybe_default_var;
36388 if (_n == _children_capacity) {
36389 _children_capacity *= 2;
36390 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36391 if (!_new_children) {
36392 PyMem_Free(_children);
36393 p->error_indicator = 1;
36394 PyErr_NoMemory();
36395 p->level--;
36396 return NULL;
36397 }
36398 _children = _new_children;
36399 }
36400 _children[_n++] = _res;
36401 _mark = p->mark;
36402 }
36403 p->mark = _mark;
36404 D(fprintf(stderr, "%*c%s _loop0_177[%d-%d]: %s failed!\n", p->level, ' ',
36405 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
36406 }
36407 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36408 if (!_seq) {
36409 PyMem_Free(_children);
36410 p->error_indicator = 1;
36411 PyErr_NoMemory();
36412 p->level--;
36413 return NULL;
36414 }
36415 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36416 PyMem_Free(_children);
36417 p->level--;
36418 return _seq;
36419 }
36420
36421 // _loop1_178: param_maybe_default
36422 static asdl_seq *
36423 _loop1_178_rule(Parser *p)
36424 {
36425 if (p->level++ == MAXSTACK) {
36426 _Pypegen_stack_overflow(p);
36427 }
36428 if (p->error_indicator) {
36429 p->level--;
36430 return NULL;
36431 }
36432 void *_res = NULL;
36433 int _mark = p->mark;
36434 void **_children = PyMem_Malloc(sizeof(void *));
36435 if (!_children) {
36436 p->error_indicator = 1;
36437 PyErr_NoMemory();
36438 p->level--;
36439 return NULL;
36440 }
36441 Py_ssize_t _children_capacity = 1;
36442 Py_ssize_t _n = 0;
36443 { // param_maybe_default
36444 if (p->error_indicator) {
36445 p->level--;
36446 return NULL;
36447 }
36448 D(fprintf(stderr, "%*c> _loop1_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
36449 NameDefaultPair* param_maybe_default_var;
36450 while (
36451 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
36452 )
36453 {
36454 _res = param_maybe_default_var;
36455 if (_n == _children_capacity) {
36456 _children_capacity *= 2;
36457 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36458 if (!_new_children) {
36459 PyMem_Free(_children);
36460 p->error_indicator = 1;
36461 PyErr_NoMemory();
36462 p->level--;
36463 return NULL;
36464 }
36465 _children = _new_children;
36466 }
36467 _children[_n++] = _res;
36468 _mark = p->mark;
36469 }
36470 p->mark = _mark;
36471 D(fprintf(stderr, "%*c%s _loop1_178[%d-%d]: %s failed!\n", p->level, ' ',
36472 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
36473 }
36474 if (_n == 0 || p->error_indicator) {
36475 PyMem_Free(_children);
36476 p->level--;
36477 return NULL;
36478 }
36479 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36480 if (!_seq) {
36481 PyMem_Free(_children);
36482 p->error_indicator = 1;
36483 PyErr_NoMemory();
36484 p->level--;
36485 return NULL;
36486 }
36487 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36488 PyMem_Free(_children);
36489 p->level--;
36490 return _seq;
36491 }
36492
36493 // _tmp_179: ')' | ','
36494 static void *
36495 _tmp_179_rule(Parser *p)
36496 {
36497 if (p->level++ == MAXSTACK) {
36498 _Pypegen_stack_overflow(p);
36499 }
36500 if (p->error_indicator) {
36501 p->level--;
36502 return NULL;
36503 }
36504 void * _res = NULL;
36505 int _mark = p->mark;
36506 { // ')'
36507 if (p->error_indicator) {
36508 p->level--;
36509 return NULL;
36510 }
36511 D(fprintf(stderr, "%*c> _tmp_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
36512 Token * _literal;
36513 if (
36514 (_literal = _PyPegen_expect_token(p, 8)) // token=')'
36515 )
36516 {
36517 D(fprintf(stderr, "%*c+ _tmp_179[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
36518 _res = _literal;
36519 goto done;
36520 }
36521 p->mark = _mark;
36522 D(fprintf(stderr, "%*c%s _tmp_179[%d-%d]: %s failed!\n", p->level, ' ',
36523 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
36524 }
36525 { // ','
36526 if (p->error_indicator) {
36527 p->level--;
36528 return NULL;
36529 }
36530 D(fprintf(stderr, "%*c> _tmp_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
36531 Token * _literal;
36532 if (
36533 (_literal = _PyPegen_expect_token(p, 12)) // token=','
36534 )
36535 {
36536 D(fprintf(stderr, "%*c+ _tmp_179[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
36537 _res = _literal;
36538 goto done;
36539 }
36540 p->mark = _mark;
36541 D(fprintf(stderr, "%*c%s _tmp_179[%d-%d]: %s failed!\n", p->level, ' ',
36542 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
36543 }
36544 _res = NULL;
36545 done:
36546 p->level--;
36547 return _res;
36548 }
36549
36550 // _tmp_180: ')' | ',' (')' | '**')
36551 static void *
36552 _tmp_180_rule(Parser *p)
36553 {
36554 if (p->level++ == MAXSTACK) {
36555 _Pypegen_stack_overflow(p);
36556 }
36557 if (p->error_indicator) {
36558 p->level--;
36559 return NULL;
36560 }
36561 void * _res = NULL;
36562 int _mark = p->mark;
36563 { // ')'
36564 if (p->error_indicator) {
36565 p->level--;
36566 return NULL;
36567 }
36568 D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
36569 Token * _literal;
36570 if (
36571 (_literal = _PyPegen_expect_token(p, 8)) // token=')'
36572 )
36573 {
36574 D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
36575 _res = _literal;
36576 goto done;
36577 }
36578 p->mark = _mark;
36579 D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ',
36580 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
36581 }
36582 { // ',' (')' | '**')
36583 if (p->error_indicator) {
36584 p->level--;
36585 return NULL;
36586 }
36587 D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')"));
36588 Token * _literal;
36589 void *_tmp_265_var;
36590 if (
36591 (_literal = _PyPegen_expect_token(p, 12)) // token=','
36592 &&
36593 (_tmp_265_var = _tmp_265_rule(p)) // ')' | '**'
36594 )
36595 {
36596 D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')"));
36597 _res = _PyPegen_dummy_name(p, _literal, _tmp_265_var);
36598 goto done;
36599 }
36600 p->mark = _mark;
36601 D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ',
36602 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')"));
36603 }
36604 _res = NULL;
36605 done:
36606 p->level--;
36607 return _res;
36608 }
36609
36610 // _tmp_181: param_no_default | ','
36611 static void *
36612 _tmp_181_rule(Parser *p)
36613 {
36614 if (p->level++ == MAXSTACK) {
36615 _Pypegen_stack_overflow(p);
36616 }
36617 if (p->error_indicator) {
36618 p->level--;
36619 return NULL;
36620 }
36621 void * _res = NULL;
36622 int _mark = p->mark;
36623 { // param_no_default
36624 if (p->error_indicator) {
36625 p->level--;
36626 return NULL;
36627 }
36628 D(fprintf(stderr, "%*c> _tmp_181[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
36629 arg_ty param_no_default_var;
36630 if (
36631 (param_no_default_var = param_no_default_rule(p)) // param_no_default
36632 )
36633 {
36634 D(fprintf(stderr, "%*c+ _tmp_181[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default"));
36635 _res = param_no_default_var;
36636 goto done;
36637 }
36638 p->mark = _mark;
36639 D(fprintf(stderr, "%*c%s _tmp_181[%d-%d]: %s failed!\n", p->level, ' ',
36640 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
36641 }
36642 { // ','
36643 if (p->error_indicator) {
36644 p->level--;
36645 return NULL;
36646 }
36647 D(fprintf(stderr, "%*c> _tmp_181[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
36648 Token * _literal;
36649 if (
36650 (_literal = _PyPegen_expect_token(p, 12)) // token=','
36651 )
36652 {
36653 D(fprintf(stderr, "%*c+ _tmp_181[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
36654 _res = _literal;
36655 goto done;
36656 }
36657 p->mark = _mark;
36658 D(fprintf(stderr, "%*c%s _tmp_181[%d-%d]: %s failed!\n", p->level, ' ',
36659 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
36660 }
36661 _res = NULL;
36662 done:
36663 p->level--;
36664 return _res;
36665 }
36666
36667 // _loop0_182: param_maybe_default
36668 static asdl_seq *
36669 _loop0_182_rule(Parser *p)
36670 {
36671 if (p->level++ == MAXSTACK) {
36672 _Pypegen_stack_overflow(p);
36673 }
36674 if (p->error_indicator) {
36675 p->level--;
36676 return NULL;
36677 }
36678 void *_res = NULL;
36679 int _mark = p->mark;
36680 void **_children = PyMem_Malloc(sizeof(void *));
36681 if (!_children) {
36682 p->error_indicator = 1;
36683 PyErr_NoMemory();
36684 p->level--;
36685 return NULL;
36686 }
36687 Py_ssize_t _children_capacity = 1;
36688 Py_ssize_t _n = 0;
36689 { // param_maybe_default
36690 if (p->error_indicator) {
36691 p->level--;
36692 return NULL;
36693 }
36694 D(fprintf(stderr, "%*c> _loop0_182[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
36695 NameDefaultPair* param_maybe_default_var;
36696 while (
36697 (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default
36698 )
36699 {
36700 _res = param_maybe_default_var;
36701 if (_n == _children_capacity) {
36702 _children_capacity *= 2;
36703 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36704 if (!_new_children) {
36705 PyMem_Free(_children);
36706 p->error_indicator = 1;
36707 PyErr_NoMemory();
36708 p->level--;
36709 return NULL;
36710 }
36711 _children = _new_children;
36712 }
36713 _children[_n++] = _res;
36714 _mark = p->mark;
36715 }
36716 p->mark = _mark;
36717 D(fprintf(stderr, "%*c%s _loop0_182[%d-%d]: %s failed!\n", p->level, ' ',
36718 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
36719 }
36720 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36721 if (!_seq) {
36722 PyMem_Free(_children);
36723 p->error_indicator = 1;
36724 PyErr_NoMemory();
36725 p->level--;
36726 return NULL;
36727 }
36728 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36729 PyMem_Free(_children);
36730 p->level--;
36731 return _seq;
36732 }
36733
36734 // _tmp_183: param_no_default | ','
36735 static void *
36736 _tmp_183_rule(Parser *p)
36737 {
36738 if (p->level++ == MAXSTACK) {
36739 _Pypegen_stack_overflow(p);
36740 }
36741 if (p->error_indicator) {
36742 p->level--;
36743 return NULL;
36744 }
36745 void * _res = NULL;
36746 int _mark = p->mark;
36747 { // param_no_default
36748 if (p->error_indicator) {
36749 p->level--;
36750 return NULL;
36751 }
36752 D(fprintf(stderr, "%*c> _tmp_183[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
36753 arg_ty param_no_default_var;
36754 if (
36755 (param_no_default_var = param_no_default_rule(p)) // param_no_default
36756 )
36757 {
36758 D(fprintf(stderr, "%*c+ _tmp_183[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default"));
36759 _res = param_no_default_var;
36760 goto done;
36761 }
36762 p->mark = _mark;
36763 D(fprintf(stderr, "%*c%s _tmp_183[%d-%d]: %s failed!\n", p->level, ' ',
36764 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
36765 }
36766 { // ','
36767 if (p->error_indicator) {
36768 p->level--;
36769 return NULL;
36770 }
36771 D(fprintf(stderr, "%*c> _tmp_183[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
36772 Token * _literal;
36773 if (
36774 (_literal = _PyPegen_expect_token(p, 12)) // token=','
36775 )
36776 {
36777 D(fprintf(stderr, "%*c+ _tmp_183[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
36778 _res = _literal;
36779 goto done;
36780 }
36781 p->mark = _mark;
36782 D(fprintf(stderr, "%*c%s _tmp_183[%d-%d]: %s failed!\n", p->level, ' ',
36783 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
36784 }
36785 _res = NULL;
36786 done:
36787 p->level--;
36788 return _res;
36789 }
36790
36791 // _tmp_184: '*' | '**' | '/'
36792 static void *
36793 _tmp_184_rule(Parser *p)
36794 {
36795 if (p->level++ == MAXSTACK) {
36796 _Pypegen_stack_overflow(p);
36797 }
36798 if (p->error_indicator) {
36799 p->level--;
36800 return NULL;
36801 }
36802 void * _res = NULL;
36803 int _mark = p->mark;
36804 { // '*'
36805 if (p->error_indicator) {
36806 p->level--;
36807 return NULL;
36808 }
36809 D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
36810 Token * _literal;
36811 if (
36812 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
36813 )
36814 {
36815 D(fprintf(stderr, "%*c+ _tmp_184[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'"));
36816 _res = _literal;
36817 goto done;
36818 }
36819 p->mark = _mark;
36820 D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ',
36821 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));
36822 }
36823 { // '**'
36824 if (p->error_indicator) {
36825 p->level--;
36826 return NULL;
36827 }
36828 D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
36829 Token * _literal;
36830 if (
36831 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
36832 )
36833 {
36834 D(fprintf(stderr, "%*c+ _tmp_184[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'"));
36835 _res = _literal;
36836 goto done;
36837 }
36838 p->mark = _mark;
36839 D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ',
36840 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
36841 }
36842 { // '/'
36843 if (p->error_indicator) {
36844 p->level--;
36845 return NULL;
36846 }
36847 D(fprintf(stderr, "%*c> _tmp_184[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'"));
36848 Token * _literal;
36849 if (
36850 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
36851 )
36852 {
36853 D(fprintf(stderr, "%*c+ _tmp_184[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'"));
36854 _res = _literal;
36855 goto done;
36856 }
36857 p->mark = _mark;
36858 D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ',
36859 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'"));
36860 }
36861 _res = NULL;
36862 done:
36863 p->level--;
36864 return _res;
36865 }
36866
36867 // _loop1_185: param_with_default
36868 static asdl_seq *
36869 _loop1_185_rule(Parser *p)
36870 {
36871 if (p->level++ == MAXSTACK) {
36872 _Pypegen_stack_overflow(p);
36873 }
36874 if (p->error_indicator) {
36875 p->level--;
36876 return NULL;
36877 }
36878 void *_res = NULL;
36879 int _mark = p->mark;
36880 void **_children = PyMem_Malloc(sizeof(void *));
36881 if (!_children) {
36882 p->error_indicator = 1;
36883 PyErr_NoMemory();
36884 p->level--;
36885 return NULL;
36886 }
36887 Py_ssize_t _children_capacity = 1;
36888 Py_ssize_t _n = 0;
36889 { // param_with_default
36890 if (p->error_indicator) {
36891 p->level--;
36892 return NULL;
36893 }
36894 D(fprintf(stderr, "%*c> _loop1_185[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
36895 NameDefaultPair* param_with_default_var;
36896 while (
36897 (param_with_default_var = param_with_default_rule(p)) // param_with_default
36898 )
36899 {
36900 _res = param_with_default_var;
36901 if (_n == _children_capacity) {
36902 _children_capacity *= 2;
36903 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
36904 if (!_new_children) {
36905 PyMem_Free(_children);
36906 p->error_indicator = 1;
36907 PyErr_NoMemory();
36908 p->level--;
36909 return NULL;
36910 }
36911 _children = _new_children;
36912 }
36913 _children[_n++] = _res;
36914 _mark = p->mark;
36915 }
36916 p->mark = _mark;
36917 D(fprintf(stderr, "%*c%s _loop1_185[%d-%d]: %s failed!\n", p->level, ' ',
36918 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
36919 }
36920 if (_n == 0 || p->error_indicator) {
36921 PyMem_Free(_children);
36922 p->level--;
36923 return NULL;
36924 }
36925 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
36926 if (!_seq) {
36927 PyMem_Free(_children);
36928 p->error_indicator = 1;
36929 PyErr_NoMemory();
36930 p->level--;
36931 return NULL;
36932 }
36933 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
36934 PyMem_Free(_children);
36935 p->level--;
36936 return _seq;
36937 }
36938
36939 // _tmp_186: lambda_slash_no_default | lambda_slash_with_default
36940 static void *
36941 _tmp_186_rule(Parser *p)
36942 {
36943 if (p->level++ == MAXSTACK) {
36944 _Pypegen_stack_overflow(p);
36945 }
36946 if (p->error_indicator) {
36947 p->level--;
36948 return NULL;
36949 }
36950 void * _res = NULL;
36951 int _mark = p->mark;
36952 { // lambda_slash_no_default
36953 if (p->error_indicator) {
36954 p->level--;
36955 return NULL;
36956 }
36957 D(fprintf(stderr, "%*c> _tmp_186[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default"));
36958 asdl_arg_seq* lambda_slash_no_default_var;
36959 if (
36960 (lambda_slash_no_default_var = lambda_slash_no_default_rule(p)) // lambda_slash_no_default
36961 )
36962 {
36963 D(fprintf(stderr, "%*c+ _tmp_186[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default"));
36964 _res = lambda_slash_no_default_var;
36965 goto done;
36966 }
36967 p->mark = _mark;
36968 D(fprintf(stderr, "%*c%s _tmp_186[%d-%d]: %s failed!\n", p->level, ' ',
36969 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default"));
36970 }
36971 { // lambda_slash_with_default
36972 if (p->error_indicator) {
36973 p->level--;
36974 return NULL;
36975 }
36976 D(fprintf(stderr, "%*c> _tmp_186[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
36977 SlashWithDefault* lambda_slash_with_default_var;
36978 if (
36979 (lambda_slash_with_default_var = lambda_slash_with_default_rule(p)) // lambda_slash_with_default
36980 )
36981 {
36982 D(fprintf(stderr, "%*c+ _tmp_186[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
36983 _res = lambda_slash_with_default_var;
36984 goto done;
36985 }
36986 p->mark = _mark;
36987 D(fprintf(stderr, "%*c%s _tmp_186[%d-%d]: %s failed!\n", p->level, ' ',
36988 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default"));
36989 }
36990 _res = NULL;
36991 done:
36992 p->level--;
36993 return _res;
36994 }
36995
36996 // _loop0_187: lambda_param_maybe_default
36997 static asdl_seq *
36998 _loop0_187_rule(Parser *p)
36999 {
37000 if (p->level++ == MAXSTACK) {
37001 _Pypegen_stack_overflow(p);
37002 }
37003 if (p->error_indicator) {
37004 p->level--;
37005 return NULL;
37006 }
37007 void *_res = NULL;
37008 int _mark = p->mark;
37009 void **_children = PyMem_Malloc(sizeof(void *));
37010 if (!_children) {
37011 p->error_indicator = 1;
37012 PyErr_NoMemory();
37013 p->level--;
37014 return NULL;
37015 }
37016 Py_ssize_t _children_capacity = 1;
37017 Py_ssize_t _n = 0;
37018 { // lambda_param_maybe_default
37019 if (p->error_indicator) {
37020 p->level--;
37021 return NULL;
37022 }
37023 D(fprintf(stderr, "%*c> _loop0_187[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
37024 NameDefaultPair* lambda_param_maybe_default_var;
37025 while (
37026 (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
37027 )
37028 {
37029 _res = lambda_param_maybe_default_var;
37030 if (_n == _children_capacity) {
37031 _children_capacity *= 2;
37032 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37033 if (!_new_children) {
37034 PyMem_Free(_children);
37035 p->error_indicator = 1;
37036 PyErr_NoMemory();
37037 p->level--;
37038 return NULL;
37039 }
37040 _children = _new_children;
37041 }
37042 _children[_n++] = _res;
37043 _mark = p->mark;
37044 }
37045 p->mark = _mark;
37046 D(fprintf(stderr, "%*c%s _loop0_187[%d-%d]: %s failed!\n", p->level, ' ',
37047 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
37048 }
37049 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37050 if (!_seq) {
37051 PyMem_Free(_children);
37052 p->error_indicator = 1;
37053 PyErr_NoMemory();
37054 p->level--;
37055 return NULL;
37056 }
37057 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37058 PyMem_Free(_children);
37059 p->level--;
37060 return _seq;
37061 }
37062
37063 // _loop0_188: lambda_param_no_default
37064 static asdl_seq *
37065 _loop0_188_rule(Parser *p)
37066 {
37067 if (p->level++ == MAXSTACK) {
37068 _Pypegen_stack_overflow(p);
37069 }
37070 if (p->error_indicator) {
37071 p->level--;
37072 return NULL;
37073 }
37074 void *_res = NULL;
37075 int _mark = p->mark;
37076 void **_children = PyMem_Malloc(sizeof(void *));
37077 if (!_children) {
37078 p->error_indicator = 1;
37079 PyErr_NoMemory();
37080 p->level--;
37081 return NULL;
37082 }
37083 Py_ssize_t _children_capacity = 1;
37084 Py_ssize_t _n = 0;
37085 { // lambda_param_no_default
37086 if (p->error_indicator) {
37087 p->level--;
37088 return NULL;
37089 }
37090 D(fprintf(stderr, "%*c> _loop0_188[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
37091 arg_ty lambda_param_no_default_var;
37092 while (
37093 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
37094 )
37095 {
37096 _res = lambda_param_no_default_var;
37097 if (_n == _children_capacity) {
37098 _children_capacity *= 2;
37099 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37100 if (!_new_children) {
37101 PyMem_Free(_children);
37102 p->error_indicator = 1;
37103 PyErr_NoMemory();
37104 p->level--;
37105 return NULL;
37106 }
37107 _children = _new_children;
37108 }
37109 _children[_n++] = _res;
37110 _mark = p->mark;
37111 }
37112 p->mark = _mark;
37113 D(fprintf(stderr, "%*c%s _loop0_188[%d-%d]: %s failed!\n", p->level, ' ',
37114 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
37115 }
37116 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37117 if (!_seq) {
37118 PyMem_Free(_children);
37119 p->error_indicator = 1;
37120 PyErr_NoMemory();
37121 p->level--;
37122 return NULL;
37123 }
37124 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37125 PyMem_Free(_children);
37126 p->level--;
37127 return _seq;
37128 }
37129
37130 // _loop0_189: lambda_param_no_default
37131 static asdl_seq *
37132 _loop0_189_rule(Parser *p)
37133 {
37134 if (p->level++ == MAXSTACK) {
37135 _Pypegen_stack_overflow(p);
37136 }
37137 if (p->error_indicator) {
37138 p->level--;
37139 return NULL;
37140 }
37141 void *_res = NULL;
37142 int _mark = p->mark;
37143 void **_children = PyMem_Malloc(sizeof(void *));
37144 if (!_children) {
37145 p->error_indicator = 1;
37146 PyErr_NoMemory();
37147 p->level--;
37148 return NULL;
37149 }
37150 Py_ssize_t _children_capacity = 1;
37151 Py_ssize_t _n = 0;
37152 { // lambda_param_no_default
37153 if (p->error_indicator) {
37154 p->level--;
37155 return NULL;
37156 }
37157 D(fprintf(stderr, "%*c> _loop0_189[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
37158 arg_ty lambda_param_no_default_var;
37159 while (
37160 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
37161 )
37162 {
37163 _res = lambda_param_no_default_var;
37164 if (_n == _children_capacity) {
37165 _children_capacity *= 2;
37166 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37167 if (!_new_children) {
37168 PyMem_Free(_children);
37169 p->error_indicator = 1;
37170 PyErr_NoMemory();
37171 p->level--;
37172 return NULL;
37173 }
37174 _children = _new_children;
37175 }
37176 _children[_n++] = _res;
37177 _mark = p->mark;
37178 }
37179 p->mark = _mark;
37180 D(fprintf(stderr, "%*c%s _loop0_189[%d-%d]: %s failed!\n", p->level, ' ',
37181 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
37182 }
37183 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37184 if (!_seq) {
37185 PyMem_Free(_children);
37186 p->error_indicator = 1;
37187 PyErr_NoMemory();
37188 p->level--;
37189 return NULL;
37190 }
37191 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37192 PyMem_Free(_children);
37193 p->level--;
37194 return _seq;
37195 }
37196
37197 // _loop0_191: ',' lambda_param
37198 static asdl_seq *
37199 _loop0_191_rule(Parser *p)
37200 {
37201 if (p->level++ == MAXSTACK) {
37202 _Pypegen_stack_overflow(p);
37203 }
37204 if (p->error_indicator) {
37205 p->level--;
37206 return NULL;
37207 }
37208 void *_res = NULL;
37209 int _mark = p->mark;
37210 void **_children = PyMem_Malloc(sizeof(void *));
37211 if (!_children) {
37212 p->error_indicator = 1;
37213 PyErr_NoMemory();
37214 p->level--;
37215 return NULL;
37216 }
37217 Py_ssize_t _children_capacity = 1;
37218 Py_ssize_t _n = 0;
37219 { // ',' lambda_param
37220 if (p->error_indicator) {
37221 p->level--;
37222 return NULL;
37223 }
37224 D(fprintf(stderr, "%*c> _loop0_191[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param"));
37225 Token * _literal;
37226 arg_ty elem;
37227 while (
37228 (_literal = _PyPegen_expect_token(p, 12)) // token=','
37229 &&
37230 (elem = lambda_param_rule(p)) // lambda_param
37231 )
37232 {
37233 _res = elem;
37234 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
37235 p->error_indicator = 1;
37236 PyMem_Free(_children);
37237 p->level--;
37238 return NULL;
37239 }
37240 if (_n == _children_capacity) {
37241 _children_capacity *= 2;
37242 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37243 if (!_new_children) {
37244 PyMem_Free(_children);
37245 p->error_indicator = 1;
37246 PyErr_NoMemory();
37247 p->level--;
37248 return NULL;
37249 }
37250 _children = _new_children;
37251 }
37252 _children[_n++] = _res;
37253 _mark = p->mark;
37254 }
37255 p->mark = _mark;
37256 D(fprintf(stderr, "%*c%s _loop0_191[%d-%d]: %s failed!\n", p->level, ' ',
37257 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' lambda_param"));
37258 }
37259 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37260 if (!_seq) {
37261 PyMem_Free(_children);
37262 p->error_indicator = 1;
37263 PyErr_NoMemory();
37264 p->level--;
37265 return NULL;
37266 }
37267 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37268 PyMem_Free(_children);
37269 p->level--;
37270 return _seq;
37271 }
37272
37273 // _gather_190: lambda_param _loop0_191
37274 static asdl_seq *
37275 _gather_190_rule(Parser *p)
37276 {
37277 if (p->level++ == MAXSTACK) {
37278 _Pypegen_stack_overflow(p);
37279 }
37280 if (p->error_indicator) {
37281 p->level--;
37282 return NULL;
37283 }
37284 asdl_seq * _res = NULL;
37285 int _mark = p->mark;
37286 { // lambda_param _loop0_191
37287 if (p->error_indicator) {
37288 p->level--;
37289 return NULL;
37290 }
37291 D(fprintf(stderr, "%*c> _gather_190[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_191"));
37292 arg_ty elem;
37293 asdl_seq * seq;
37294 if (
37295 (elem = lambda_param_rule(p)) // lambda_param
37296 &&
37297 (seq = _loop0_191_rule(p)) // _loop0_191
37298 )
37299 {
37300 D(fprintf(stderr, "%*c+ _gather_190[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_191"));
37301 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
37302 goto done;
37303 }
37304 p->mark = _mark;
37305 D(fprintf(stderr, "%*c%s _gather_190[%d-%d]: %s failed!\n", p->level, ' ',
37306 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_191"));
37307 }
37308 _res = NULL;
37309 done:
37310 p->level--;
37311 return _res;
37312 }
37313
37314 // _tmp_192: lambda_slash_no_default | lambda_slash_with_default
37315 static void *
37316 _tmp_192_rule(Parser *p)
37317 {
37318 if (p->level++ == MAXSTACK) {
37319 _Pypegen_stack_overflow(p);
37320 }
37321 if (p->error_indicator) {
37322 p->level--;
37323 return NULL;
37324 }
37325 void * _res = NULL;
37326 int _mark = p->mark;
37327 { // lambda_slash_no_default
37328 if (p->error_indicator) {
37329 p->level--;
37330 return NULL;
37331 }
37332 D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default"));
37333 asdl_arg_seq* lambda_slash_no_default_var;
37334 if (
37335 (lambda_slash_no_default_var = lambda_slash_no_default_rule(p)) // lambda_slash_no_default
37336 )
37337 {
37338 D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default"));
37339 _res = lambda_slash_no_default_var;
37340 goto done;
37341 }
37342 p->mark = _mark;
37343 D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ',
37344 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default"));
37345 }
37346 { // lambda_slash_with_default
37347 if (p->error_indicator) {
37348 p->level--;
37349 return NULL;
37350 }
37351 D(fprintf(stderr, "%*c> _tmp_192[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
37352 SlashWithDefault* lambda_slash_with_default_var;
37353 if (
37354 (lambda_slash_with_default_var = lambda_slash_with_default_rule(p)) // lambda_slash_with_default
37355 )
37356 {
37357 D(fprintf(stderr, "%*c+ _tmp_192[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
37358 _res = lambda_slash_with_default_var;
37359 goto done;
37360 }
37361 p->mark = _mark;
37362 D(fprintf(stderr, "%*c%s _tmp_192[%d-%d]: %s failed!\n", p->level, ' ',
37363 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default"));
37364 }
37365 _res = NULL;
37366 done:
37367 p->level--;
37368 return _res;
37369 }
37370
37371 // _loop0_193: lambda_param_maybe_default
37372 static asdl_seq *
37373 _loop0_193_rule(Parser *p)
37374 {
37375 if (p->level++ == MAXSTACK) {
37376 _Pypegen_stack_overflow(p);
37377 }
37378 if (p->error_indicator) {
37379 p->level--;
37380 return NULL;
37381 }
37382 void *_res = NULL;
37383 int _mark = p->mark;
37384 void **_children = PyMem_Malloc(sizeof(void *));
37385 if (!_children) {
37386 p->error_indicator = 1;
37387 PyErr_NoMemory();
37388 p->level--;
37389 return NULL;
37390 }
37391 Py_ssize_t _children_capacity = 1;
37392 Py_ssize_t _n = 0;
37393 { // lambda_param_maybe_default
37394 if (p->error_indicator) {
37395 p->level--;
37396 return NULL;
37397 }
37398 D(fprintf(stderr, "%*c> _loop0_193[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
37399 NameDefaultPair* lambda_param_maybe_default_var;
37400 while (
37401 (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
37402 )
37403 {
37404 _res = lambda_param_maybe_default_var;
37405 if (_n == _children_capacity) {
37406 _children_capacity *= 2;
37407 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37408 if (!_new_children) {
37409 PyMem_Free(_children);
37410 p->error_indicator = 1;
37411 PyErr_NoMemory();
37412 p->level--;
37413 return NULL;
37414 }
37415 _children = _new_children;
37416 }
37417 _children[_n++] = _res;
37418 _mark = p->mark;
37419 }
37420 p->mark = _mark;
37421 D(fprintf(stderr, "%*c%s _loop0_193[%d-%d]: %s failed!\n", p->level, ' ',
37422 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
37423 }
37424 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37425 if (!_seq) {
37426 PyMem_Free(_children);
37427 p->error_indicator = 1;
37428 PyErr_NoMemory();
37429 p->level--;
37430 return NULL;
37431 }
37432 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37433 PyMem_Free(_children);
37434 p->level--;
37435 return _seq;
37436 }
37437
37438 // _tmp_194: ',' | lambda_param_no_default
37439 static void *
37440 _tmp_194_rule(Parser *p)
37441 {
37442 if (p->level++ == MAXSTACK) {
37443 _Pypegen_stack_overflow(p);
37444 }
37445 if (p->error_indicator) {
37446 p->level--;
37447 return NULL;
37448 }
37449 void * _res = NULL;
37450 int _mark = p->mark;
37451 { // ','
37452 if (p->error_indicator) {
37453 p->level--;
37454 return NULL;
37455 }
37456 D(fprintf(stderr, "%*c> _tmp_194[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
37457 Token * _literal;
37458 if (
37459 (_literal = _PyPegen_expect_token(p, 12)) // token=','
37460 )
37461 {
37462 D(fprintf(stderr, "%*c+ _tmp_194[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
37463 _res = _literal;
37464 goto done;
37465 }
37466 p->mark = _mark;
37467 D(fprintf(stderr, "%*c%s _tmp_194[%d-%d]: %s failed!\n", p->level, ' ',
37468 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
37469 }
37470 { // lambda_param_no_default
37471 if (p->error_indicator) {
37472 p->level--;
37473 return NULL;
37474 }
37475 D(fprintf(stderr, "%*c> _tmp_194[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
37476 arg_ty lambda_param_no_default_var;
37477 if (
37478 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
37479 )
37480 {
37481 D(fprintf(stderr, "%*c+ _tmp_194[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
37482 _res = lambda_param_no_default_var;
37483 goto done;
37484 }
37485 p->mark = _mark;
37486 D(fprintf(stderr, "%*c%s _tmp_194[%d-%d]: %s failed!\n", p->level, ' ',
37487 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
37488 }
37489 _res = NULL;
37490 done:
37491 p->level--;
37492 return _res;
37493 }
37494
37495 // _loop0_195: lambda_param_maybe_default
37496 static asdl_seq *
37497 _loop0_195_rule(Parser *p)
37498 {
37499 if (p->level++ == MAXSTACK) {
37500 _Pypegen_stack_overflow(p);
37501 }
37502 if (p->error_indicator) {
37503 p->level--;
37504 return NULL;
37505 }
37506 void *_res = NULL;
37507 int _mark = p->mark;
37508 void **_children = PyMem_Malloc(sizeof(void *));
37509 if (!_children) {
37510 p->error_indicator = 1;
37511 PyErr_NoMemory();
37512 p->level--;
37513 return NULL;
37514 }
37515 Py_ssize_t _children_capacity = 1;
37516 Py_ssize_t _n = 0;
37517 { // lambda_param_maybe_default
37518 if (p->error_indicator) {
37519 p->level--;
37520 return NULL;
37521 }
37522 D(fprintf(stderr, "%*c> _loop0_195[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
37523 NameDefaultPair* lambda_param_maybe_default_var;
37524 while (
37525 (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
37526 )
37527 {
37528 _res = lambda_param_maybe_default_var;
37529 if (_n == _children_capacity) {
37530 _children_capacity *= 2;
37531 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37532 if (!_new_children) {
37533 PyMem_Free(_children);
37534 p->error_indicator = 1;
37535 PyErr_NoMemory();
37536 p->level--;
37537 return NULL;
37538 }
37539 _children = _new_children;
37540 }
37541 _children[_n++] = _res;
37542 _mark = p->mark;
37543 }
37544 p->mark = _mark;
37545 D(fprintf(stderr, "%*c%s _loop0_195[%d-%d]: %s failed!\n", p->level, ' ',
37546 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
37547 }
37548 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37549 if (!_seq) {
37550 PyMem_Free(_children);
37551 p->error_indicator = 1;
37552 PyErr_NoMemory();
37553 p->level--;
37554 return NULL;
37555 }
37556 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37557 PyMem_Free(_children);
37558 p->level--;
37559 return _seq;
37560 }
37561
37562 // _loop1_196: lambda_param_maybe_default
37563 static asdl_seq *
37564 _loop1_196_rule(Parser *p)
37565 {
37566 if (p->level++ == MAXSTACK) {
37567 _Pypegen_stack_overflow(p);
37568 }
37569 if (p->error_indicator) {
37570 p->level--;
37571 return NULL;
37572 }
37573 void *_res = NULL;
37574 int _mark = p->mark;
37575 void **_children = PyMem_Malloc(sizeof(void *));
37576 if (!_children) {
37577 p->error_indicator = 1;
37578 PyErr_NoMemory();
37579 p->level--;
37580 return NULL;
37581 }
37582 Py_ssize_t _children_capacity = 1;
37583 Py_ssize_t _n = 0;
37584 { // lambda_param_maybe_default
37585 if (p->error_indicator) {
37586 p->level--;
37587 return NULL;
37588 }
37589 D(fprintf(stderr, "%*c> _loop1_196[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
37590 NameDefaultPair* lambda_param_maybe_default_var;
37591 while (
37592 (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
37593 )
37594 {
37595 _res = lambda_param_maybe_default_var;
37596 if (_n == _children_capacity) {
37597 _children_capacity *= 2;
37598 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37599 if (!_new_children) {
37600 PyMem_Free(_children);
37601 p->error_indicator = 1;
37602 PyErr_NoMemory();
37603 p->level--;
37604 return NULL;
37605 }
37606 _children = _new_children;
37607 }
37608 _children[_n++] = _res;
37609 _mark = p->mark;
37610 }
37611 p->mark = _mark;
37612 D(fprintf(stderr, "%*c%s _loop1_196[%d-%d]: %s failed!\n", p->level, ' ',
37613 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
37614 }
37615 if (_n == 0 || p->error_indicator) {
37616 PyMem_Free(_children);
37617 p->level--;
37618 return NULL;
37619 }
37620 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37621 if (!_seq) {
37622 PyMem_Free(_children);
37623 p->error_indicator = 1;
37624 PyErr_NoMemory();
37625 p->level--;
37626 return NULL;
37627 }
37628 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37629 PyMem_Free(_children);
37630 p->level--;
37631 return _seq;
37632 }
37633
37634 // _loop1_197: lambda_param_with_default
37635 static asdl_seq *
37636 _loop1_197_rule(Parser *p)
37637 {
37638 if (p->level++ == MAXSTACK) {
37639 _Pypegen_stack_overflow(p);
37640 }
37641 if (p->error_indicator) {
37642 p->level--;
37643 return NULL;
37644 }
37645 void *_res = NULL;
37646 int _mark = p->mark;
37647 void **_children = PyMem_Malloc(sizeof(void *));
37648 if (!_children) {
37649 p->error_indicator = 1;
37650 PyErr_NoMemory();
37651 p->level--;
37652 return NULL;
37653 }
37654 Py_ssize_t _children_capacity = 1;
37655 Py_ssize_t _n = 0;
37656 { // lambda_param_with_default
37657 if (p->error_indicator) {
37658 p->level--;
37659 return NULL;
37660 }
37661 D(fprintf(stderr, "%*c> _loop1_197[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
37662 NameDefaultPair* lambda_param_with_default_var;
37663 while (
37664 (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default
37665 )
37666 {
37667 _res = lambda_param_with_default_var;
37668 if (_n == _children_capacity) {
37669 _children_capacity *= 2;
37670 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37671 if (!_new_children) {
37672 PyMem_Free(_children);
37673 p->error_indicator = 1;
37674 PyErr_NoMemory();
37675 p->level--;
37676 return NULL;
37677 }
37678 _children = _new_children;
37679 }
37680 _children[_n++] = _res;
37681 _mark = p->mark;
37682 }
37683 p->mark = _mark;
37684 D(fprintf(stderr, "%*c%s _loop1_197[%d-%d]: %s failed!\n", p->level, ' ',
37685 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
37686 }
37687 if (_n == 0 || p->error_indicator) {
37688 PyMem_Free(_children);
37689 p->level--;
37690 return NULL;
37691 }
37692 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37693 if (!_seq) {
37694 PyMem_Free(_children);
37695 p->error_indicator = 1;
37696 PyErr_NoMemory();
37697 p->level--;
37698 return NULL;
37699 }
37700 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37701 PyMem_Free(_children);
37702 p->level--;
37703 return _seq;
37704 }
37705
37706 // _tmp_198: ':' | ',' (':' | '**')
37707 static void *
37708 _tmp_198_rule(Parser *p)
37709 {
37710 if (p->level++ == MAXSTACK) {
37711 _Pypegen_stack_overflow(p);
37712 }
37713 if (p->error_indicator) {
37714 p->level--;
37715 return NULL;
37716 }
37717 void * _res = NULL;
37718 int _mark = p->mark;
37719 { // ':'
37720 if (p->error_indicator) {
37721 p->level--;
37722 return NULL;
37723 }
37724 D(fprintf(stderr, "%*c> _tmp_198[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
37725 Token * _literal;
37726 if (
37727 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
37728 )
37729 {
37730 D(fprintf(stderr, "%*c+ _tmp_198[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
37731 _res = _literal;
37732 goto done;
37733 }
37734 p->mark = _mark;
37735 D(fprintf(stderr, "%*c%s _tmp_198[%d-%d]: %s failed!\n", p->level, ' ',
37736 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
37737 }
37738 { // ',' (':' | '**')
37739 if (p->error_indicator) {
37740 p->level--;
37741 return NULL;
37742 }
37743 D(fprintf(stderr, "%*c> _tmp_198[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')"));
37744 Token * _literal;
37745 void *_tmp_266_var;
37746 if (
37747 (_literal = _PyPegen_expect_token(p, 12)) // token=','
37748 &&
37749 (_tmp_266_var = _tmp_266_rule(p)) // ':' | '**'
37750 )
37751 {
37752 D(fprintf(stderr, "%*c+ _tmp_198[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')"));
37753 _res = _PyPegen_dummy_name(p, _literal, _tmp_266_var);
37754 goto done;
37755 }
37756 p->mark = _mark;
37757 D(fprintf(stderr, "%*c%s _tmp_198[%d-%d]: %s failed!\n", p->level, ' ',
37758 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')"));
37759 }
37760 _res = NULL;
37761 done:
37762 p->level--;
37763 return _res;
37764 }
37765
37766 // _tmp_199: lambda_param_no_default | ','
37767 static void *
37768 _tmp_199_rule(Parser *p)
37769 {
37770 if (p->level++ == MAXSTACK) {
37771 _Pypegen_stack_overflow(p);
37772 }
37773 if (p->error_indicator) {
37774 p->level--;
37775 return NULL;
37776 }
37777 void * _res = NULL;
37778 int _mark = p->mark;
37779 { // lambda_param_no_default
37780 if (p->error_indicator) {
37781 p->level--;
37782 return NULL;
37783 }
37784 D(fprintf(stderr, "%*c> _tmp_199[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
37785 arg_ty lambda_param_no_default_var;
37786 if (
37787 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
37788 )
37789 {
37790 D(fprintf(stderr, "%*c+ _tmp_199[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
37791 _res = lambda_param_no_default_var;
37792 goto done;
37793 }
37794 p->mark = _mark;
37795 D(fprintf(stderr, "%*c%s _tmp_199[%d-%d]: %s failed!\n", p->level, ' ',
37796 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
37797 }
37798 { // ','
37799 if (p->error_indicator) {
37800 p->level--;
37801 return NULL;
37802 }
37803 D(fprintf(stderr, "%*c> _tmp_199[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
37804 Token * _literal;
37805 if (
37806 (_literal = _PyPegen_expect_token(p, 12)) // token=','
37807 )
37808 {
37809 D(fprintf(stderr, "%*c+ _tmp_199[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
37810 _res = _literal;
37811 goto done;
37812 }
37813 p->mark = _mark;
37814 D(fprintf(stderr, "%*c%s _tmp_199[%d-%d]: %s failed!\n", p->level, ' ',
37815 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
37816 }
37817 _res = NULL;
37818 done:
37819 p->level--;
37820 return _res;
37821 }
37822
37823 // _loop0_200: lambda_param_maybe_default
37824 static asdl_seq *
37825 _loop0_200_rule(Parser *p)
37826 {
37827 if (p->level++ == MAXSTACK) {
37828 _Pypegen_stack_overflow(p);
37829 }
37830 if (p->error_indicator) {
37831 p->level--;
37832 return NULL;
37833 }
37834 void *_res = NULL;
37835 int _mark = p->mark;
37836 void **_children = PyMem_Malloc(sizeof(void *));
37837 if (!_children) {
37838 p->error_indicator = 1;
37839 PyErr_NoMemory();
37840 p->level--;
37841 return NULL;
37842 }
37843 Py_ssize_t _children_capacity = 1;
37844 Py_ssize_t _n = 0;
37845 { // lambda_param_maybe_default
37846 if (p->error_indicator) {
37847 p->level--;
37848 return NULL;
37849 }
37850 D(fprintf(stderr, "%*c> _loop0_200[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
37851 NameDefaultPair* lambda_param_maybe_default_var;
37852 while (
37853 (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default
37854 )
37855 {
37856 _res = lambda_param_maybe_default_var;
37857 if (_n == _children_capacity) {
37858 _children_capacity *= 2;
37859 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
37860 if (!_new_children) {
37861 PyMem_Free(_children);
37862 p->error_indicator = 1;
37863 PyErr_NoMemory();
37864 p->level--;
37865 return NULL;
37866 }
37867 _children = _new_children;
37868 }
37869 _children[_n++] = _res;
37870 _mark = p->mark;
37871 }
37872 p->mark = _mark;
37873 D(fprintf(stderr, "%*c%s _loop0_200[%d-%d]: %s failed!\n", p->level, ' ',
37874 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
37875 }
37876 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
37877 if (!_seq) {
37878 PyMem_Free(_children);
37879 p->error_indicator = 1;
37880 PyErr_NoMemory();
37881 p->level--;
37882 return NULL;
37883 }
37884 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
37885 PyMem_Free(_children);
37886 p->level--;
37887 return _seq;
37888 }
37889
37890 // _tmp_201: lambda_param_no_default | ','
37891 static void *
37892 _tmp_201_rule(Parser *p)
37893 {
37894 if (p->level++ == MAXSTACK) {
37895 _Pypegen_stack_overflow(p);
37896 }
37897 if (p->error_indicator) {
37898 p->level--;
37899 return NULL;
37900 }
37901 void * _res = NULL;
37902 int _mark = p->mark;
37903 { // lambda_param_no_default
37904 if (p->error_indicator) {
37905 p->level--;
37906 return NULL;
37907 }
37908 D(fprintf(stderr, "%*c> _tmp_201[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
37909 arg_ty lambda_param_no_default_var;
37910 if (
37911 (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default
37912 )
37913 {
37914 D(fprintf(stderr, "%*c+ _tmp_201[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
37915 _res = lambda_param_no_default_var;
37916 goto done;
37917 }
37918 p->mark = _mark;
37919 D(fprintf(stderr, "%*c%s _tmp_201[%d-%d]: %s failed!\n", p->level, ' ',
37920 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
37921 }
37922 { // ','
37923 if (p->error_indicator) {
37924 p->level--;
37925 return NULL;
37926 }
37927 D(fprintf(stderr, "%*c> _tmp_201[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
37928 Token * _literal;
37929 if (
37930 (_literal = _PyPegen_expect_token(p, 12)) // token=','
37931 )
37932 {
37933 D(fprintf(stderr, "%*c+ _tmp_201[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
37934 _res = _literal;
37935 goto done;
37936 }
37937 p->mark = _mark;
37938 D(fprintf(stderr, "%*c%s _tmp_201[%d-%d]: %s failed!\n", p->level, ' ',
37939 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
37940 }
37941 _res = NULL;
37942 done:
37943 p->level--;
37944 return _res;
37945 }
37946
37947 // _tmp_202: '*' | '**' | '/'
37948 static void *
37949 _tmp_202_rule(Parser *p)
37950 {
37951 if (p->level++ == MAXSTACK) {
37952 _Pypegen_stack_overflow(p);
37953 }
37954 if (p->error_indicator) {
37955 p->level--;
37956 return NULL;
37957 }
37958 void * _res = NULL;
37959 int _mark = p->mark;
37960 { // '*'
37961 if (p->error_indicator) {
37962 p->level--;
37963 return NULL;
37964 }
37965 D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
37966 Token * _literal;
37967 if (
37968 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
37969 )
37970 {
37971 D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'"));
37972 _res = _literal;
37973 goto done;
37974 }
37975 p->mark = _mark;
37976 D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ',
37977 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));
37978 }
37979 { // '**'
37980 if (p->error_indicator) {
37981 p->level--;
37982 return NULL;
37983 }
37984 D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
37985 Token * _literal;
37986 if (
37987 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
37988 )
37989 {
37990 D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'"));
37991 _res = _literal;
37992 goto done;
37993 }
37994 p->mark = _mark;
37995 D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ',
37996 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
37997 }
37998 { // '/'
37999 if (p->error_indicator) {
38000 p->level--;
38001 return NULL;
38002 }
38003 D(fprintf(stderr, "%*c> _tmp_202[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'"));
38004 Token * _literal;
38005 if (
38006 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
38007 )
38008 {
38009 D(fprintf(stderr, "%*c+ _tmp_202[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'"));
38010 _res = _literal;
38011 goto done;
38012 }
38013 p->mark = _mark;
38014 D(fprintf(stderr, "%*c%s _tmp_202[%d-%d]: %s failed!\n", p->level, ' ',
38015 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'"));
38016 }
38017 _res = NULL;
38018 done:
38019 p->level--;
38020 return _res;
38021 }
38022
38023 // _tmp_203: ',' | ')' | ':'
38024 static void *
38025 _tmp_203_rule(Parser *p)
38026 {
38027 if (p->level++ == MAXSTACK) {
38028 _Pypegen_stack_overflow(p);
38029 }
38030 if (p->error_indicator) {
38031 p->level--;
38032 return NULL;
38033 }
38034 void * _res = NULL;
38035 int _mark = p->mark;
38036 { // ','
38037 if (p->error_indicator) {
38038 p->level--;
38039 return NULL;
38040 }
38041 D(fprintf(stderr, "%*c> _tmp_203[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
38042 Token * _literal;
38043 if (
38044 (_literal = _PyPegen_expect_token(p, 12)) // token=','
38045 )
38046 {
38047 D(fprintf(stderr, "%*c+ _tmp_203[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
38048 _res = _literal;
38049 goto done;
38050 }
38051 p->mark = _mark;
38052 D(fprintf(stderr, "%*c%s _tmp_203[%d-%d]: %s failed!\n", p->level, ' ',
38053 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
38054 }
38055 { // ')'
38056 if (p->error_indicator) {
38057 p->level--;
38058 return NULL;
38059 }
38060 D(fprintf(stderr, "%*c> _tmp_203[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
38061 Token * _literal;
38062 if (
38063 (_literal = _PyPegen_expect_token(p, 8)) // token=')'
38064 )
38065 {
38066 D(fprintf(stderr, "%*c+ _tmp_203[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
38067 _res = _literal;
38068 goto done;
38069 }
38070 p->mark = _mark;
38071 D(fprintf(stderr, "%*c%s _tmp_203[%d-%d]: %s failed!\n", p->level, ' ',
38072 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
38073 }
38074 { // ':'
38075 if (p->error_indicator) {
38076 p->level--;
38077 return NULL;
38078 }
38079 D(fprintf(stderr, "%*c> _tmp_203[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
38080 Token * _literal;
38081 if (
38082 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
38083 )
38084 {
38085 D(fprintf(stderr, "%*c+ _tmp_203[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
38086 _res = _literal;
38087 goto done;
38088 }
38089 p->mark = _mark;
38090 D(fprintf(stderr, "%*c%s _tmp_203[%d-%d]: %s failed!\n", p->level, ' ',
38091 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
38092 }
38093 _res = NULL;
38094 done:
38095 p->level--;
38096 return _res;
38097 }
38098
38099 // _loop0_205: ',' dotted_name
38100 static asdl_seq *
38101 _loop0_205_rule(Parser *p)
38102 {
38103 if (p->level++ == MAXSTACK) {
38104 _Pypegen_stack_overflow(p);
38105 }
38106 if (p->error_indicator) {
38107 p->level--;
38108 return NULL;
38109 }
38110 void *_res = NULL;
38111 int _mark = p->mark;
38112 void **_children = PyMem_Malloc(sizeof(void *));
38113 if (!_children) {
38114 p->error_indicator = 1;
38115 PyErr_NoMemory();
38116 p->level--;
38117 return NULL;
38118 }
38119 Py_ssize_t _children_capacity = 1;
38120 Py_ssize_t _n = 0;
38121 { // ',' dotted_name
38122 if (p->error_indicator) {
38123 p->level--;
38124 return NULL;
38125 }
38126 D(fprintf(stderr, "%*c> _loop0_205[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name"));
38127 Token * _literal;
38128 expr_ty elem;
38129 while (
38130 (_literal = _PyPegen_expect_token(p, 12)) // token=','
38131 &&
38132 (elem = dotted_name_rule(p)) // dotted_name
38133 )
38134 {
38135 _res = elem;
38136 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
38137 p->error_indicator = 1;
38138 PyMem_Free(_children);
38139 p->level--;
38140 return NULL;
38141 }
38142 if (_n == _children_capacity) {
38143 _children_capacity *= 2;
38144 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38145 if (!_new_children) {
38146 PyMem_Free(_children);
38147 p->error_indicator = 1;
38148 PyErr_NoMemory();
38149 p->level--;
38150 return NULL;
38151 }
38152 _children = _new_children;
38153 }
38154 _children[_n++] = _res;
38155 _mark = p->mark;
38156 }
38157 p->mark = _mark;
38158 D(fprintf(stderr, "%*c%s _loop0_205[%d-%d]: %s failed!\n", p->level, ' ',
38159 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_name"));
38160 }
38161 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38162 if (!_seq) {
38163 PyMem_Free(_children);
38164 p->error_indicator = 1;
38165 PyErr_NoMemory();
38166 p->level--;
38167 return NULL;
38168 }
38169 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38170 PyMem_Free(_children);
38171 p->level--;
38172 return _seq;
38173 }
38174
38175 // _gather_204: dotted_name _loop0_205
38176 static asdl_seq *
38177 _gather_204_rule(Parser *p)
38178 {
38179 if (p->level++ == MAXSTACK) {
38180 _Pypegen_stack_overflow(p);
38181 }
38182 if (p->error_indicator) {
38183 p->level--;
38184 return NULL;
38185 }
38186 asdl_seq * _res = NULL;
38187 int _mark = p->mark;
38188 { // dotted_name _loop0_205
38189 if (p->error_indicator) {
38190 p->level--;
38191 return NULL;
38192 }
38193 D(fprintf(stderr, "%*c> _gather_204[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_205"));
38194 expr_ty elem;
38195 asdl_seq * seq;
38196 if (
38197 (elem = dotted_name_rule(p)) // dotted_name
38198 &&
38199 (seq = _loop0_205_rule(p)) // _loop0_205
38200 )
38201 {
38202 D(fprintf(stderr, "%*c+ _gather_204[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_205"));
38203 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
38204 goto done;
38205 }
38206 p->mark = _mark;
38207 D(fprintf(stderr, "%*c%s _gather_204[%d-%d]: %s failed!\n", p->level, ' ',
38208 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_205"));
38209 }
38210 _res = NULL;
38211 done:
38212 p->level--;
38213 return _res;
38214 }
38215
38216 // _loop0_207: ',' (expression ['as' star_target])
38217 static asdl_seq *
38218 _loop0_207_rule(Parser *p)
38219 {
38220 if (p->level++ == MAXSTACK) {
38221 _Pypegen_stack_overflow(p);
38222 }
38223 if (p->error_indicator) {
38224 p->level--;
38225 return NULL;
38226 }
38227 void *_res = NULL;
38228 int _mark = p->mark;
38229 void **_children = PyMem_Malloc(sizeof(void *));
38230 if (!_children) {
38231 p->error_indicator = 1;
38232 PyErr_NoMemory();
38233 p->level--;
38234 return NULL;
38235 }
38236 Py_ssize_t _children_capacity = 1;
38237 Py_ssize_t _n = 0;
38238 { // ',' (expression ['as' star_target])
38239 if (p->error_indicator) {
38240 p->level--;
38241 return NULL;
38242 }
38243 D(fprintf(stderr, "%*c> _loop0_207[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])"));
38244 Token * _literal;
38245 void *elem;
38246 while (
38247 (_literal = _PyPegen_expect_token(p, 12)) // token=','
38248 &&
38249 (elem = _tmp_267_rule(p)) // expression ['as' star_target]
38250 )
38251 {
38252 _res = elem;
38253 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
38254 p->error_indicator = 1;
38255 PyMem_Free(_children);
38256 p->level--;
38257 return NULL;
38258 }
38259 if (_n == _children_capacity) {
38260 _children_capacity *= 2;
38261 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38262 if (!_new_children) {
38263 PyMem_Free(_children);
38264 p->error_indicator = 1;
38265 PyErr_NoMemory();
38266 p->level--;
38267 return NULL;
38268 }
38269 _children = _new_children;
38270 }
38271 _children[_n++] = _res;
38272 _mark = p->mark;
38273 }
38274 p->mark = _mark;
38275 D(fprintf(stderr, "%*c%s _loop0_207[%d-%d]: %s failed!\n", p->level, ' ',
38276 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])"));
38277 }
38278 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38279 if (!_seq) {
38280 PyMem_Free(_children);
38281 p->error_indicator = 1;
38282 PyErr_NoMemory();
38283 p->level--;
38284 return NULL;
38285 }
38286 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38287 PyMem_Free(_children);
38288 p->level--;
38289 return _seq;
38290 }
38291
38292 // _gather_206: (expression ['as' star_target]) _loop0_207
38293 static asdl_seq *
38294 _gather_206_rule(Parser *p)
38295 {
38296 if (p->level++ == MAXSTACK) {
38297 _Pypegen_stack_overflow(p);
38298 }
38299 if (p->error_indicator) {
38300 p->level--;
38301 return NULL;
38302 }
38303 asdl_seq * _res = NULL;
38304 int _mark = p->mark;
38305 { // (expression ['as' star_target]) _loop0_207
38306 if (p->error_indicator) {
38307 p->level--;
38308 return NULL;
38309 }
38310 D(fprintf(stderr, "%*c> _gather_206[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_207"));
38311 void *elem;
38312 asdl_seq * seq;
38313 if (
38314 (elem = _tmp_267_rule(p)) // expression ['as' star_target]
38315 &&
38316 (seq = _loop0_207_rule(p)) // _loop0_207
38317 )
38318 {
38319 D(fprintf(stderr, "%*c+ _gather_206[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_207"));
38320 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
38321 goto done;
38322 }
38323 p->mark = _mark;
38324 D(fprintf(stderr, "%*c%s _gather_206[%d-%d]: %s failed!\n", p->level, ' ',
38325 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_207"));
38326 }
38327 _res = NULL;
38328 done:
38329 p->level--;
38330 return _res;
38331 }
38332
38333 // _loop0_209: ',' (expressions ['as' star_target])
38334 static asdl_seq *
38335 _loop0_209_rule(Parser *p)
38336 {
38337 if (p->level++ == MAXSTACK) {
38338 _Pypegen_stack_overflow(p);
38339 }
38340 if (p->error_indicator) {
38341 p->level--;
38342 return NULL;
38343 }
38344 void *_res = NULL;
38345 int _mark = p->mark;
38346 void **_children = PyMem_Malloc(sizeof(void *));
38347 if (!_children) {
38348 p->error_indicator = 1;
38349 PyErr_NoMemory();
38350 p->level--;
38351 return NULL;
38352 }
38353 Py_ssize_t _children_capacity = 1;
38354 Py_ssize_t _n = 0;
38355 { // ',' (expressions ['as' star_target])
38356 if (p->error_indicator) {
38357 p->level--;
38358 return NULL;
38359 }
38360 D(fprintf(stderr, "%*c> _loop0_209[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])"));
38361 Token * _literal;
38362 void *elem;
38363 while (
38364 (_literal = _PyPegen_expect_token(p, 12)) // token=','
38365 &&
38366 (elem = _tmp_268_rule(p)) // expressions ['as' star_target]
38367 )
38368 {
38369 _res = elem;
38370 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
38371 p->error_indicator = 1;
38372 PyMem_Free(_children);
38373 p->level--;
38374 return NULL;
38375 }
38376 if (_n == _children_capacity) {
38377 _children_capacity *= 2;
38378 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38379 if (!_new_children) {
38380 PyMem_Free(_children);
38381 p->error_indicator = 1;
38382 PyErr_NoMemory();
38383 p->level--;
38384 return NULL;
38385 }
38386 _children = _new_children;
38387 }
38388 _children[_n++] = _res;
38389 _mark = p->mark;
38390 }
38391 p->mark = _mark;
38392 D(fprintf(stderr, "%*c%s _loop0_209[%d-%d]: %s failed!\n", p->level, ' ',
38393 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])"));
38394 }
38395 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38396 if (!_seq) {
38397 PyMem_Free(_children);
38398 p->error_indicator = 1;
38399 PyErr_NoMemory();
38400 p->level--;
38401 return NULL;
38402 }
38403 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38404 PyMem_Free(_children);
38405 p->level--;
38406 return _seq;
38407 }
38408
38409 // _gather_208: (expressions ['as' star_target]) _loop0_209
38410 static asdl_seq *
38411 _gather_208_rule(Parser *p)
38412 {
38413 if (p->level++ == MAXSTACK) {
38414 _Pypegen_stack_overflow(p);
38415 }
38416 if (p->error_indicator) {
38417 p->level--;
38418 return NULL;
38419 }
38420 asdl_seq * _res = NULL;
38421 int _mark = p->mark;
38422 { // (expressions ['as' star_target]) _loop0_209
38423 if (p->error_indicator) {
38424 p->level--;
38425 return NULL;
38426 }
38427 D(fprintf(stderr, "%*c> _gather_208[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_209"));
38428 void *elem;
38429 asdl_seq * seq;
38430 if (
38431 (elem = _tmp_268_rule(p)) // expressions ['as' star_target]
38432 &&
38433 (seq = _loop0_209_rule(p)) // _loop0_209
38434 )
38435 {
38436 D(fprintf(stderr, "%*c+ _gather_208[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_209"));
38437 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
38438 goto done;
38439 }
38440 p->mark = _mark;
38441 D(fprintf(stderr, "%*c%s _gather_208[%d-%d]: %s failed!\n", p->level, ' ',
38442 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_209"));
38443 }
38444 _res = NULL;
38445 done:
38446 p->level--;
38447 return _res;
38448 }
38449
38450 // _loop0_211: ',' (expression ['as' star_target])
38451 static asdl_seq *
38452 _loop0_211_rule(Parser *p)
38453 {
38454 if (p->level++ == MAXSTACK) {
38455 _Pypegen_stack_overflow(p);
38456 }
38457 if (p->error_indicator) {
38458 p->level--;
38459 return NULL;
38460 }
38461 void *_res = NULL;
38462 int _mark = p->mark;
38463 void **_children = PyMem_Malloc(sizeof(void *));
38464 if (!_children) {
38465 p->error_indicator = 1;
38466 PyErr_NoMemory();
38467 p->level--;
38468 return NULL;
38469 }
38470 Py_ssize_t _children_capacity = 1;
38471 Py_ssize_t _n = 0;
38472 { // ',' (expression ['as' star_target])
38473 if (p->error_indicator) {
38474 p->level--;
38475 return NULL;
38476 }
38477 D(fprintf(stderr, "%*c> _loop0_211[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])"));
38478 Token * _literal;
38479 void *elem;
38480 while (
38481 (_literal = _PyPegen_expect_token(p, 12)) // token=','
38482 &&
38483 (elem = _tmp_269_rule(p)) // expression ['as' star_target]
38484 )
38485 {
38486 _res = elem;
38487 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
38488 p->error_indicator = 1;
38489 PyMem_Free(_children);
38490 p->level--;
38491 return NULL;
38492 }
38493 if (_n == _children_capacity) {
38494 _children_capacity *= 2;
38495 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38496 if (!_new_children) {
38497 PyMem_Free(_children);
38498 p->error_indicator = 1;
38499 PyErr_NoMemory();
38500 p->level--;
38501 return NULL;
38502 }
38503 _children = _new_children;
38504 }
38505 _children[_n++] = _res;
38506 _mark = p->mark;
38507 }
38508 p->mark = _mark;
38509 D(fprintf(stderr, "%*c%s _loop0_211[%d-%d]: %s failed!\n", p->level, ' ',
38510 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])"));
38511 }
38512 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38513 if (!_seq) {
38514 PyMem_Free(_children);
38515 p->error_indicator = 1;
38516 PyErr_NoMemory();
38517 p->level--;
38518 return NULL;
38519 }
38520 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38521 PyMem_Free(_children);
38522 p->level--;
38523 return _seq;
38524 }
38525
38526 // _gather_210: (expression ['as' star_target]) _loop0_211
38527 static asdl_seq *
38528 _gather_210_rule(Parser *p)
38529 {
38530 if (p->level++ == MAXSTACK) {
38531 _Pypegen_stack_overflow(p);
38532 }
38533 if (p->error_indicator) {
38534 p->level--;
38535 return NULL;
38536 }
38537 asdl_seq * _res = NULL;
38538 int _mark = p->mark;
38539 { // (expression ['as' star_target]) _loop0_211
38540 if (p->error_indicator) {
38541 p->level--;
38542 return NULL;
38543 }
38544 D(fprintf(stderr, "%*c> _gather_210[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_211"));
38545 void *elem;
38546 asdl_seq * seq;
38547 if (
38548 (elem = _tmp_269_rule(p)) // expression ['as' star_target]
38549 &&
38550 (seq = _loop0_211_rule(p)) // _loop0_211
38551 )
38552 {
38553 D(fprintf(stderr, "%*c+ _gather_210[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_211"));
38554 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
38555 goto done;
38556 }
38557 p->mark = _mark;
38558 D(fprintf(stderr, "%*c%s _gather_210[%d-%d]: %s failed!\n", p->level, ' ',
38559 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_211"));
38560 }
38561 _res = NULL;
38562 done:
38563 p->level--;
38564 return _res;
38565 }
38566
38567 // _loop0_213: ',' (expressions ['as' star_target])
38568 static asdl_seq *
38569 _loop0_213_rule(Parser *p)
38570 {
38571 if (p->level++ == MAXSTACK) {
38572 _Pypegen_stack_overflow(p);
38573 }
38574 if (p->error_indicator) {
38575 p->level--;
38576 return NULL;
38577 }
38578 void *_res = NULL;
38579 int _mark = p->mark;
38580 void **_children = PyMem_Malloc(sizeof(void *));
38581 if (!_children) {
38582 p->error_indicator = 1;
38583 PyErr_NoMemory();
38584 p->level--;
38585 return NULL;
38586 }
38587 Py_ssize_t _children_capacity = 1;
38588 Py_ssize_t _n = 0;
38589 { // ',' (expressions ['as' star_target])
38590 if (p->error_indicator) {
38591 p->level--;
38592 return NULL;
38593 }
38594 D(fprintf(stderr, "%*c> _loop0_213[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])"));
38595 Token * _literal;
38596 void *elem;
38597 while (
38598 (_literal = _PyPegen_expect_token(p, 12)) // token=','
38599 &&
38600 (elem = _tmp_270_rule(p)) // expressions ['as' star_target]
38601 )
38602 {
38603 _res = elem;
38604 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
38605 p->error_indicator = 1;
38606 PyMem_Free(_children);
38607 p->level--;
38608 return NULL;
38609 }
38610 if (_n == _children_capacity) {
38611 _children_capacity *= 2;
38612 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38613 if (!_new_children) {
38614 PyMem_Free(_children);
38615 p->error_indicator = 1;
38616 PyErr_NoMemory();
38617 p->level--;
38618 return NULL;
38619 }
38620 _children = _new_children;
38621 }
38622 _children[_n++] = _res;
38623 _mark = p->mark;
38624 }
38625 p->mark = _mark;
38626 D(fprintf(stderr, "%*c%s _loop0_213[%d-%d]: %s failed!\n", p->level, ' ',
38627 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])"));
38628 }
38629 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38630 if (!_seq) {
38631 PyMem_Free(_children);
38632 p->error_indicator = 1;
38633 PyErr_NoMemory();
38634 p->level--;
38635 return NULL;
38636 }
38637 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38638 PyMem_Free(_children);
38639 p->level--;
38640 return _seq;
38641 }
38642
38643 // _gather_212: (expressions ['as' star_target]) _loop0_213
38644 static asdl_seq *
38645 _gather_212_rule(Parser *p)
38646 {
38647 if (p->level++ == MAXSTACK) {
38648 _Pypegen_stack_overflow(p);
38649 }
38650 if (p->error_indicator) {
38651 p->level--;
38652 return NULL;
38653 }
38654 asdl_seq * _res = NULL;
38655 int _mark = p->mark;
38656 { // (expressions ['as' star_target]) _loop0_213
38657 if (p->error_indicator) {
38658 p->level--;
38659 return NULL;
38660 }
38661 D(fprintf(stderr, "%*c> _gather_212[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_213"));
38662 void *elem;
38663 asdl_seq * seq;
38664 if (
38665 (elem = _tmp_270_rule(p)) // expressions ['as' star_target]
38666 &&
38667 (seq = _loop0_213_rule(p)) // _loop0_213
38668 )
38669 {
38670 D(fprintf(stderr, "%*c+ _gather_212[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_213"));
38671 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
38672 goto done;
38673 }
38674 p->mark = _mark;
38675 D(fprintf(stderr, "%*c%s _gather_212[%d-%d]: %s failed!\n", p->level, ' ',
38676 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_213"));
38677 }
38678 _res = NULL;
38679 done:
38680 p->level--;
38681 return _res;
38682 }
38683
38684 // _tmp_214: 'except' | 'finally'
38685 static void *
38686 _tmp_214_rule(Parser *p)
38687 {
38688 if (p->level++ == MAXSTACK) {
38689 _Pypegen_stack_overflow(p);
38690 }
38691 if (p->error_indicator) {
38692 p->level--;
38693 return NULL;
38694 }
38695 void * _res = NULL;
38696 int _mark = p->mark;
38697 { // 'except'
38698 if (p->error_indicator) {
38699 p->level--;
38700 return NULL;
38701 }
38702 D(fprintf(stderr, "%*c> _tmp_214[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'"));
38703 Token * _keyword;
38704 if (
38705 (_keyword = _PyPegen_expect_token(p, 655)) // token='except'
38706 )
38707 {
38708 D(fprintf(stderr, "%*c+ _tmp_214[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'"));
38709 _res = _keyword;
38710 goto done;
38711 }
38712 p->mark = _mark;
38713 D(fprintf(stderr, "%*c%s _tmp_214[%d-%d]: %s failed!\n", p->level, ' ',
38714 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'"));
38715 }
38716 { // 'finally'
38717 if (p->error_indicator) {
38718 p->level--;
38719 return NULL;
38720 }
38721 D(fprintf(stderr, "%*c> _tmp_214[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'"));
38722 Token * _keyword;
38723 if (
38724 (_keyword = _PyPegen_expect_token(p, 651)) // token='finally'
38725 )
38726 {
38727 D(fprintf(stderr, "%*c+ _tmp_214[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'"));
38728 _res = _keyword;
38729 goto done;
38730 }
38731 p->mark = _mark;
38732 D(fprintf(stderr, "%*c%s _tmp_214[%d-%d]: %s failed!\n", p->level, ' ',
38733 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'"));
38734 }
38735 _res = NULL;
38736 done:
38737 p->level--;
38738 return _res;
38739 }
38740
38741 // _loop0_215: block
38742 static asdl_seq *
38743 _loop0_215_rule(Parser *p)
38744 {
38745 if (p->level++ == MAXSTACK) {
38746 _Pypegen_stack_overflow(p);
38747 }
38748 if (p->error_indicator) {
38749 p->level--;
38750 return NULL;
38751 }
38752 void *_res = NULL;
38753 int _mark = p->mark;
38754 void **_children = PyMem_Malloc(sizeof(void *));
38755 if (!_children) {
38756 p->error_indicator = 1;
38757 PyErr_NoMemory();
38758 p->level--;
38759 return NULL;
38760 }
38761 Py_ssize_t _children_capacity = 1;
38762 Py_ssize_t _n = 0;
38763 { // block
38764 if (p->error_indicator) {
38765 p->level--;
38766 return NULL;
38767 }
38768 D(fprintf(stderr, "%*c> _loop0_215[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block"));
38769 asdl_stmt_seq* block_var;
38770 while (
38771 (block_var = block_rule(p)) // block
38772 )
38773 {
38774 _res = block_var;
38775 if (_n == _children_capacity) {
38776 _children_capacity *= 2;
38777 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38778 if (!_new_children) {
38779 PyMem_Free(_children);
38780 p->error_indicator = 1;
38781 PyErr_NoMemory();
38782 p->level--;
38783 return NULL;
38784 }
38785 _children = _new_children;
38786 }
38787 _children[_n++] = _res;
38788 _mark = p->mark;
38789 }
38790 p->mark = _mark;
38791 D(fprintf(stderr, "%*c%s _loop0_215[%d-%d]: %s failed!\n", p->level, ' ',
38792 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "block"));
38793 }
38794 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38795 if (!_seq) {
38796 PyMem_Free(_children);
38797 p->error_indicator = 1;
38798 PyErr_NoMemory();
38799 p->level--;
38800 return NULL;
38801 }
38802 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38803 PyMem_Free(_children);
38804 p->level--;
38805 return _seq;
38806 }
38807
38808 // _loop1_216: except_block
38809 static asdl_seq *
38810 _loop1_216_rule(Parser *p)
38811 {
38812 if (p->level++ == MAXSTACK) {
38813 _Pypegen_stack_overflow(p);
38814 }
38815 if (p->error_indicator) {
38816 p->level--;
38817 return NULL;
38818 }
38819 void *_res = NULL;
38820 int _mark = p->mark;
38821 void **_children = PyMem_Malloc(sizeof(void *));
38822 if (!_children) {
38823 p->error_indicator = 1;
38824 PyErr_NoMemory();
38825 p->level--;
38826 return NULL;
38827 }
38828 Py_ssize_t _children_capacity = 1;
38829 Py_ssize_t _n = 0;
38830 { // except_block
38831 if (p->error_indicator) {
38832 p->level--;
38833 return NULL;
38834 }
38835 D(fprintf(stderr, "%*c> _loop1_216[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));
38836 excepthandler_ty except_block_var;
38837 while (
38838 (except_block_var = except_block_rule(p)) // except_block
38839 )
38840 {
38841 _res = except_block_var;
38842 if (_n == _children_capacity) {
38843 _children_capacity *= 2;
38844 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38845 if (!_new_children) {
38846 PyMem_Free(_children);
38847 p->error_indicator = 1;
38848 PyErr_NoMemory();
38849 p->level--;
38850 return NULL;
38851 }
38852 _children = _new_children;
38853 }
38854 _children[_n++] = _res;
38855 _mark = p->mark;
38856 }
38857 p->mark = _mark;
38858 D(fprintf(stderr, "%*c%s _loop1_216[%d-%d]: %s failed!\n", p->level, ' ',
38859 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block"));
38860 }
38861 if (_n == 0 || p->error_indicator) {
38862 PyMem_Free(_children);
38863 p->level--;
38864 return NULL;
38865 }
38866 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38867 if (!_seq) {
38868 PyMem_Free(_children);
38869 p->error_indicator = 1;
38870 PyErr_NoMemory();
38871 p->level--;
38872 return NULL;
38873 }
38874 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38875 PyMem_Free(_children);
38876 p->level--;
38877 return _seq;
38878 }
38879
38880 // _tmp_217: 'as' NAME
38881 static void *
38882 _tmp_217_rule(Parser *p)
38883 {
38884 if (p->level++ == MAXSTACK) {
38885 _Pypegen_stack_overflow(p);
38886 }
38887 if (p->error_indicator) {
38888 p->level--;
38889 return NULL;
38890 }
38891 void * _res = NULL;
38892 int _mark = p->mark;
38893 { // 'as' NAME
38894 if (p->error_indicator) {
38895 p->level--;
38896 return NULL;
38897 }
38898 D(fprintf(stderr, "%*c> _tmp_217[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
38899 Token * _keyword;
38900 expr_ty name_var;
38901 if (
38902 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
38903 &&
38904 (name_var = _PyPegen_name_token(p)) // NAME
38905 )
38906 {
38907 D(fprintf(stderr, "%*c+ _tmp_217[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
38908 _res = _PyPegen_dummy_name(p, _keyword, name_var);
38909 goto done;
38910 }
38911 p->mark = _mark;
38912 D(fprintf(stderr, "%*c%s _tmp_217[%d-%d]: %s failed!\n", p->level, ' ',
38913 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
38914 }
38915 _res = NULL;
38916 done:
38917 p->level--;
38918 return _res;
38919 }
38920
38921 // _loop0_218: block
38922 static asdl_seq *
38923 _loop0_218_rule(Parser *p)
38924 {
38925 if (p->level++ == MAXSTACK) {
38926 _Pypegen_stack_overflow(p);
38927 }
38928 if (p->error_indicator) {
38929 p->level--;
38930 return NULL;
38931 }
38932 void *_res = NULL;
38933 int _mark = p->mark;
38934 void **_children = PyMem_Malloc(sizeof(void *));
38935 if (!_children) {
38936 p->error_indicator = 1;
38937 PyErr_NoMemory();
38938 p->level--;
38939 return NULL;
38940 }
38941 Py_ssize_t _children_capacity = 1;
38942 Py_ssize_t _n = 0;
38943 { // block
38944 if (p->error_indicator) {
38945 p->level--;
38946 return NULL;
38947 }
38948 D(fprintf(stderr, "%*c> _loop0_218[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block"));
38949 asdl_stmt_seq* block_var;
38950 while (
38951 (block_var = block_rule(p)) // block
38952 )
38953 {
38954 _res = block_var;
38955 if (_n == _children_capacity) {
38956 _children_capacity *= 2;
38957 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
38958 if (!_new_children) {
38959 PyMem_Free(_children);
38960 p->error_indicator = 1;
38961 PyErr_NoMemory();
38962 p->level--;
38963 return NULL;
38964 }
38965 _children = _new_children;
38966 }
38967 _children[_n++] = _res;
38968 _mark = p->mark;
38969 }
38970 p->mark = _mark;
38971 D(fprintf(stderr, "%*c%s _loop0_218[%d-%d]: %s failed!\n", p->level, ' ',
38972 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "block"));
38973 }
38974 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
38975 if (!_seq) {
38976 PyMem_Free(_children);
38977 p->error_indicator = 1;
38978 PyErr_NoMemory();
38979 p->level--;
38980 return NULL;
38981 }
38982 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
38983 PyMem_Free(_children);
38984 p->level--;
38985 return _seq;
38986 }
38987
38988 // _loop1_219: except_star_block
38989 static asdl_seq *
38990 _loop1_219_rule(Parser *p)
38991 {
38992 if (p->level++ == MAXSTACK) {
38993 _Pypegen_stack_overflow(p);
38994 }
38995 if (p->error_indicator) {
38996 p->level--;
38997 return NULL;
38998 }
38999 void *_res = NULL;
39000 int _mark = p->mark;
39001 void **_children = PyMem_Malloc(sizeof(void *));
39002 if (!_children) {
39003 p->error_indicator = 1;
39004 PyErr_NoMemory();
39005 p->level--;
39006 return NULL;
39007 }
39008 Py_ssize_t _children_capacity = 1;
39009 Py_ssize_t _n = 0;
39010 { // except_star_block
39011 if (p->error_indicator) {
39012 p->level--;
39013 return NULL;
39014 }
39015 D(fprintf(stderr, "%*c> _loop1_219[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block"));
39016 excepthandler_ty except_star_block_var;
39017 while (
39018 (except_star_block_var = except_star_block_rule(p)) // except_star_block
39019 )
39020 {
39021 _res = except_star_block_var;
39022 if (_n == _children_capacity) {
39023 _children_capacity *= 2;
39024 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
39025 if (!_new_children) {
39026 PyMem_Free(_children);
39027 p->error_indicator = 1;
39028 PyErr_NoMemory();
39029 p->level--;
39030 return NULL;
39031 }
39032 _children = _new_children;
39033 }
39034 _children[_n++] = _res;
39035 _mark = p->mark;
39036 }
39037 p->mark = _mark;
39038 D(fprintf(stderr, "%*c%s _loop1_219[%d-%d]: %s failed!\n", p->level, ' ',
39039 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_star_block"));
39040 }
39041 if (_n == 0 || p->error_indicator) {
39042 PyMem_Free(_children);
39043 p->level--;
39044 return NULL;
39045 }
39046 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
39047 if (!_seq) {
39048 PyMem_Free(_children);
39049 p->error_indicator = 1;
39050 PyErr_NoMemory();
39051 p->level--;
39052 return NULL;
39053 }
39054 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
39055 PyMem_Free(_children);
39056 p->level--;
39057 return _seq;
39058 }
39059
39060 // _tmp_220: expression ['as' NAME]
39061 static void *
39062 _tmp_220_rule(Parser *p)
39063 {
39064 if (p->level++ == MAXSTACK) {
39065 _Pypegen_stack_overflow(p);
39066 }
39067 if (p->error_indicator) {
39068 p->level--;
39069 return NULL;
39070 }
39071 void * _res = NULL;
39072 int _mark = p->mark;
39073 { // expression ['as' NAME]
39074 if (p->error_indicator) {
39075 p->level--;
39076 return NULL;
39077 }
39078 D(fprintf(stderr, "%*c> _tmp_220[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]"));
39079 void *_opt_var;
39080 UNUSED(_opt_var); // Silence compiler warnings
39081 expr_ty expression_var;
39082 if (
39083 (expression_var = expression_rule(p)) // expression
39084 &&
39085 (_opt_var = _tmp_271_rule(p), !p->error_indicator) // ['as' NAME]
39086 )
39087 {
39088 D(fprintf(stderr, "%*c+ _tmp_220[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]"));
39089 _res = _PyPegen_dummy_name(p, expression_var, _opt_var);
39090 goto done;
39091 }
39092 p->mark = _mark;
39093 D(fprintf(stderr, "%*c%s _tmp_220[%d-%d]: %s failed!\n", p->level, ' ',
39094 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' NAME]"));
39095 }
39096 _res = NULL;
39097 done:
39098 p->level--;
39099 return _res;
39100 }
39101
39102 // _tmp_221: 'as' NAME
39103 static void *
39104 _tmp_221_rule(Parser *p)
39105 {
39106 if (p->level++ == MAXSTACK) {
39107 _Pypegen_stack_overflow(p);
39108 }
39109 if (p->error_indicator) {
39110 p->level--;
39111 return NULL;
39112 }
39113 void * _res = NULL;
39114 int _mark = p->mark;
39115 { // 'as' NAME
39116 if (p->error_indicator) {
39117 p->level--;
39118 return NULL;
39119 }
39120 D(fprintf(stderr, "%*c> _tmp_221[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
39121 Token * _keyword;
39122 expr_ty name_var;
39123 if (
39124 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
39125 &&
39126 (name_var = _PyPegen_name_token(p)) // NAME
39127 )
39128 {
39129 D(fprintf(stderr, "%*c+ _tmp_221[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
39130 _res = _PyPegen_dummy_name(p, _keyword, name_var);
39131 goto done;
39132 }
39133 p->mark = _mark;
39134 D(fprintf(stderr, "%*c%s _tmp_221[%d-%d]: %s failed!\n", p->level, ' ',
39135 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
39136 }
39137 _res = NULL;
39138 done:
39139 p->level--;
39140 return _res;
39141 }
39142
39143 // _tmp_222: 'as' NAME
39144 static void *
39145 _tmp_222_rule(Parser *p)
39146 {
39147 if (p->level++ == MAXSTACK) {
39148 _Pypegen_stack_overflow(p);
39149 }
39150 if (p->error_indicator) {
39151 p->level--;
39152 return NULL;
39153 }
39154 void * _res = NULL;
39155 int _mark = p->mark;
39156 { // 'as' NAME
39157 if (p->error_indicator) {
39158 p->level--;
39159 return NULL;
39160 }
39161 D(fprintf(stderr, "%*c> _tmp_222[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
39162 Token * _keyword;
39163 expr_ty name_var;
39164 if (
39165 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
39166 &&
39167 (name_var = _PyPegen_name_token(p)) // NAME
39168 )
39169 {
39170 D(fprintf(stderr, "%*c+ _tmp_222[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
39171 _res = _PyPegen_dummy_name(p, _keyword, name_var);
39172 goto done;
39173 }
39174 p->mark = _mark;
39175 D(fprintf(stderr, "%*c%s _tmp_222[%d-%d]: %s failed!\n", p->level, ' ',
39176 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
39177 }
39178 _res = NULL;
39179 done:
39180 p->level--;
39181 return _res;
39182 }
39183
39184 // _tmp_223: NEWLINE | ':'
39185 static void *
39186 _tmp_223_rule(Parser *p)
39187 {
39188 if (p->level++ == MAXSTACK) {
39189 _Pypegen_stack_overflow(p);
39190 }
39191 if (p->error_indicator) {
39192 p->level--;
39193 return NULL;
39194 }
39195 void * _res = NULL;
39196 int _mark = p->mark;
39197 { // NEWLINE
39198 if (p->error_indicator) {
39199 p->level--;
39200 return NULL;
39201 }
39202 D(fprintf(stderr, "%*c> _tmp_223[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
39203 Token * newline_var;
39204 if (
39205 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
39206 )
39207 {
39208 D(fprintf(stderr, "%*c+ _tmp_223[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
39209 _res = newline_var;
39210 goto done;
39211 }
39212 p->mark = _mark;
39213 D(fprintf(stderr, "%*c%s _tmp_223[%d-%d]: %s failed!\n", p->level, ' ',
39214 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
39215 }
39216 { // ':'
39217 if (p->error_indicator) {
39218 p->level--;
39219 return NULL;
39220 }
39221 D(fprintf(stderr, "%*c> _tmp_223[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
39222 Token * _literal;
39223 if (
39224 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
39225 )
39226 {
39227 D(fprintf(stderr, "%*c+ _tmp_223[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
39228 _res = _literal;
39229 goto done;
39230 }
39231 p->mark = _mark;
39232 D(fprintf(stderr, "%*c%s _tmp_223[%d-%d]: %s failed!\n", p->level, ' ',
39233 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
39234 }
39235 _res = NULL;
39236 done:
39237 p->level--;
39238 return _res;
39239 }
39240
39241 // _tmp_224: 'as' NAME
39242 static void *
39243 _tmp_224_rule(Parser *p)
39244 {
39245 if (p->level++ == MAXSTACK) {
39246 _Pypegen_stack_overflow(p);
39247 }
39248 if (p->error_indicator) {
39249 p->level--;
39250 return NULL;
39251 }
39252 void * _res = NULL;
39253 int _mark = p->mark;
39254 { // 'as' NAME
39255 if (p->error_indicator) {
39256 p->level--;
39257 return NULL;
39258 }
39259 D(fprintf(stderr, "%*c> _tmp_224[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
39260 Token * _keyword;
39261 expr_ty name_var;
39262 if (
39263 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
39264 &&
39265 (name_var = _PyPegen_name_token(p)) // NAME
39266 )
39267 {
39268 D(fprintf(stderr, "%*c+ _tmp_224[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
39269 _res = _PyPegen_dummy_name(p, _keyword, name_var);
39270 goto done;
39271 }
39272 p->mark = _mark;
39273 D(fprintf(stderr, "%*c%s _tmp_224[%d-%d]: %s failed!\n", p->level, ' ',
39274 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
39275 }
39276 _res = NULL;
39277 done:
39278 p->level--;
39279 return _res;
39280 }
39281
39282 // _tmp_225: 'as' NAME
39283 static void *
39284 _tmp_225_rule(Parser *p)
39285 {
39286 if (p->level++ == MAXSTACK) {
39287 _Pypegen_stack_overflow(p);
39288 }
39289 if (p->error_indicator) {
39290 p->level--;
39291 return NULL;
39292 }
39293 void * _res = NULL;
39294 int _mark = p->mark;
39295 { // 'as' NAME
39296 if (p->error_indicator) {
39297 p->level--;
39298 return NULL;
39299 }
39300 D(fprintf(stderr, "%*c> _tmp_225[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
39301 Token * _keyword;
39302 expr_ty name_var;
39303 if (
39304 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
39305 &&
39306 (name_var = _PyPegen_name_token(p)) // NAME
39307 )
39308 {
39309 D(fprintf(stderr, "%*c+ _tmp_225[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
39310 _res = _PyPegen_dummy_name(p, _keyword, name_var);
39311 goto done;
39312 }
39313 p->mark = _mark;
39314 D(fprintf(stderr, "%*c%s _tmp_225[%d-%d]: %s failed!\n", p->level, ' ',
39315 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
39316 }
39317 _res = NULL;
39318 done:
39319 p->level--;
39320 return _res;
39321 }
39322
39323 // _tmp_226: positional_patterns ','
39324 static void *
39325 _tmp_226_rule(Parser *p)
39326 {
39327 if (p->level++ == MAXSTACK) {
39328 _Pypegen_stack_overflow(p);
39329 }
39330 if (p->error_indicator) {
39331 p->level--;
39332 return NULL;
39333 }
39334 void * _res = NULL;
39335 int _mark = p->mark;
39336 { // positional_patterns ','
39337 if (p->error_indicator) {
39338 p->level--;
39339 return NULL;
39340 }
39341 D(fprintf(stderr, "%*c> _tmp_226[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','"));
39342 Token * _literal;
39343 asdl_pattern_seq* positional_patterns_var;
39344 if (
39345 (positional_patterns_var = positional_patterns_rule(p)) // positional_patterns
39346 &&
39347 (_literal = _PyPegen_expect_token(p, 12)) // token=','
39348 )
39349 {
39350 D(fprintf(stderr, "%*c+ _tmp_226[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','"));
39351 _res = _PyPegen_dummy_name(p, positional_patterns_var, _literal);
39352 goto done;
39353 }
39354 p->mark = _mark;
39355 D(fprintf(stderr, "%*c%s _tmp_226[%d-%d]: %s failed!\n", p->level, ' ',
39356 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','"));
39357 }
39358 _res = NULL;
39359 done:
39360 p->level--;
39361 return _res;
39362 }
39363
39364 // _tmp_227: '->' expression
39365 static void *
39366 _tmp_227_rule(Parser *p)
39367 {
39368 if (p->level++ == MAXSTACK) {
39369 _Pypegen_stack_overflow(p);
39370 }
39371 if (p->error_indicator) {
39372 p->level--;
39373 return NULL;
39374 }
39375 void * _res = NULL;
39376 int _mark = p->mark;
39377 { // '->' expression
39378 if (p->error_indicator) {
39379 p->level--;
39380 return NULL;
39381 }
39382 D(fprintf(stderr, "%*c> _tmp_227[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
39383 Token * _literal;
39384 expr_ty expression_var;
39385 if (
39386 (_literal = _PyPegen_expect_token(p, 51)) // token='->'
39387 &&
39388 (expression_var = expression_rule(p)) // expression
39389 )
39390 {
39391 D(fprintf(stderr, "%*c+ _tmp_227[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
39392 _res = _PyPegen_dummy_name(p, _literal, expression_var);
39393 goto done;
39394 }
39395 p->mark = _mark;
39396 D(fprintf(stderr, "%*c%s _tmp_227[%d-%d]: %s failed!\n", p->level, ' ',
39397 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));
39398 }
39399 _res = NULL;
39400 done:
39401 p->level--;
39402 return _res;
39403 }
39404
39405 // _tmp_228: '->' expression
39406 static void *
39407 _tmp_228_rule(Parser *p)
39408 {
39409 if (p->level++ == MAXSTACK) {
39410 _Pypegen_stack_overflow(p);
39411 }
39412 if (p->error_indicator) {
39413 p->level--;
39414 return NULL;
39415 }
39416 void * _res = NULL;
39417 int _mark = p->mark;
39418 { // '->' expression
39419 if (p->error_indicator) {
39420 p->level--;
39421 return NULL;
39422 }
39423 D(fprintf(stderr, "%*c> _tmp_228[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
39424 Token * _literal;
39425 expr_ty expression_var;
39426 if (
39427 (_literal = _PyPegen_expect_token(p, 51)) // token='->'
39428 &&
39429 (expression_var = expression_rule(p)) // expression
39430 )
39431 {
39432 D(fprintf(stderr, "%*c+ _tmp_228[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
39433 _res = _PyPegen_dummy_name(p, _literal, expression_var);
39434 goto done;
39435 }
39436 p->mark = _mark;
39437 D(fprintf(stderr, "%*c%s _tmp_228[%d-%d]: %s failed!\n", p->level, ' ',
39438 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));
39439 }
39440 _res = NULL;
39441 done:
39442 p->level--;
39443 return _res;
39444 }
39445
39446 // _tmp_229: '(' arguments? ')'
39447 static void *
39448 _tmp_229_rule(Parser *p)
39449 {
39450 if (p->level++ == MAXSTACK) {
39451 _Pypegen_stack_overflow(p);
39452 }
39453 if (p->error_indicator) {
39454 p->level--;
39455 return NULL;
39456 }
39457 void * _res = NULL;
39458 int _mark = p->mark;
39459 { // '(' arguments? ')'
39460 if (p->error_indicator) {
39461 p->level--;
39462 return NULL;
39463 }
39464 D(fprintf(stderr, "%*c> _tmp_229[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
39465 Token * _literal;
39466 Token * _literal_1;
39467 void *_opt_var;
39468 UNUSED(_opt_var); // Silence compiler warnings
39469 if (
39470 (_literal = _PyPegen_expect_token(p, 7)) // token='('
39471 &&
39472 (_opt_var = arguments_rule(p), !p->error_indicator) // arguments?
39473 &&
39474 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
39475 )
39476 {
39477 D(fprintf(stderr, "%*c+ _tmp_229[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
39478 _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1);
39479 goto done;
39480 }
39481 p->mark = _mark;
39482 D(fprintf(stderr, "%*c%s _tmp_229[%d-%d]: %s failed!\n", p->level, ' ',
39483 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'"));
39484 }
39485 _res = NULL;
39486 done:
39487 p->level--;
39488 return _res;
39489 }
39490
39491 // _tmp_230: '(' arguments? ')'
39492 static void *
39493 _tmp_230_rule(Parser *p)
39494 {
39495 if (p->level++ == MAXSTACK) {
39496 _Pypegen_stack_overflow(p);
39497 }
39498 if (p->error_indicator) {
39499 p->level--;
39500 return NULL;
39501 }
39502 void * _res = NULL;
39503 int _mark = p->mark;
39504 { // '(' arguments? ')'
39505 if (p->error_indicator) {
39506 p->level--;
39507 return NULL;
39508 }
39509 D(fprintf(stderr, "%*c> _tmp_230[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
39510 Token * _literal;
39511 Token * _literal_1;
39512 void *_opt_var;
39513 UNUSED(_opt_var); // Silence compiler warnings
39514 if (
39515 (_literal = _PyPegen_expect_token(p, 7)) // token='('
39516 &&
39517 (_opt_var = arguments_rule(p), !p->error_indicator) // arguments?
39518 &&
39519 (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')'
39520 )
39521 {
39522 D(fprintf(stderr, "%*c+ _tmp_230[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
39523 _res = _PyPegen_dummy_name(p, _literal, _opt_var, _literal_1);
39524 goto done;
39525 }
39526 p->mark = _mark;
39527 D(fprintf(stderr, "%*c%s _tmp_230[%d-%d]: %s failed!\n", p->level, ' ',
39528 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'"));
39529 }
39530 _res = NULL;
39531 done:
39532 p->level--;
39533 return _res;
39534 }
39535
39536 // _loop0_232: ',' double_starred_kvpair
39537 static asdl_seq *
39538 _loop0_232_rule(Parser *p)
39539 {
39540 if (p->level++ == MAXSTACK) {
39541 _Pypegen_stack_overflow(p);
39542 }
39543 if (p->error_indicator) {
39544 p->level--;
39545 return NULL;
39546 }
39547 void *_res = NULL;
39548 int _mark = p->mark;
39549 void **_children = PyMem_Malloc(sizeof(void *));
39550 if (!_children) {
39551 p->error_indicator = 1;
39552 PyErr_NoMemory();
39553 p->level--;
39554 return NULL;
39555 }
39556 Py_ssize_t _children_capacity = 1;
39557 Py_ssize_t _n = 0;
39558 { // ',' double_starred_kvpair
39559 if (p->error_indicator) {
39560 p->level--;
39561 return NULL;
39562 }
39563 D(fprintf(stderr, "%*c> _loop0_232[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair"));
39564 Token * _literal;
39565 KeyValuePair* elem;
39566 while (
39567 (_literal = _PyPegen_expect_token(p, 12)) // token=','
39568 &&
39569 (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
39570 )
39571 {
39572 _res = elem;
39573 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
39574 p->error_indicator = 1;
39575 PyMem_Free(_children);
39576 p->level--;
39577 return NULL;
39578 }
39579 if (_n == _children_capacity) {
39580 _children_capacity *= 2;
39581 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
39582 if (!_new_children) {
39583 PyMem_Free(_children);
39584 p->error_indicator = 1;
39585 PyErr_NoMemory();
39586 p->level--;
39587 return NULL;
39588 }
39589 _children = _new_children;
39590 }
39591 _children[_n++] = _res;
39592 _mark = p->mark;
39593 }
39594 p->mark = _mark;
39595 D(fprintf(stderr, "%*c%s _loop0_232[%d-%d]: %s failed!\n", p->level, ' ',
39596 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair"));
39597 }
39598 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
39599 if (!_seq) {
39600 PyMem_Free(_children);
39601 p->error_indicator = 1;
39602 PyErr_NoMemory();
39603 p->level--;
39604 return NULL;
39605 }
39606 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
39607 PyMem_Free(_children);
39608 p->level--;
39609 return _seq;
39610 }
39611
39612 // _gather_231: double_starred_kvpair _loop0_232
39613 static asdl_seq *
39614 _gather_231_rule(Parser *p)
39615 {
39616 if (p->level++ == MAXSTACK) {
39617 _Pypegen_stack_overflow(p);
39618 }
39619 if (p->error_indicator) {
39620 p->level--;
39621 return NULL;
39622 }
39623 asdl_seq * _res = NULL;
39624 int _mark = p->mark;
39625 { // double_starred_kvpair _loop0_232
39626 if (p->error_indicator) {
39627 p->level--;
39628 return NULL;
39629 }
39630 D(fprintf(stderr, "%*c> _gather_231[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_232"));
39631 KeyValuePair* elem;
39632 asdl_seq * seq;
39633 if (
39634 (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair
39635 &&
39636 (seq = _loop0_232_rule(p)) // _loop0_232
39637 )
39638 {
39639 D(fprintf(stderr, "%*c+ _gather_231[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_232"));
39640 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
39641 goto done;
39642 }
39643 p->mark = _mark;
39644 D(fprintf(stderr, "%*c%s _gather_231[%d-%d]: %s failed!\n", p->level, ' ',
39645 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_232"));
39646 }
39647 _res = NULL;
39648 done:
39649 p->level--;
39650 return _res;
39651 }
39652
39653 // _tmp_233: '}' | ','
39654 static void *
39655 _tmp_233_rule(Parser *p)
39656 {
39657 if (p->level++ == MAXSTACK) {
39658 _Pypegen_stack_overflow(p);
39659 }
39660 if (p->error_indicator) {
39661 p->level--;
39662 return NULL;
39663 }
39664 void * _res = NULL;
39665 int _mark = p->mark;
39666 { // '}'
39667 if (p->error_indicator) {
39668 p->level--;
39669 return NULL;
39670 }
39671 D(fprintf(stderr, "%*c> _tmp_233[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
39672 Token * _literal;
39673 if (
39674 (_literal = _PyPegen_expect_token(p, 26)) // token='}'
39675 )
39676 {
39677 D(fprintf(stderr, "%*c+ _tmp_233[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'"));
39678 _res = _literal;
39679 goto done;
39680 }
39681 p->mark = _mark;
39682 D(fprintf(stderr, "%*c%s _tmp_233[%d-%d]: %s failed!\n", p->level, ' ',
39683 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
39684 }
39685 { // ','
39686 if (p->error_indicator) {
39687 p->level--;
39688 return NULL;
39689 }
39690 D(fprintf(stderr, "%*c> _tmp_233[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
39691 Token * _literal;
39692 if (
39693 (_literal = _PyPegen_expect_token(p, 12)) // token=','
39694 )
39695 {
39696 D(fprintf(stderr, "%*c+ _tmp_233[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
39697 _res = _literal;
39698 goto done;
39699 }
39700 p->mark = _mark;
39701 D(fprintf(stderr, "%*c%s _tmp_233[%d-%d]: %s failed!\n", p->level, ' ',
39702 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
39703 }
39704 _res = NULL;
39705 done:
39706 p->level--;
39707 return _res;
39708 }
39709
39710 // _tmp_234: '}' | ','
39711 static void *
39712 _tmp_234_rule(Parser *p)
39713 {
39714 if (p->level++ == MAXSTACK) {
39715 _Pypegen_stack_overflow(p);
39716 }
39717 if (p->error_indicator) {
39718 p->level--;
39719 return NULL;
39720 }
39721 void * _res = NULL;
39722 int _mark = p->mark;
39723 { // '}'
39724 if (p->error_indicator) {
39725 p->level--;
39726 return NULL;
39727 }
39728 D(fprintf(stderr, "%*c> _tmp_234[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
39729 Token * _literal;
39730 if (
39731 (_literal = _PyPegen_expect_token(p, 26)) // token='}'
39732 )
39733 {
39734 D(fprintf(stderr, "%*c+ _tmp_234[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'"));
39735 _res = _literal;
39736 goto done;
39737 }
39738 p->mark = _mark;
39739 D(fprintf(stderr, "%*c%s _tmp_234[%d-%d]: %s failed!\n", p->level, ' ',
39740 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
39741 }
39742 { // ','
39743 if (p->error_indicator) {
39744 p->level--;
39745 return NULL;
39746 }
39747 D(fprintf(stderr, "%*c> _tmp_234[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
39748 Token * _literal;
39749 if (
39750 (_literal = _PyPegen_expect_token(p, 12)) // token=','
39751 )
39752 {
39753 D(fprintf(stderr, "%*c+ _tmp_234[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
39754 _res = _literal;
39755 goto done;
39756 }
39757 p->mark = _mark;
39758 D(fprintf(stderr, "%*c%s _tmp_234[%d-%d]: %s failed!\n", p->level, ' ',
39759 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
39760 }
39761 _res = NULL;
39762 done:
39763 p->level--;
39764 return _res;
39765 }
39766
39767 // _tmp_235: '=' | '!' | ':' | '}'
39768 static void *
39769 _tmp_235_rule(Parser *p)
39770 {
39771 if (p->level++ == MAXSTACK) {
39772 _Pypegen_stack_overflow(p);
39773 }
39774 if (p->error_indicator) {
39775 p->level--;
39776 return NULL;
39777 }
39778 void * _res = NULL;
39779 int _mark = p->mark;
39780 { // '='
39781 if (p->error_indicator) {
39782 p->level--;
39783 return NULL;
39784 }
39785 D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='"));
39786 Token * _literal;
39787 if (
39788 (_literal = _PyPegen_expect_token(p, 22)) // token='='
39789 )
39790 {
39791 D(fprintf(stderr, "%*c+ _tmp_235[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='"));
39792 _res = _literal;
39793 goto done;
39794 }
39795 p->mark = _mark;
39796 D(fprintf(stderr, "%*c%s _tmp_235[%d-%d]: %s failed!\n", p->level, ' ',
39797 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
39798 }
39799 { // '!'
39800 if (p->error_indicator) {
39801 p->level--;
39802 return NULL;
39803 }
39804 D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'"));
39805 Token * _literal;
39806 if (
39807 (_literal = _PyPegen_expect_token(p, 54)) // token='!'
39808 )
39809 {
39810 D(fprintf(stderr, "%*c+ _tmp_235[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'"));
39811 _res = _literal;
39812 goto done;
39813 }
39814 p->mark = _mark;
39815 D(fprintf(stderr, "%*c%s _tmp_235[%d-%d]: %s failed!\n", p->level, ' ',
39816 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'"));
39817 }
39818 { // ':'
39819 if (p->error_indicator) {
39820 p->level--;
39821 return NULL;
39822 }
39823 D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
39824 Token * _literal;
39825 if (
39826 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
39827 )
39828 {
39829 D(fprintf(stderr, "%*c+ _tmp_235[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
39830 _res = _literal;
39831 goto done;
39832 }
39833 p->mark = _mark;
39834 D(fprintf(stderr, "%*c%s _tmp_235[%d-%d]: %s failed!\n", p->level, ' ',
39835 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
39836 }
39837 { // '}'
39838 if (p->error_indicator) {
39839 p->level--;
39840 return NULL;
39841 }
39842 D(fprintf(stderr, "%*c> _tmp_235[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
39843 Token * _literal;
39844 if (
39845 (_literal = _PyPegen_expect_token(p, 26)) // token='}'
39846 )
39847 {
39848 D(fprintf(stderr, "%*c+ _tmp_235[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'"));
39849 _res = _literal;
39850 goto done;
39851 }
39852 p->mark = _mark;
39853 D(fprintf(stderr, "%*c%s _tmp_235[%d-%d]: %s failed!\n", p->level, ' ',
39854 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
39855 }
39856 _res = NULL;
39857 done:
39858 p->level--;
39859 return _res;
39860 }
39861
39862 // _tmp_236: '!' | ':' | '}'
39863 static void *
39864 _tmp_236_rule(Parser *p)
39865 {
39866 if (p->level++ == MAXSTACK) {
39867 _Pypegen_stack_overflow(p);
39868 }
39869 if (p->error_indicator) {
39870 p->level--;
39871 return NULL;
39872 }
39873 void * _res = NULL;
39874 int _mark = p->mark;
39875 { // '!'
39876 if (p->error_indicator) {
39877 p->level--;
39878 return NULL;
39879 }
39880 D(fprintf(stderr, "%*c> _tmp_236[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'"));
39881 Token * _literal;
39882 if (
39883 (_literal = _PyPegen_expect_token(p, 54)) // token='!'
39884 )
39885 {
39886 D(fprintf(stderr, "%*c+ _tmp_236[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'"));
39887 _res = _literal;
39888 goto done;
39889 }
39890 p->mark = _mark;
39891 D(fprintf(stderr, "%*c%s _tmp_236[%d-%d]: %s failed!\n", p->level, ' ',
39892 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'"));
39893 }
39894 { // ':'
39895 if (p->error_indicator) {
39896 p->level--;
39897 return NULL;
39898 }
39899 D(fprintf(stderr, "%*c> _tmp_236[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
39900 Token * _literal;
39901 if (
39902 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
39903 )
39904 {
39905 D(fprintf(stderr, "%*c+ _tmp_236[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
39906 _res = _literal;
39907 goto done;
39908 }
39909 p->mark = _mark;
39910 D(fprintf(stderr, "%*c%s _tmp_236[%d-%d]: %s failed!\n", p->level, ' ',
39911 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
39912 }
39913 { // '}'
39914 if (p->error_indicator) {
39915 p->level--;
39916 return NULL;
39917 }
39918 D(fprintf(stderr, "%*c> _tmp_236[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
39919 Token * _literal;
39920 if (
39921 (_literal = _PyPegen_expect_token(p, 26)) // token='}'
39922 )
39923 {
39924 D(fprintf(stderr, "%*c+ _tmp_236[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'"));
39925 _res = _literal;
39926 goto done;
39927 }
39928 p->mark = _mark;
39929 D(fprintf(stderr, "%*c%s _tmp_236[%d-%d]: %s failed!\n", p->level, ' ',
39930 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
39931 }
39932 _res = NULL;
39933 done:
39934 p->level--;
39935 return _res;
39936 }
39937
39938 // _tmp_237: '!' NAME
39939 static void *
39940 _tmp_237_rule(Parser *p)
39941 {
39942 if (p->level++ == MAXSTACK) {
39943 _Pypegen_stack_overflow(p);
39944 }
39945 if (p->error_indicator) {
39946 p->level--;
39947 return NULL;
39948 }
39949 void * _res = NULL;
39950 int _mark = p->mark;
39951 { // '!' NAME
39952 if (p->error_indicator) {
39953 p->level--;
39954 return NULL;
39955 }
39956 D(fprintf(stderr, "%*c> _tmp_237[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME"));
39957 Token * _literal;
39958 expr_ty name_var;
39959 if (
39960 (_literal = _PyPegen_expect_token(p, 54)) // token='!'
39961 &&
39962 (name_var = _PyPegen_name_token(p)) // NAME
39963 )
39964 {
39965 D(fprintf(stderr, "%*c+ _tmp_237[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME"));
39966 _res = _PyPegen_dummy_name(p, _literal, name_var);
39967 goto done;
39968 }
39969 p->mark = _mark;
39970 D(fprintf(stderr, "%*c%s _tmp_237[%d-%d]: %s failed!\n", p->level, ' ',
39971 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' NAME"));
39972 }
39973 _res = NULL;
39974 done:
39975 p->level--;
39976 return _res;
39977 }
39978
39979 // _tmp_238: ':' | '}'
39980 static void *
39981 _tmp_238_rule(Parser *p)
39982 {
39983 if (p->level++ == MAXSTACK) {
39984 _Pypegen_stack_overflow(p);
39985 }
39986 if (p->error_indicator) {
39987 p->level--;
39988 return NULL;
39989 }
39990 void * _res = NULL;
39991 int _mark = p->mark;
39992 { // ':'
39993 if (p->error_indicator) {
39994 p->level--;
39995 return NULL;
39996 }
39997 D(fprintf(stderr, "%*c> _tmp_238[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
39998 Token * _literal;
39999 if (
40000 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
40001 )
40002 {
40003 D(fprintf(stderr, "%*c+ _tmp_238[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
40004 _res = _literal;
40005 goto done;
40006 }
40007 p->mark = _mark;
40008 D(fprintf(stderr, "%*c%s _tmp_238[%d-%d]: %s failed!\n", p->level, ' ',
40009 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
40010 }
40011 { // '}'
40012 if (p->error_indicator) {
40013 p->level--;
40014 return NULL;
40015 }
40016 D(fprintf(stderr, "%*c> _tmp_238[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
40017 Token * _literal;
40018 if (
40019 (_literal = _PyPegen_expect_token(p, 26)) // token='}'
40020 )
40021 {
40022 D(fprintf(stderr, "%*c+ _tmp_238[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'"));
40023 _res = _literal;
40024 goto done;
40025 }
40026 p->mark = _mark;
40027 D(fprintf(stderr, "%*c%s _tmp_238[%d-%d]: %s failed!\n", p->level, ' ',
40028 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
40029 }
40030 _res = NULL;
40031 done:
40032 p->level--;
40033 return _res;
40034 }
40035
40036 // _tmp_239: '!' NAME
40037 static void *
40038 _tmp_239_rule(Parser *p)
40039 {
40040 if (p->level++ == MAXSTACK) {
40041 _Pypegen_stack_overflow(p);
40042 }
40043 if (p->error_indicator) {
40044 p->level--;
40045 return NULL;
40046 }
40047 void * _res = NULL;
40048 int _mark = p->mark;
40049 { // '!' NAME
40050 if (p->error_indicator) {
40051 p->level--;
40052 return NULL;
40053 }
40054 D(fprintf(stderr, "%*c> _tmp_239[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME"));
40055 Token * _literal;
40056 expr_ty name_var;
40057 if (
40058 (_literal = _PyPegen_expect_token(p, 54)) // token='!'
40059 &&
40060 (name_var = _PyPegen_name_token(p)) // NAME
40061 )
40062 {
40063 D(fprintf(stderr, "%*c+ _tmp_239[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME"));
40064 _res = _PyPegen_dummy_name(p, _literal, name_var);
40065 goto done;
40066 }
40067 p->mark = _mark;
40068 D(fprintf(stderr, "%*c%s _tmp_239[%d-%d]: %s failed!\n", p->level, ' ',
40069 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' NAME"));
40070 }
40071 _res = NULL;
40072 done:
40073 p->level--;
40074 return _res;
40075 }
40076
40077 // _loop0_240: fstring_format_spec
40078 static asdl_seq *
40079 _loop0_240_rule(Parser *p)
40080 {
40081 if (p->level++ == MAXSTACK) {
40082 _Pypegen_stack_overflow(p);
40083 }
40084 if (p->error_indicator) {
40085 p->level--;
40086 return NULL;
40087 }
40088 void *_res = NULL;
40089 int _mark = p->mark;
40090 void **_children = PyMem_Malloc(sizeof(void *));
40091 if (!_children) {
40092 p->error_indicator = 1;
40093 PyErr_NoMemory();
40094 p->level--;
40095 return NULL;
40096 }
40097 Py_ssize_t _children_capacity = 1;
40098 Py_ssize_t _n = 0;
40099 { // fstring_format_spec
40100 if (p->error_indicator) {
40101 p->level--;
40102 return NULL;
40103 }
40104 D(fprintf(stderr, "%*c> _loop0_240[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec"));
40105 expr_ty fstring_format_spec_var;
40106 while (
40107 (fstring_format_spec_var = fstring_format_spec_rule(p)) // fstring_format_spec
40108 )
40109 {
40110 _res = fstring_format_spec_var;
40111 if (_n == _children_capacity) {
40112 _children_capacity *= 2;
40113 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
40114 if (!_new_children) {
40115 PyMem_Free(_children);
40116 p->error_indicator = 1;
40117 PyErr_NoMemory();
40118 p->level--;
40119 return NULL;
40120 }
40121 _children = _new_children;
40122 }
40123 _children[_n++] = _res;
40124 _mark = p->mark;
40125 }
40126 p->mark = _mark;
40127 D(fprintf(stderr, "%*c%s _loop0_240[%d-%d]: %s failed!\n", p->level, ' ',
40128 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_format_spec"));
40129 }
40130 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
40131 if (!_seq) {
40132 PyMem_Free(_children);
40133 p->error_indicator = 1;
40134 PyErr_NoMemory();
40135 p->level--;
40136 return NULL;
40137 }
40138 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
40139 PyMem_Free(_children);
40140 p->level--;
40141 return _seq;
40142 }
40143
40144 // _tmp_241: '!' NAME
40145 static void *
40146 _tmp_241_rule(Parser *p)
40147 {
40148 if (p->level++ == MAXSTACK) {
40149 _Pypegen_stack_overflow(p);
40150 }
40151 if (p->error_indicator) {
40152 p->level--;
40153 return NULL;
40154 }
40155 void * _res = NULL;
40156 int _mark = p->mark;
40157 { // '!' NAME
40158 if (p->error_indicator) {
40159 p->level--;
40160 return NULL;
40161 }
40162 D(fprintf(stderr, "%*c> _tmp_241[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME"));
40163 Token * _literal;
40164 expr_ty name_var;
40165 if (
40166 (_literal = _PyPegen_expect_token(p, 54)) // token='!'
40167 &&
40168 (name_var = _PyPegen_name_token(p)) // NAME
40169 )
40170 {
40171 D(fprintf(stderr, "%*c+ _tmp_241[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME"));
40172 _res = _PyPegen_dummy_name(p, _literal, name_var);
40173 goto done;
40174 }
40175 p->mark = _mark;
40176 D(fprintf(stderr, "%*c%s _tmp_241[%d-%d]: %s failed!\n", p->level, ' ',
40177 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' NAME"));
40178 }
40179 _res = NULL;
40180 done:
40181 p->level--;
40182 return _res;
40183 }
40184
40185 // _tmp_242: ':' | '}'
40186 static void *
40187 _tmp_242_rule(Parser *p)
40188 {
40189 if (p->level++ == MAXSTACK) {
40190 _Pypegen_stack_overflow(p);
40191 }
40192 if (p->error_indicator) {
40193 p->level--;
40194 return NULL;
40195 }
40196 void * _res = NULL;
40197 int _mark = p->mark;
40198 { // ':'
40199 if (p->error_indicator) {
40200 p->level--;
40201 return NULL;
40202 }
40203 D(fprintf(stderr, "%*c> _tmp_242[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
40204 Token * _literal;
40205 if (
40206 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
40207 )
40208 {
40209 D(fprintf(stderr, "%*c+ _tmp_242[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
40210 _res = _literal;
40211 goto done;
40212 }
40213 p->mark = _mark;
40214 D(fprintf(stderr, "%*c%s _tmp_242[%d-%d]: %s failed!\n", p->level, ' ',
40215 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
40216 }
40217 { // '}'
40218 if (p->error_indicator) {
40219 p->level--;
40220 return NULL;
40221 }
40222 D(fprintf(stderr, "%*c> _tmp_242[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'"));
40223 Token * _literal;
40224 if (
40225 (_literal = _PyPegen_expect_token(p, 26)) // token='}'
40226 )
40227 {
40228 D(fprintf(stderr, "%*c+ _tmp_242[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'"));
40229 _res = _literal;
40230 goto done;
40231 }
40232 p->mark = _mark;
40233 D(fprintf(stderr, "%*c%s _tmp_242[%d-%d]: %s failed!\n", p->level, ' ',
40234 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
40235 }
40236 _res = NULL;
40237 done:
40238 p->level--;
40239 return _res;
40240 }
40241
40242 // _tmp_243: '+' | '-' | '*' | '/' | '%' | '//' | '@'
40243 static void *
40244 _tmp_243_rule(Parser *p)
40245 {
40246 if (p->level++ == MAXSTACK) {
40247 _Pypegen_stack_overflow(p);
40248 }
40249 if (p->error_indicator) {
40250 p->level--;
40251 return NULL;
40252 }
40253 void * _res = NULL;
40254 int _mark = p->mark;
40255 { // '+'
40256 if (p->error_indicator) {
40257 p->level--;
40258 return NULL;
40259 }
40260 D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'"));
40261 Token * _literal;
40262 if (
40263 (_literal = _PyPegen_expect_token(p, 14)) // token='+'
40264 )
40265 {
40266 D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'"));
40267 _res = _literal;
40268 goto done;
40269 }
40270 p->mark = _mark;
40271 D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ',
40272 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));
40273 }
40274 { // '-'
40275 if (p->error_indicator) {
40276 p->level--;
40277 return NULL;
40278 }
40279 D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'"));
40280 Token * _literal;
40281 if (
40282 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
40283 )
40284 {
40285 D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'"));
40286 _res = _literal;
40287 goto done;
40288 }
40289 p->mark = _mark;
40290 D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ',
40291 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));
40292 }
40293 { // '*'
40294 if (p->error_indicator) {
40295 p->level--;
40296 return NULL;
40297 }
40298 D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
40299 Token * _literal;
40300 if (
40301 (_literal = _PyPegen_expect_token(p, 16)) // token='*'
40302 )
40303 {
40304 D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'"));
40305 _res = _literal;
40306 goto done;
40307 }
40308 p->mark = _mark;
40309 D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ',
40310 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));
40311 }
40312 { // '/'
40313 if (p->error_indicator) {
40314 p->level--;
40315 return NULL;
40316 }
40317 D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'"));
40318 Token * _literal;
40319 if (
40320 (_literal = _PyPegen_expect_token(p, 17)) // token='/'
40321 )
40322 {
40323 D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'"));
40324 _res = _literal;
40325 goto done;
40326 }
40327 p->mark = _mark;
40328 D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ',
40329 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'"));
40330 }
40331 { // '%'
40332 if (p->error_indicator) {
40333 p->level--;
40334 return NULL;
40335 }
40336 D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'"));
40337 Token * _literal;
40338 if (
40339 (_literal = _PyPegen_expect_token(p, 24)) // token='%'
40340 )
40341 {
40342 D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'"));
40343 _res = _literal;
40344 goto done;
40345 }
40346 p->mark = _mark;
40347 D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ',
40348 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%'"));
40349 }
40350 { // '//'
40351 if (p->error_indicator) {
40352 p->level--;
40353 return NULL;
40354 }
40355 D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'"));
40356 Token * _literal;
40357 if (
40358 (_literal = _PyPegen_expect_token(p, 47)) // token='//'
40359 )
40360 {
40361 D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'"));
40362 _res = _literal;
40363 goto done;
40364 }
40365 p->mark = _mark;
40366 D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ',
40367 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//'"));
40368 }
40369 { // '@'
40370 if (p->error_indicator) {
40371 p->level--;
40372 return NULL;
40373 }
40374 D(fprintf(stderr, "%*c> _tmp_243[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
40375 Token * _literal;
40376 if (
40377 (_literal = _PyPegen_expect_token(p, 49)) // token='@'
40378 )
40379 {
40380 D(fprintf(stderr, "%*c+ _tmp_243[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
40381 _res = _literal;
40382 goto done;
40383 }
40384 p->mark = _mark;
40385 D(fprintf(stderr, "%*c%s _tmp_243[%d-%d]: %s failed!\n", p->level, ' ',
40386 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
40387 }
40388 _res = NULL;
40389 done:
40390 p->level--;
40391 return _res;
40392 }
40393
40394 // _tmp_244: '+' | '-' | '~'
40395 static void *
40396 _tmp_244_rule(Parser *p)
40397 {
40398 if (p->level++ == MAXSTACK) {
40399 _Pypegen_stack_overflow(p);
40400 }
40401 if (p->error_indicator) {
40402 p->level--;
40403 return NULL;
40404 }
40405 void * _res = NULL;
40406 int _mark = p->mark;
40407 { // '+'
40408 if (p->error_indicator) {
40409 p->level--;
40410 return NULL;
40411 }
40412 D(fprintf(stderr, "%*c> _tmp_244[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'"));
40413 Token * _literal;
40414 if (
40415 (_literal = _PyPegen_expect_token(p, 14)) // token='+'
40416 )
40417 {
40418 D(fprintf(stderr, "%*c+ _tmp_244[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'"));
40419 _res = _literal;
40420 goto done;
40421 }
40422 p->mark = _mark;
40423 D(fprintf(stderr, "%*c%s _tmp_244[%d-%d]: %s failed!\n", p->level, ' ',
40424 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));
40425 }
40426 { // '-'
40427 if (p->error_indicator) {
40428 p->level--;
40429 return NULL;
40430 }
40431 D(fprintf(stderr, "%*c> _tmp_244[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'"));
40432 Token * _literal;
40433 if (
40434 (_literal = _PyPegen_expect_token(p, 15)) // token='-'
40435 )
40436 {
40437 D(fprintf(stderr, "%*c+ _tmp_244[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'"));
40438 _res = _literal;
40439 goto done;
40440 }
40441 p->mark = _mark;
40442 D(fprintf(stderr, "%*c%s _tmp_244[%d-%d]: %s failed!\n", p->level, ' ',
40443 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));
40444 }
40445 { // '~'
40446 if (p->error_indicator) {
40447 p->level--;
40448 return NULL;
40449 }
40450 D(fprintf(stderr, "%*c> _tmp_244[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'"));
40451 Token * _literal;
40452 if (
40453 (_literal = _PyPegen_expect_token(p, 31)) // token='~'
40454 )
40455 {
40456 D(fprintf(stderr, "%*c+ _tmp_244[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'"));
40457 _res = _literal;
40458 goto done;
40459 }
40460 p->mark = _mark;
40461 D(fprintf(stderr, "%*c%s _tmp_244[%d-%d]: %s failed!\n", p->level, ' ',
40462 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~'"));
40463 }
40464 _res = NULL;
40465 done:
40466 p->level--;
40467 return _res;
40468 }
40469
40470 // _tmp_245: star_targets '='
40471 static void *
40472 _tmp_245_rule(Parser *p)
40473 {
40474 if (p->level++ == MAXSTACK) {
40475 _Pypegen_stack_overflow(p);
40476 }
40477 if (p->error_indicator) {
40478 p->level--;
40479 return NULL;
40480 }
40481 void * _res = NULL;
40482 int _mark = p->mark;
40483 { // star_targets '='
40484 if (p->error_indicator) {
40485 p->level--;
40486 return NULL;
40487 }
40488 D(fprintf(stderr, "%*c> _tmp_245[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
40489 Token * _literal;
40490 expr_ty z;
40491 if (
40492 (z = star_targets_rule(p)) // star_targets
40493 &&
40494 (_literal = _PyPegen_expect_token(p, 22)) // token='='
40495 )
40496 {
40497 D(fprintf(stderr, "%*c+ _tmp_245[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
40498 _res = z;
40499 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
40500 p->error_indicator = 1;
40501 p->level--;
40502 return NULL;
40503 }
40504 goto done;
40505 }
40506 p->mark = _mark;
40507 D(fprintf(stderr, "%*c%s _tmp_245[%d-%d]: %s failed!\n", p->level, ' ',
40508 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));
40509 }
40510 _res = NULL;
40511 done:
40512 p->level--;
40513 return _res;
40514 }
40515
40516 // _tmp_246: '.' | '...'
40517 static void *
40518 _tmp_246_rule(Parser *p)
40519 {
40520 if (p->level++ == MAXSTACK) {
40521 _Pypegen_stack_overflow(p);
40522 }
40523 if (p->error_indicator) {
40524 p->level--;
40525 return NULL;
40526 }
40527 void * _res = NULL;
40528 int _mark = p->mark;
40529 { // '.'
40530 if (p->error_indicator) {
40531 p->level--;
40532 return NULL;
40533 }
40534 D(fprintf(stderr, "%*c> _tmp_246[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
40535 Token * _literal;
40536 if (
40537 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
40538 )
40539 {
40540 D(fprintf(stderr, "%*c+ _tmp_246[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
40541 _res = _literal;
40542 goto done;
40543 }
40544 p->mark = _mark;
40545 D(fprintf(stderr, "%*c%s _tmp_246[%d-%d]: %s failed!\n", p->level, ' ',
40546 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
40547 }
40548 { // '...'
40549 if (p->error_indicator) {
40550 p->level--;
40551 return NULL;
40552 }
40553 D(fprintf(stderr, "%*c> _tmp_246[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
40554 Token * _literal;
40555 if (
40556 (_literal = _PyPegen_expect_token(p, 52)) // token='...'
40557 )
40558 {
40559 D(fprintf(stderr, "%*c+ _tmp_246[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
40560 _res = _literal;
40561 goto done;
40562 }
40563 p->mark = _mark;
40564 D(fprintf(stderr, "%*c%s _tmp_246[%d-%d]: %s failed!\n", p->level, ' ',
40565 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
40566 }
40567 _res = NULL;
40568 done:
40569 p->level--;
40570 return _res;
40571 }
40572
40573 // _tmp_247: '.' | '...'
40574 static void *
40575 _tmp_247_rule(Parser *p)
40576 {
40577 if (p->level++ == MAXSTACK) {
40578 _Pypegen_stack_overflow(p);
40579 }
40580 if (p->error_indicator) {
40581 p->level--;
40582 return NULL;
40583 }
40584 void * _res = NULL;
40585 int _mark = p->mark;
40586 { // '.'
40587 if (p->error_indicator) {
40588 p->level--;
40589 return NULL;
40590 }
40591 D(fprintf(stderr, "%*c> _tmp_247[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
40592 Token * _literal;
40593 if (
40594 (_literal = _PyPegen_expect_token(p, 23)) // token='.'
40595 )
40596 {
40597 D(fprintf(stderr, "%*c+ _tmp_247[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
40598 _res = _literal;
40599 goto done;
40600 }
40601 p->mark = _mark;
40602 D(fprintf(stderr, "%*c%s _tmp_247[%d-%d]: %s failed!\n", p->level, ' ',
40603 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
40604 }
40605 { // '...'
40606 if (p->error_indicator) {
40607 p->level--;
40608 return NULL;
40609 }
40610 D(fprintf(stderr, "%*c> _tmp_247[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
40611 Token * _literal;
40612 if (
40613 (_literal = _PyPegen_expect_token(p, 52)) // token='...'
40614 )
40615 {
40616 D(fprintf(stderr, "%*c+ _tmp_247[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
40617 _res = _literal;
40618 goto done;
40619 }
40620 p->mark = _mark;
40621 D(fprintf(stderr, "%*c%s _tmp_247[%d-%d]: %s failed!\n", p->level, ' ',
40622 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
40623 }
40624 _res = NULL;
40625 done:
40626 p->level--;
40627 return _res;
40628 }
40629
40630 // _tmp_248: '@' named_expression NEWLINE
40631 static void *
40632 _tmp_248_rule(Parser *p)
40633 {
40634 if (p->level++ == MAXSTACK) {
40635 _Pypegen_stack_overflow(p);
40636 }
40637 if (p->error_indicator) {
40638 p->level--;
40639 return NULL;
40640 }
40641 void * _res = NULL;
40642 int _mark = p->mark;
40643 { // '@' named_expression NEWLINE
40644 if (p->error_indicator) {
40645 p->level--;
40646 return NULL;
40647 }
40648 D(fprintf(stderr, "%*c> _tmp_248[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE"));
40649 Token * _literal;
40650 expr_ty f;
40651 Token * newline_var;
40652 if (
40653 (_literal = _PyPegen_expect_token(p, 49)) // token='@'
40654 &&
40655 (f = named_expression_rule(p)) // named_expression
40656 &&
40657 (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE'
40658 )
40659 {
40660 D(fprintf(stderr, "%*c+ _tmp_248[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE"));
40661 _res = f;
40662 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
40663 p->error_indicator = 1;
40664 p->level--;
40665 return NULL;
40666 }
40667 goto done;
40668 }
40669 p->mark = _mark;
40670 D(fprintf(stderr, "%*c%s _tmp_248[%d-%d]: %s failed!\n", p->level, ' ',
40671 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE"));
40672 }
40673 _res = NULL;
40674 done:
40675 p->level--;
40676 return _res;
40677 }
40678
40679 // _tmp_249: ',' expression
40680 static void *
40681 _tmp_249_rule(Parser *p)
40682 {
40683 if (p->level++ == MAXSTACK) {
40684 _Pypegen_stack_overflow(p);
40685 }
40686 if (p->error_indicator) {
40687 p->level--;
40688 return NULL;
40689 }
40690 void * _res = NULL;
40691 int _mark = p->mark;
40692 { // ',' expression
40693 if (p->error_indicator) {
40694 p->level--;
40695 return NULL;
40696 }
40697 D(fprintf(stderr, "%*c> _tmp_249[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
40698 Token * _literal;
40699 expr_ty c;
40700 if (
40701 (_literal = _PyPegen_expect_token(p, 12)) // token=','
40702 &&
40703 (c = expression_rule(p)) // expression
40704 )
40705 {
40706 D(fprintf(stderr, "%*c+ _tmp_249[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression"));
40707 _res = c;
40708 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
40709 p->error_indicator = 1;
40710 p->level--;
40711 return NULL;
40712 }
40713 goto done;
40714 }
40715 p->mark = _mark;
40716 D(fprintf(stderr, "%*c%s _tmp_249[%d-%d]: %s failed!\n", p->level, ' ',
40717 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
40718 }
40719 _res = NULL;
40720 done:
40721 p->level--;
40722 return _res;
40723 }
40724
40725 // _tmp_250: ',' star_expression
40726 static void *
40727 _tmp_250_rule(Parser *p)
40728 {
40729 if (p->level++ == MAXSTACK) {
40730 _Pypegen_stack_overflow(p);
40731 }
40732 if (p->error_indicator) {
40733 p->level--;
40734 return NULL;
40735 }
40736 void * _res = NULL;
40737 int _mark = p->mark;
40738 { // ',' star_expression
40739 if (p->error_indicator) {
40740 p->level--;
40741 return NULL;
40742 }
40743 D(fprintf(stderr, "%*c> _tmp_250[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression"));
40744 Token * _literal;
40745 expr_ty c;
40746 if (
40747 (_literal = _PyPegen_expect_token(p, 12)) // token=','
40748 &&
40749 (c = star_expression_rule(p)) // star_expression
40750 )
40751 {
40752 D(fprintf(stderr, "%*c+ _tmp_250[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression"));
40753 _res = c;
40754 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
40755 p->error_indicator = 1;
40756 p->level--;
40757 return NULL;
40758 }
40759 goto done;
40760 }
40761 p->mark = _mark;
40762 D(fprintf(stderr, "%*c%s _tmp_250[%d-%d]: %s failed!\n", p->level, ' ',
40763 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression"));
40764 }
40765 _res = NULL;
40766 done:
40767 p->level--;
40768 return _res;
40769 }
40770
40771 // _tmp_251: 'or' conjunction
40772 static void *
40773 _tmp_251_rule(Parser *p)
40774 {
40775 if (p->level++ == MAXSTACK) {
40776 _Pypegen_stack_overflow(p);
40777 }
40778 if (p->error_indicator) {
40779 p->level--;
40780 return NULL;
40781 }
40782 void * _res = NULL;
40783 int _mark = p->mark;
40784 { // 'or' conjunction
40785 if (p->error_indicator) {
40786 p->level--;
40787 return NULL;
40788 }
40789 D(fprintf(stderr, "%*c> _tmp_251[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction"));
40790 Token * _keyword;
40791 expr_ty c;
40792 if (
40793 (_keyword = _PyPegen_expect_token(p, 581)) // token='or'
40794 &&
40795 (c = conjunction_rule(p)) // conjunction
40796 )
40797 {
40798 D(fprintf(stderr, "%*c+ _tmp_251[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction"));
40799 _res = c;
40800 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
40801 p->error_indicator = 1;
40802 p->level--;
40803 return NULL;
40804 }
40805 goto done;
40806 }
40807 p->mark = _mark;
40808 D(fprintf(stderr, "%*c%s _tmp_251[%d-%d]: %s failed!\n", p->level, ' ',
40809 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction"));
40810 }
40811 _res = NULL;
40812 done:
40813 p->level--;
40814 return _res;
40815 }
40816
40817 // _tmp_252: 'and' inversion
40818 static void *
40819 _tmp_252_rule(Parser *p)
40820 {
40821 if (p->level++ == MAXSTACK) {
40822 _Pypegen_stack_overflow(p);
40823 }
40824 if (p->error_indicator) {
40825 p->level--;
40826 return NULL;
40827 }
40828 void * _res = NULL;
40829 int _mark = p->mark;
40830 { // 'and' inversion
40831 if (p->error_indicator) {
40832 p->level--;
40833 return NULL;
40834 }
40835 D(fprintf(stderr, "%*c> _tmp_252[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion"));
40836 Token * _keyword;
40837 expr_ty c;
40838 if (
40839 (_keyword = _PyPegen_expect_token(p, 582)) // token='and'
40840 &&
40841 (c = inversion_rule(p)) // inversion
40842 )
40843 {
40844 D(fprintf(stderr, "%*c+ _tmp_252[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion"));
40845 _res = c;
40846 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
40847 p->error_indicator = 1;
40848 p->level--;
40849 return NULL;
40850 }
40851 goto done;
40852 }
40853 p->mark = _mark;
40854 D(fprintf(stderr, "%*c%s _tmp_252[%d-%d]: %s failed!\n", p->level, ' ',
40855 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion"));
40856 }
40857 _res = NULL;
40858 done:
40859 p->level--;
40860 return _res;
40861 }
40862
40863 // _tmp_253: slice | starred_expression
40864 static void *
40865 _tmp_253_rule(Parser *p)
40866 {
40867 if (p->level++ == MAXSTACK) {
40868 _Pypegen_stack_overflow(p);
40869 }
40870 if (p->error_indicator) {
40871 p->level--;
40872 return NULL;
40873 }
40874 void * _res = NULL;
40875 int _mark = p->mark;
40876 { // slice
40877 if (p->error_indicator) {
40878 p->level--;
40879 return NULL;
40880 }
40881 D(fprintf(stderr, "%*c> _tmp_253[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice"));
40882 expr_ty slice_var;
40883 if (
40884 (slice_var = slice_rule(p)) // slice
40885 )
40886 {
40887 D(fprintf(stderr, "%*c+ _tmp_253[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice"));
40888 _res = slice_var;
40889 goto done;
40890 }
40891 p->mark = _mark;
40892 D(fprintf(stderr, "%*c%s _tmp_253[%d-%d]: %s failed!\n", p->level, ' ',
40893 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice"));
40894 }
40895 { // starred_expression
40896 if (p->error_indicator) {
40897 p->level--;
40898 return NULL;
40899 }
40900 D(fprintf(stderr, "%*c> _tmp_253[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
40901 expr_ty starred_expression_var;
40902 if (
40903 (starred_expression_var = starred_expression_rule(p)) // starred_expression
40904 )
40905 {
40906 D(fprintf(stderr, "%*c+ _tmp_253[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
40907 _res = starred_expression_var;
40908 goto done;
40909 }
40910 p->mark = _mark;
40911 D(fprintf(stderr, "%*c%s _tmp_253[%d-%d]: %s failed!\n", p->level, ' ',
40912 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
40913 }
40914 _res = NULL;
40915 done:
40916 p->level--;
40917 return _res;
40918 }
40919
40920 // _tmp_254: fstring | string
40921 static void *
40922 _tmp_254_rule(Parser *p)
40923 {
40924 if (p->level++ == MAXSTACK) {
40925 _Pypegen_stack_overflow(p);
40926 }
40927 if (p->error_indicator) {
40928 p->level--;
40929 return NULL;
40930 }
40931 void * _res = NULL;
40932 int _mark = p->mark;
40933 { // fstring
40934 if (p->error_indicator) {
40935 p->level--;
40936 return NULL;
40937 }
40938 D(fprintf(stderr, "%*c> _tmp_254[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring"));
40939 expr_ty fstring_var;
40940 if (
40941 (fstring_var = fstring_rule(p)) // fstring
40942 )
40943 {
40944 D(fprintf(stderr, "%*c+ _tmp_254[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring"));
40945 _res = fstring_var;
40946 goto done;
40947 }
40948 p->mark = _mark;
40949 D(fprintf(stderr, "%*c%s _tmp_254[%d-%d]: %s failed!\n", p->level, ' ',
40950 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring"));
40951 }
40952 { // string
40953 if (p->error_indicator) {
40954 p->level--;
40955 return NULL;
40956 }
40957 D(fprintf(stderr, "%*c> _tmp_254[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "string"));
40958 expr_ty string_var;
40959 if (
40960 (string_var = string_rule(p)) // string
40961 )
40962 {
40963 D(fprintf(stderr, "%*c+ _tmp_254[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "string"));
40964 _res = string_var;
40965 goto done;
40966 }
40967 p->mark = _mark;
40968 D(fprintf(stderr, "%*c%s _tmp_254[%d-%d]: %s failed!\n", p->level, ' ',
40969 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "string"));
40970 }
40971 _res = NULL;
40972 done:
40973 p->level--;
40974 return _res;
40975 }
40976
40977 // _tmp_255: 'if' disjunction
40978 static void *
40979 _tmp_255_rule(Parser *p)
40980 {
40981 if (p->level++ == MAXSTACK) {
40982 _Pypegen_stack_overflow(p);
40983 }
40984 if (p->error_indicator) {
40985 p->level--;
40986 return NULL;
40987 }
40988 void * _res = NULL;
40989 int _mark = p->mark;
40990 { // 'if' disjunction
40991 if (p->error_indicator) {
40992 p->level--;
40993 return NULL;
40994 }
40995 D(fprintf(stderr, "%*c> _tmp_255[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
40996 Token * _keyword;
40997 expr_ty z;
40998 if (
40999 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
41000 &&
41001 (z = disjunction_rule(p)) // disjunction
41002 )
41003 {
41004 D(fprintf(stderr, "%*c+ _tmp_255[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
41005 _res = z;
41006 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
41007 p->error_indicator = 1;
41008 p->level--;
41009 return NULL;
41010 }
41011 goto done;
41012 }
41013 p->mark = _mark;
41014 D(fprintf(stderr, "%*c%s _tmp_255[%d-%d]: %s failed!\n", p->level, ' ',
41015 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction"));
41016 }
41017 _res = NULL;
41018 done:
41019 p->level--;
41020 return _res;
41021 }
41022
41023 // _tmp_256: 'if' disjunction
41024 static void *
41025 _tmp_256_rule(Parser *p)
41026 {
41027 if (p->level++ == MAXSTACK) {
41028 _Pypegen_stack_overflow(p);
41029 }
41030 if (p->error_indicator) {
41031 p->level--;
41032 return NULL;
41033 }
41034 void * _res = NULL;
41035 int _mark = p->mark;
41036 { // 'if' disjunction
41037 if (p->error_indicator) {
41038 p->level--;
41039 return NULL;
41040 }
41041 D(fprintf(stderr, "%*c> _tmp_256[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
41042 Token * _keyword;
41043 expr_ty z;
41044 if (
41045 (_keyword = _PyPegen_expect_token(p, 660)) // token='if'
41046 &&
41047 (z = disjunction_rule(p)) // disjunction
41048 )
41049 {
41050 D(fprintf(stderr, "%*c+ _tmp_256[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
41051 _res = z;
41052 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
41053 p->error_indicator = 1;
41054 p->level--;
41055 return NULL;
41056 }
41057 goto done;
41058 }
41059 p->mark = _mark;
41060 D(fprintf(stderr, "%*c%s _tmp_256[%d-%d]: %s failed!\n", p->level, ' ',
41061 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction"));
41062 }
41063 _res = NULL;
41064 done:
41065 p->level--;
41066 return _res;
41067 }
41068
41069 // _loop0_257: (',' bitwise_or)
41070 static asdl_seq *
41071 _loop0_257_rule(Parser *p)
41072 {
41073 if (p->level++ == MAXSTACK) {
41074 _Pypegen_stack_overflow(p);
41075 }
41076 if (p->error_indicator) {
41077 p->level--;
41078 return NULL;
41079 }
41080 void *_res = NULL;
41081 int _mark = p->mark;
41082 void **_children = PyMem_Malloc(sizeof(void *));
41083 if (!_children) {
41084 p->error_indicator = 1;
41085 PyErr_NoMemory();
41086 p->level--;
41087 return NULL;
41088 }
41089 Py_ssize_t _children_capacity = 1;
41090 Py_ssize_t _n = 0;
41091 { // (',' bitwise_or)
41092 if (p->error_indicator) {
41093 p->level--;
41094 return NULL;
41095 }
41096 D(fprintf(stderr, "%*c> _loop0_257[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)"));
41097 void *_tmp_272_var;
41098 while (
41099 (_tmp_272_var = _tmp_272_rule(p)) // ',' bitwise_or
41100 )
41101 {
41102 _res = _tmp_272_var;
41103 if (_n == _children_capacity) {
41104 _children_capacity *= 2;
41105 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
41106 if (!_new_children) {
41107 PyMem_Free(_children);
41108 p->error_indicator = 1;
41109 PyErr_NoMemory();
41110 p->level--;
41111 return NULL;
41112 }
41113 _children = _new_children;
41114 }
41115 _children[_n++] = _res;
41116 _mark = p->mark;
41117 }
41118 p->mark = _mark;
41119 D(fprintf(stderr, "%*c%s _loop0_257[%d-%d]: %s failed!\n", p->level, ' ',
41120 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' bitwise_or)"));
41121 }
41122 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
41123 if (!_seq) {
41124 PyMem_Free(_children);
41125 p->error_indicator = 1;
41126 PyErr_NoMemory();
41127 p->level--;
41128 return NULL;
41129 }
41130 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
41131 PyMem_Free(_children);
41132 p->level--;
41133 return _seq;
41134 }
41135
41136 // _tmp_258: starred_expression | (assignment_expression | expression !':=') !'='
41137 static void *
41138 _tmp_258_rule(Parser *p)
41139 {
41140 if (p->level++ == MAXSTACK) {
41141 _Pypegen_stack_overflow(p);
41142 }
41143 if (p->error_indicator) {
41144 p->level--;
41145 return NULL;
41146 }
41147 void * _res = NULL;
41148 int _mark = p->mark;
41149 { // starred_expression
41150 if (p->error_indicator) {
41151 p->level--;
41152 return NULL;
41153 }
41154 D(fprintf(stderr, "%*c> _tmp_258[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
41155 expr_ty starred_expression_var;
41156 if (
41157 (starred_expression_var = starred_expression_rule(p)) // starred_expression
41158 )
41159 {
41160 D(fprintf(stderr, "%*c+ _tmp_258[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
41161 _res = starred_expression_var;
41162 goto done;
41163 }
41164 p->mark = _mark;
41165 D(fprintf(stderr, "%*c%s _tmp_258[%d-%d]: %s failed!\n", p->level, ' ',
41166 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
41167 }
41168 { // (assignment_expression | expression !':=') !'='
41169 if (p->error_indicator) {
41170 p->level--;
41171 return NULL;
41172 }
41173 D(fprintf(stderr, "%*c> _tmp_258[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
41174 void *_tmp_273_var;
41175 if (
41176 (_tmp_273_var = _tmp_273_rule(p)) // assignment_expression | expression !':='
41177 &&
41178 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='='
41179 )
41180 {
41181 D(fprintf(stderr, "%*c+ _tmp_258[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
41182 _res = _tmp_273_var;
41183 goto done;
41184 }
41185 p->mark = _mark;
41186 D(fprintf(stderr, "%*c%s _tmp_258[%d-%d]: %s failed!\n", p->level, ' ',
41187 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
41188 }
41189 _res = NULL;
41190 done:
41191 p->level--;
41192 return _res;
41193 }
41194
41195 // _tmp_259: ',' star_target
41196 static void *
41197 _tmp_259_rule(Parser *p)
41198 {
41199 if (p->level++ == MAXSTACK) {
41200 _Pypegen_stack_overflow(p);
41201 }
41202 if (p->error_indicator) {
41203 p->level--;
41204 return NULL;
41205 }
41206 void * _res = NULL;
41207 int _mark = p->mark;
41208 { // ',' star_target
41209 if (p->error_indicator) {
41210 p->level--;
41211 return NULL;
41212 }
41213 D(fprintf(stderr, "%*c> _tmp_259[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
41214 Token * _literal;
41215 expr_ty c;
41216 if (
41217 (_literal = _PyPegen_expect_token(p, 12)) // token=','
41218 &&
41219 (c = star_target_rule(p)) // star_target
41220 )
41221 {
41222 D(fprintf(stderr, "%*c+ _tmp_259[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target"));
41223 _res = c;
41224 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
41225 p->error_indicator = 1;
41226 p->level--;
41227 return NULL;
41228 }
41229 goto done;
41230 }
41231 p->mark = _mark;
41232 D(fprintf(stderr, "%*c%s _tmp_259[%d-%d]: %s failed!\n", p->level, ' ',
41233 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));
41234 }
41235 _res = NULL;
41236 done:
41237 p->level--;
41238 return _res;
41239 }
41240
41241 // _tmp_260: ',' star_target
41242 static void *
41243 _tmp_260_rule(Parser *p)
41244 {
41245 if (p->level++ == MAXSTACK) {
41246 _Pypegen_stack_overflow(p);
41247 }
41248 if (p->error_indicator) {
41249 p->level--;
41250 return NULL;
41251 }
41252 void * _res = NULL;
41253 int _mark = p->mark;
41254 { // ',' star_target
41255 if (p->error_indicator) {
41256 p->level--;
41257 return NULL;
41258 }
41259 D(fprintf(stderr, "%*c> _tmp_260[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
41260 Token * _literal;
41261 expr_ty c;
41262 if (
41263 (_literal = _PyPegen_expect_token(p, 12)) // token=','
41264 &&
41265 (c = star_target_rule(p)) // star_target
41266 )
41267 {
41268 D(fprintf(stderr, "%*c+ _tmp_260[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target"));
41269 _res = c;
41270 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
41271 p->error_indicator = 1;
41272 p->level--;
41273 return NULL;
41274 }
41275 goto done;
41276 }
41277 p->mark = _mark;
41278 D(fprintf(stderr, "%*c%s _tmp_260[%d-%d]: %s failed!\n", p->level, ' ',
41279 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));
41280 }
41281 _res = NULL;
41282 done:
41283 p->level--;
41284 return _res;
41285 }
41286
41287 // _tmp_261:
41288 // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs
41289 static void *
41290 _tmp_261_rule(Parser *p)
41291 {
41292 if (p->level++ == MAXSTACK) {
41293 _Pypegen_stack_overflow(p);
41294 }
41295 if (p->error_indicator) {
41296 p->level--;
41297 return NULL;
41298 }
41299 void * _res = NULL;
41300 int _mark = p->mark;
41301 { // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs
41302 if (p->error_indicator) {
41303 p->level--;
41304 return NULL;
41305 }
41306 D(fprintf(stderr, "%*c> _tmp_261[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs"));
41307 asdl_seq * _gather_274_var;
41308 Token * _literal;
41309 asdl_seq* kwargs_var;
41310 if (
41311 (_gather_274_var = _gather_274_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+
41312 &&
41313 (_literal = _PyPegen_expect_token(p, 12)) // token=','
41314 &&
41315 (kwargs_var = kwargs_rule(p)) // kwargs
41316 )
41317 {
41318 D(fprintf(stderr, "%*c+ _tmp_261[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs"));
41319 _res = _PyPegen_dummy_name(p, _gather_274_var, _literal, kwargs_var);
41320 goto done;
41321 }
41322 p->mark = _mark;
41323 D(fprintf(stderr, "%*c%s _tmp_261[%d-%d]: %s failed!\n", p->level, ' ',
41324 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs"));
41325 }
41326 _res = NULL;
41327 done:
41328 p->level--;
41329 return _res;
41330 }
41331
41332 // _tmp_262: starred_expression !'='
41333 static void *
41334 _tmp_262_rule(Parser *p)
41335 {
41336 if (p->level++ == MAXSTACK) {
41337 _Pypegen_stack_overflow(p);
41338 }
41339 if (p->error_indicator) {
41340 p->level--;
41341 return NULL;
41342 }
41343 void * _res = NULL;
41344 int _mark = p->mark;
41345 { // starred_expression !'='
41346 if (p->error_indicator) {
41347 p->level--;
41348 return NULL;
41349 }
41350 D(fprintf(stderr, "%*c> _tmp_262[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression !'='"));
41351 expr_ty starred_expression_var;
41352 if (
41353 (starred_expression_var = starred_expression_rule(p)) // starred_expression
41354 &&
41355 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='='
41356 )
41357 {
41358 D(fprintf(stderr, "%*c+ _tmp_262[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression !'='"));
41359 _res = starred_expression_var;
41360 goto done;
41361 }
41362 p->mark = _mark;
41363 D(fprintf(stderr, "%*c%s _tmp_262[%d-%d]: %s failed!\n", p->level, ' ',
41364 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression !'='"));
41365 }
41366 _res = NULL;
41367 done:
41368 p->level--;
41369 return _res;
41370 }
41371
41372 // _tmp_263: star_targets '='
41373 static void *
41374 _tmp_263_rule(Parser *p)
41375 {
41376 if (p->level++ == MAXSTACK) {
41377 _Pypegen_stack_overflow(p);
41378 }
41379 if (p->error_indicator) {
41380 p->level--;
41381 return NULL;
41382 }
41383 void * _res = NULL;
41384 int _mark = p->mark;
41385 { // star_targets '='
41386 if (p->error_indicator) {
41387 p->level--;
41388 return NULL;
41389 }
41390 D(fprintf(stderr, "%*c> _tmp_263[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
41391 Token * _literal;
41392 expr_ty star_targets_var;
41393 if (
41394 (star_targets_var = star_targets_rule(p)) // star_targets
41395 &&
41396 (_literal = _PyPegen_expect_token(p, 22)) // token='='
41397 )
41398 {
41399 D(fprintf(stderr, "%*c+ _tmp_263[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
41400 _res = _PyPegen_dummy_name(p, star_targets_var, _literal);
41401 goto done;
41402 }
41403 p->mark = _mark;
41404 D(fprintf(stderr, "%*c%s _tmp_263[%d-%d]: %s failed!\n", p->level, ' ',
41405 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));
41406 }
41407 _res = NULL;
41408 done:
41409 p->level--;
41410 return _res;
41411 }
41412
41413 // _tmp_264: star_targets '='
41414 static void *
41415 _tmp_264_rule(Parser *p)
41416 {
41417 if (p->level++ == MAXSTACK) {
41418 _Pypegen_stack_overflow(p);
41419 }
41420 if (p->error_indicator) {
41421 p->level--;
41422 return NULL;
41423 }
41424 void * _res = NULL;
41425 int _mark = p->mark;
41426 { // star_targets '='
41427 if (p->error_indicator) {
41428 p->level--;
41429 return NULL;
41430 }
41431 D(fprintf(stderr, "%*c> _tmp_264[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
41432 Token * _literal;
41433 expr_ty star_targets_var;
41434 if (
41435 (star_targets_var = star_targets_rule(p)) // star_targets
41436 &&
41437 (_literal = _PyPegen_expect_token(p, 22)) // token='='
41438 )
41439 {
41440 D(fprintf(stderr, "%*c+ _tmp_264[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
41441 _res = _PyPegen_dummy_name(p, star_targets_var, _literal);
41442 goto done;
41443 }
41444 p->mark = _mark;
41445 D(fprintf(stderr, "%*c%s _tmp_264[%d-%d]: %s failed!\n", p->level, ' ',
41446 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));
41447 }
41448 _res = NULL;
41449 done:
41450 p->level--;
41451 return _res;
41452 }
41453
41454 // _tmp_265: ')' | '**'
41455 static void *
41456 _tmp_265_rule(Parser *p)
41457 {
41458 if (p->level++ == MAXSTACK) {
41459 _Pypegen_stack_overflow(p);
41460 }
41461 if (p->error_indicator) {
41462 p->level--;
41463 return NULL;
41464 }
41465 void * _res = NULL;
41466 int _mark = p->mark;
41467 { // ')'
41468 if (p->error_indicator) {
41469 p->level--;
41470 return NULL;
41471 }
41472 D(fprintf(stderr, "%*c> _tmp_265[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
41473 Token * _literal;
41474 if (
41475 (_literal = _PyPegen_expect_token(p, 8)) // token=')'
41476 )
41477 {
41478 D(fprintf(stderr, "%*c+ _tmp_265[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
41479 _res = _literal;
41480 goto done;
41481 }
41482 p->mark = _mark;
41483 D(fprintf(stderr, "%*c%s _tmp_265[%d-%d]: %s failed!\n", p->level, ' ',
41484 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
41485 }
41486 { // '**'
41487 if (p->error_indicator) {
41488 p->level--;
41489 return NULL;
41490 }
41491 D(fprintf(stderr, "%*c> _tmp_265[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
41492 Token * _literal;
41493 if (
41494 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
41495 )
41496 {
41497 D(fprintf(stderr, "%*c+ _tmp_265[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'"));
41498 _res = _literal;
41499 goto done;
41500 }
41501 p->mark = _mark;
41502 D(fprintf(stderr, "%*c%s _tmp_265[%d-%d]: %s failed!\n", p->level, ' ',
41503 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
41504 }
41505 _res = NULL;
41506 done:
41507 p->level--;
41508 return _res;
41509 }
41510
41511 // _tmp_266: ':' | '**'
41512 static void *
41513 _tmp_266_rule(Parser *p)
41514 {
41515 if (p->level++ == MAXSTACK) {
41516 _Pypegen_stack_overflow(p);
41517 }
41518 if (p->error_indicator) {
41519 p->level--;
41520 return NULL;
41521 }
41522 void * _res = NULL;
41523 int _mark = p->mark;
41524 { // ':'
41525 if (p->error_indicator) {
41526 p->level--;
41527 return NULL;
41528 }
41529 D(fprintf(stderr, "%*c> _tmp_266[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
41530 Token * _literal;
41531 if (
41532 (_literal = _PyPegen_expect_token(p, 11)) // token=':'
41533 )
41534 {
41535 D(fprintf(stderr, "%*c+ _tmp_266[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
41536 _res = _literal;
41537 goto done;
41538 }
41539 p->mark = _mark;
41540 D(fprintf(stderr, "%*c%s _tmp_266[%d-%d]: %s failed!\n", p->level, ' ',
41541 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
41542 }
41543 { // '**'
41544 if (p->error_indicator) {
41545 p->level--;
41546 return NULL;
41547 }
41548 D(fprintf(stderr, "%*c> _tmp_266[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
41549 Token * _literal;
41550 if (
41551 (_literal = _PyPegen_expect_token(p, 35)) // token='**'
41552 )
41553 {
41554 D(fprintf(stderr, "%*c+ _tmp_266[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'"));
41555 _res = _literal;
41556 goto done;
41557 }
41558 p->mark = _mark;
41559 D(fprintf(stderr, "%*c%s _tmp_266[%d-%d]: %s failed!\n", p->level, ' ',
41560 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
41561 }
41562 _res = NULL;
41563 done:
41564 p->level--;
41565 return _res;
41566 }
41567
41568 // _tmp_267: expression ['as' star_target]
41569 static void *
41570 _tmp_267_rule(Parser *p)
41571 {
41572 if (p->level++ == MAXSTACK) {
41573 _Pypegen_stack_overflow(p);
41574 }
41575 if (p->error_indicator) {
41576 p->level--;
41577 return NULL;
41578 }
41579 void * _res = NULL;
41580 int _mark = p->mark;
41581 { // expression ['as' star_target]
41582 if (p->error_indicator) {
41583 p->level--;
41584 return NULL;
41585 }
41586 D(fprintf(stderr, "%*c> _tmp_267[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]"));
41587 void *_opt_var;
41588 UNUSED(_opt_var); // Silence compiler warnings
41589 expr_ty expression_var;
41590 if (
41591 (expression_var = expression_rule(p)) // expression
41592 &&
41593 (_opt_var = _tmp_276_rule(p), !p->error_indicator) // ['as' star_target]
41594 )
41595 {
41596 D(fprintf(stderr, "%*c+ _tmp_267[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]"));
41597 _res = _PyPegen_dummy_name(p, expression_var, _opt_var);
41598 goto done;
41599 }
41600 p->mark = _mark;
41601 D(fprintf(stderr, "%*c%s _tmp_267[%d-%d]: %s failed!\n", p->level, ' ',
41602 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]"));
41603 }
41604 _res = NULL;
41605 done:
41606 p->level--;
41607 return _res;
41608 }
41609
41610 // _tmp_268: expressions ['as' star_target]
41611 static void *
41612 _tmp_268_rule(Parser *p)
41613 {
41614 if (p->level++ == MAXSTACK) {
41615 _Pypegen_stack_overflow(p);
41616 }
41617 if (p->error_indicator) {
41618 p->level--;
41619 return NULL;
41620 }
41621 void * _res = NULL;
41622 int _mark = p->mark;
41623 { // expressions ['as' star_target]
41624 if (p->error_indicator) {
41625 p->level--;
41626 return NULL;
41627 }
41628 D(fprintf(stderr, "%*c> _tmp_268[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]"));
41629 void *_opt_var;
41630 UNUSED(_opt_var); // Silence compiler warnings
41631 expr_ty expressions_var;
41632 if (
41633 (expressions_var = expressions_rule(p)) // expressions
41634 &&
41635 (_opt_var = _tmp_277_rule(p), !p->error_indicator) // ['as' star_target]
41636 )
41637 {
41638 D(fprintf(stderr, "%*c+ _tmp_268[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]"));
41639 _res = _PyPegen_dummy_name(p, expressions_var, _opt_var);
41640 goto done;
41641 }
41642 p->mark = _mark;
41643 D(fprintf(stderr, "%*c%s _tmp_268[%d-%d]: %s failed!\n", p->level, ' ',
41644 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]"));
41645 }
41646 _res = NULL;
41647 done:
41648 p->level--;
41649 return _res;
41650 }
41651
41652 // _tmp_269: expression ['as' star_target]
41653 static void *
41654 _tmp_269_rule(Parser *p)
41655 {
41656 if (p->level++ == MAXSTACK) {
41657 _Pypegen_stack_overflow(p);
41658 }
41659 if (p->error_indicator) {
41660 p->level--;
41661 return NULL;
41662 }
41663 void * _res = NULL;
41664 int _mark = p->mark;
41665 { // expression ['as' star_target]
41666 if (p->error_indicator) {
41667 p->level--;
41668 return NULL;
41669 }
41670 D(fprintf(stderr, "%*c> _tmp_269[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]"));
41671 void *_opt_var;
41672 UNUSED(_opt_var); // Silence compiler warnings
41673 expr_ty expression_var;
41674 if (
41675 (expression_var = expression_rule(p)) // expression
41676 &&
41677 (_opt_var = _tmp_278_rule(p), !p->error_indicator) // ['as' star_target]
41678 )
41679 {
41680 D(fprintf(stderr, "%*c+ _tmp_269[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]"));
41681 _res = _PyPegen_dummy_name(p, expression_var, _opt_var);
41682 goto done;
41683 }
41684 p->mark = _mark;
41685 D(fprintf(stderr, "%*c%s _tmp_269[%d-%d]: %s failed!\n", p->level, ' ',
41686 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]"));
41687 }
41688 _res = NULL;
41689 done:
41690 p->level--;
41691 return _res;
41692 }
41693
41694 // _tmp_270: expressions ['as' star_target]
41695 static void *
41696 _tmp_270_rule(Parser *p)
41697 {
41698 if (p->level++ == MAXSTACK) {
41699 _Pypegen_stack_overflow(p);
41700 }
41701 if (p->error_indicator) {
41702 p->level--;
41703 return NULL;
41704 }
41705 void * _res = NULL;
41706 int _mark = p->mark;
41707 { // expressions ['as' star_target]
41708 if (p->error_indicator) {
41709 p->level--;
41710 return NULL;
41711 }
41712 D(fprintf(stderr, "%*c> _tmp_270[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]"));
41713 void *_opt_var;
41714 UNUSED(_opt_var); // Silence compiler warnings
41715 expr_ty expressions_var;
41716 if (
41717 (expressions_var = expressions_rule(p)) // expressions
41718 &&
41719 (_opt_var = _tmp_279_rule(p), !p->error_indicator) // ['as' star_target]
41720 )
41721 {
41722 D(fprintf(stderr, "%*c+ _tmp_270[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]"));
41723 _res = _PyPegen_dummy_name(p, expressions_var, _opt_var);
41724 goto done;
41725 }
41726 p->mark = _mark;
41727 D(fprintf(stderr, "%*c%s _tmp_270[%d-%d]: %s failed!\n", p->level, ' ',
41728 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]"));
41729 }
41730 _res = NULL;
41731 done:
41732 p->level--;
41733 return _res;
41734 }
41735
41736 // _tmp_271: 'as' NAME
41737 static void *
41738 _tmp_271_rule(Parser *p)
41739 {
41740 if (p->level++ == MAXSTACK) {
41741 _Pypegen_stack_overflow(p);
41742 }
41743 if (p->error_indicator) {
41744 p->level--;
41745 return NULL;
41746 }
41747 void * _res = NULL;
41748 int _mark = p->mark;
41749 { // 'as' NAME
41750 if (p->error_indicator) {
41751 p->level--;
41752 return NULL;
41753 }
41754 D(fprintf(stderr, "%*c> _tmp_271[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
41755 Token * _keyword;
41756 expr_ty name_var;
41757 if (
41758 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
41759 &&
41760 (name_var = _PyPegen_name_token(p)) // NAME
41761 )
41762 {
41763 D(fprintf(stderr, "%*c+ _tmp_271[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
41764 _res = _PyPegen_dummy_name(p, _keyword, name_var);
41765 goto done;
41766 }
41767 p->mark = _mark;
41768 D(fprintf(stderr, "%*c%s _tmp_271[%d-%d]: %s failed!\n", p->level, ' ',
41769 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
41770 }
41771 _res = NULL;
41772 done:
41773 p->level--;
41774 return _res;
41775 }
41776
41777 // _tmp_272: ',' bitwise_or
41778 static void *
41779 _tmp_272_rule(Parser *p)
41780 {
41781 if (p->level++ == MAXSTACK) {
41782 _Pypegen_stack_overflow(p);
41783 }
41784 if (p->error_indicator) {
41785 p->level--;
41786 return NULL;
41787 }
41788 void * _res = NULL;
41789 int _mark = p->mark;
41790 { // ',' bitwise_or
41791 if (p->error_indicator) {
41792 p->level--;
41793 return NULL;
41794 }
41795 D(fprintf(stderr, "%*c> _tmp_272[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or"));
41796 Token * _literal;
41797 expr_ty bitwise_or_var;
41798 if (
41799 (_literal = _PyPegen_expect_token(p, 12)) // token=','
41800 &&
41801 (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or
41802 )
41803 {
41804 D(fprintf(stderr, "%*c+ _tmp_272[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or"));
41805 _res = _PyPegen_dummy_name(p, _literal, bitwise_or_var);
41806 goto done;
41807 }
41808 p->mark = _mark;
41809 D(fprintf(stderr, "%*c%s _tmp_272[%d-%d]: %s failed!\n", p->level, ' ',
41810 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' bitwise_or"));
41811 }
41812 _res = NULL;
41813 done:
41814 p->level--;
41815 return _res;
41816 }
41817
41818 // _tmp_273: assignment_expression | expression !':='
41819 static void *
41820 _tmp_273_rule(Parser *p)
41821 {
41822 if (p->level++ == MAXSTACK) {
41823 _Pypegen_stack_overflow(p);
41824 }
41825 if (p->error_indicator) {
41826 p->level--;
41827 return NULL;
41828 }
41829 void * _res = NULL;
41830 int _mark = p->mark;
41831 { // assignment_expression
41832 if (p->error_indicator) {
41833 p->level--;
41834 return NULL;
41835 }
41836 D(fprintf(stderr, "%*c> _tmp_273[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
41837 expr_ty assignment_expression_var;
41838 if (
41839 (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
41840 )
41841 {
41842 D(fprintf(stderr, "%*c+ _tmp_273[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
41843 _res = assignment_expression_var;
41844 goto done;
41845 }
41846 p->mark = _mark;
41847 D(fprintf(stderr, "%*c%s _tmp_273[%d-%d]: %s failed!\n", p->level, ' ',
41848 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));
41849 }
41850 { // expression !':='
41851 if (p->error_indicator) {
41852 p->level--;
41853 return NULL;
41854 }
41855 D(fprintf(stderr, "%*c> _tmp_273[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
41856 expr_ty expression_var;
41857 if (
41858 (expression_var = expression_rule(p)) // expression
41859 &&
41860 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
41861 )
41862 {
41863 D(fprintf(stderr, "%*c+ _tmp_273[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
41864 _res = expression_var;
41865 goto done;
41866 }
41867 p->mark = _mark;
41868 D(fprintf(stderr, "%*c%s _tmp_273[%d-%d]: %s failed!\n", p->level, ' ',
41869 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));
41870 }
41871 _res = NULL;
41872 done:
41873 p->level--;
41874 return _res;
41875 }
41876
41877 // _loop0_275: ',' (starred_expression | (assignment_expression | expression !':=') !'=')
41878 static asdl_seq *
41879 _loop0_275_rule(Parser *p)
41880 {
41881 if (p->level++ == MAXSTACK) {
41882 _Pypegen_stack_overflow(p);
41883 }
41884 if (p->error_indicator) {
41885 p->level--;
41886 return NULL;
41887 }
41888 void *_res = NULL;
41889 int _mark = p->mark;
41890 void **_children = PyMem_Malloc(sizeof(void *));
41891 if (!_children) {
41892 p->error_indicator = 1;
41893 PyErr_NoMemory();
41894 p->level--;
41895 return NULL;
41896 }
41897 Py_ssize_t _children_capacity = 1;
41898 Py_ssize_t _n = 0;
41899 { // ',' (starred_expression | (assignment_expression | expression !':=') !'=')
41900 if (p->error_indicator) {
41901 p->level--;
41902 return NULL;
41903 }
41904 D(fprintf(stderr, "%*c> _loop0_275[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')"));
41905 Token * _literal;
41906 void *elem;
41907 while (
41908 (_literal = _PyPegen_expect_token(p, 12)) // token=','
41909 &&
41910 (elem = _tmp_280_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'='
41911 )
41912 {
41913 _res = elem;
41914 if ((_res == NULL || p->error_indicator) && PyErr_Occurred()) {
41915 p->error_indicator = 1;
41916 PyMem_Free(_children);
41917 p->level--;
41918 return NULL;
41919 }
41920 if (_n == _children_capacity) {
41921 _children_capacity *= 2;
41922 void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
41923 if (!_new_children) {
41924 PyMem_Free(_children);
41925 p->error_indicator = 1;
41926 PyErr_NoMemory();
41927 p->level--;
41928 return NULL;
41929 }
41930 _children = _new_children;
41931 }
41932 _children[_n++] = _res;
41933 _mark = p->mark;
41934 }
41935 p->mark = _mark;
41936 D(fprintf(stderr, "%*c%s _loop0_275[%d-%d]: %s failed!\n", p->level, ' ',
41937 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')"));
41938 }
41939 asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena);
41940 if (!_seq) {
41941 PyMem_Free(_children);
41942 p->error_indicator = 1;
41943 PyErr_NoMemory();
41944 p->level--;
41945 return NULL;
41946 }
41947 for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
41948 PyMem_Free(_children);
41949 p->level--;
41950 return _seq;
41951 }
41952
41953 // _gather_274:
41954 // | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_275
41955 static asdl_seq *
41956 _gather_274_rule(Parser *p)
41957 {
41958 if (p->level++ == MAXSTACK) {
41959 _Pypegen_stack_overflow(p);
41960 }
41961 if (p->error_indicator) {
41962 p->level--;
41963 return NULL;
41964 }
41965 asdl_seq * _res = NULL;
41966 int _mark = p->mark;
41967 { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_275
41968 if (p->error_indicator) {
41969 p->level--;
41970 return NULL;
41971 }
41972 D(fprintf(stderr, "%*c> _gather_274[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_275"));
41973 void *elem;
41974 asdl_seq * seq;
41975 if (
41976 (elem = _tmp_280_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'='
41977 &&
41978 (seq = _loop0_275_rule(p)) // _loop0_275
41979 )
41980 {
41981 D(fprintf(stderr, "%*c+ _gather_274[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_275"));
41982 _res = _PyPegen_seq_insert_in_front(p, elem, seq);
41983 goto done;
41984 }
41985 p->mark = _mark;
41986 D(fprintf(stderr, "%*c%s _gather_274[%d-%d]: %s failed!\n", p->level, ' ',
41987 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_275"));
41988 }
41989 _res = NULL;
41990 done:
41991 p->level--;
41992 return _res;
41993 }
41994
41995 // _tmp_276: 'as' star_target
41996 static void *
41997 _tmp_276_rule(Parser *p)
41998 {
41999 if (p->level++ == MAXSTACK) {
42000 _Pypegen_stack_overflow(p);
42001 }
42002 if (p->error_indicator) {
42003 p->level--;
42004 return NULL;
42005 }
42006 void * _res = NULL;
42007 int _mark = p->mark;
42008 { // 'as' star_target
42009 if (p->error_indicator) {
42010 p->level--;
42011 return NULL;
42012 }
42013 D(fprintf(stderr, "%*c> _tmp_276[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target"));
42014 Token * _keyword;
42015 expr_ty star_target_var;
42016 if (
42017 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
42018 &&
42019 (star_target_var = star_target_rule(p)) // star_target
42020 )
42021 {
42022 D(fprintf(stderr, "%*c+ _tmp_276[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target"));
42023 _res = _PyPegen_dummy_name(p, _keyword, star_target_var);
42024 goto done;
42025 }
42026 p->mark = _mark;
42027 D(fprintf(stderr, "%*c%s _tmp_276[%d-%d]: %s failed!\n", p->level, ' ',
42028 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target"));
42029 }
42030 _res = NULL;
42031 done:
42032 p->level--;
42033 return _res;
42034 }
42035
42036 // _tmp_277: 'as' star_target
42037 static void *
42038 _tmp_277_rule(Parser *p)
42039 {
42040 if (p->level++ == MAXSTACK) {
42041 _Pypegen_stack_overflow(p);
42042 }
42043 if (p->error_indicator) {
42044 p->level--;
42045 return NULL;
42046 }
42047 void * _res = NULL;
42048 int _mark = p->mark;
42049 { // 'as' star_target
42050 if (p->error_indicator) {
42051 p->level--;
42052 return NULL;
42053 }
42054 D(fprintf(stderr, "%*c> _tmp_277[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target"));
42055 Token * _keyword;
42056 expr_ty star_target_var;
42057 if (
42058 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
42059 &&
42060 (star_target_var = star_target_rule(p)) // star_target
42061 )
42062 {
42063 D(fprintf(stderr, "%*c+ _tmp_277[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target"));
42064 _res = _PyPegen_dummy_name(p, _keyword, star_target_var);
42065 goto done;
42066 }
42067 p->mark = _mark;
42068 D(fprintf(stderr, "%*c%s _tmp_277[%d-%d]: %s failed!\n", p->level, ' ',
42069 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target"));
42070 }
42071 _res = NULL;
42072 done:
42073 p->level--;
42074 return _res;
42075 }
42076
42077 // _tmp_278: 'as' star_target
42078 static void *
42079 _tmp_278_rule(Parser *p)
42080 {
42081 if (p->level++ == MAXSTACK) {
42082 _Pypegen_stack_overflow(p);
42083 }
42084 if (p->error_indicator) {
42085 p->level--;
42086 return NULL;
42087 }
42088 void * _res = NULL;
42089 int _mark = p->mark;
42090 { // 'as' star_target
42091 if (p->error_indicator) {
42092 p->level--;
42093 return NULL;
42094 }
42095 D(fprintf(stderr, "%*c> _tmp_278[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target"));
42096 Token * _keyword;
42097 expr_ty star_target_var;
42098 if (
42099 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
42100 &&
42101 (star_target_var = star_target_rule(p)) // star_target
42102 )
42103 {
42104 D(fprintf(stderr, "%*c+ _tmp_278[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target"));
42105 _res = _PyPegen_dummy_name(p, _keyword, star_target_var);
42106 goto done;
42107 }
42108 p->mark = _mark;
42109 D(fprintf(stderr, "%*c%s _tmp_278[%d-%d]: %s failed!\n", p->level, ' ',
42110 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target"));
42111 }
42112 _res = NULL;
42113 done:
42114 p->level--;
42115 return _res;
42116 }
42117
42118 // _tmp_279: 'as' star_target
42119 static void *
42120 _tmp_279_rule(Parser *p)
42121 {
42122 if (p->level++ == MAXSTACK) {
42123 _Pypegen_stack_overflow(p);
42124 }
42125 if (p->error_indicator) {
42126 p->level--;
42127 return NULL;
42128 }
42129 void * _res = NULL;
42130 int _mark = p->mark;
42131 { // 'as' star_target
42132 if (p->error_indicator) {
42133 p->level--;
42134 return NULL;
42135 }
42136 D(fprintf(stderr, "%*c> _tmp_279[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target"));
42137 Token * _keyword;
42138 expr_ty star_target_var;
42139 if (
42140 (_keyword = _PyPegen_expect_token(p, 658)) // token='as'
42141 &&
42142 (star_target_var = star_target_rule(p)) // star_target
42143 )
42144 {
42145 D(fprintf(stderr, "%*c+ _tmp_279[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target"));
42146 _res = _PyPegen_dummy_name(p, _keyword, star_target_var);
42147 goto done;
42148 }
42149 p->mark = _mark;
42150 D(fprintf(stderr, "%*c%s _tmp_279[%d-%d]: %s failed!\n", p->level, ' ',
42151 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target"));
42152 }
42153 _res = NULL;
42154 done:
42155 p->level--;
42156 return _res;
42157 }
42158
42159 // _tmp_280: starred_expression | (assignment_expression | expression !':=') !'='
42160 static void *
42161 _tmp_280_rule(Parser *p)
42162 {
42163 if (p->level++ == MAXSTACK) {
42164 _Pypegen_stack_overflow(p);
42165 }
42166 if (p->error_indicator) {
42167 p->level--;
42168 return NULL;
42169 }
42170 void * _res = NULL;
42171 int _mark = p->mark;
42172 { // starred_expression
42173 if (p->error_indicator) {
42174 p->level--;
42175 return NULL;
42176 }
42177 D(fprintf(stderr, "%*c> _tmp_280[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
42178 expr_ty starred_expression_var;
42179 if (
42180 (starred_expression_var = starred_expression_rule(p)) // starred_expression
42181 )
42182 {
42183 D(fprintf(stderr, "%*c+ _tmp_280[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
42184 _res = starred_expression_var;
42185 goto done;
42186 }
42187 p->mark = _mark;
42188 D(fprintf(stderr, "%*c%s _tmp_280[%d-%d]: %s failed!\n", p->level, ' ',
42189 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
42190 }
42191 { // (assignment_expression | expression !':=') !'='
42192 if (p->error_indicator) {
42193 p->level--;
42194 return NULL;
42195 }
42196 D(fprintf(stderr, "%*c> _tmp_280[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
42197 void *_tmp_281_var;
42198 if (
42199 (_tmp_281_var = _tmp_281_rule(p)) // assignment_expression | expression !':='
42200 &&
42201 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='='
42202 )
42203 {
42204 D(fprintf(stderr, "%*c+ _tmp_280[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
42205 _res = _tmp_281_var;
42206 goto done;
42207 }
42208 p->mark = _mark;
42209 D(fprintf(stderr, "%*c%s _tmp_280[%d-%d]: %s failed!\n", p->level, ' ',
42210 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
42211 }
42212 _res = NULL;
42213 done:
42214 p->level--;
42215 return _res;
42216 }
42217
42218 // _tmp_281: assignment_expression | expression !':='
42219 static void *
42220 _tmp_281_rule(Parser *p)
42221 {
42222 if (p->level++ == MAXSTACK) {
42223 _Pypegen_stack_overflow(p);
42224 }
42225 if (p->error_indicator) {
42226 p->level--;
42227 return NULL;
42228 }
42229 void * _res = NULL;
42230 int _mark = p->mark;
42231 { // assignment_expression
42232 if (p->error_indicator) {
42233 p->level--;
42234 return NULL;
42235 }
42236 D(fprintf(stderr, "%*c> _tmp_281[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
42237 expr_ty assignment_expression_var;
42238 if (
42239 (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression
42240 )
42241 {
42242 D(fprintf(stderr, "%*c+ _tmp_281[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression"));
42243 _res = assignment_expression_var;
42244 goto done;
42245 }
42246 p->mark = _mark;
42247 D(fprintf(stderr, "%*c%s _tmp_281[%d-%d]: %s failed!\n", p->level, ' ',
42248 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));
42249 }
42250 { // expression !':='
42251 if (p->error_indicator) {
42252 p->level--;
42253 return NULL;
42254 }
42255 D(fprintf(stderr, "%*c> _tmp_281[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
42256 expr_ty expression_var;
42257 if (
42258 (expression_var = expression_rule(p)) // expression
42259 &&
42260 _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':='
42261 )
42262 {
42263 D(fprintf(stderr, "%*c+ _tmp_281[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
42264 _res = expression_var;
42265 goto done;
42266 }
42267 p->mark = _mark;
42268 D(fprintf(stderr, "%*c%s _tmp_281[%d-%d]: %s failed!\n", p->level, ' ',
42269 p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));
42270 }
42271 _res = NULL;
42272 done:
42273 p->level--;
42274 return _res;
42275 }
42276
42277 void *
42278 _PyPegen_parse(Parser *p)
42279 {
42280 // Initialize keywords
42281 p->keywords = reserved_keywords;
42282 p->n_keyword_lists = n_keyword_lists;
42283 p->soft_keywords = soft_keywords;
42284
42285 // Run parser
42286 void *result = NULL;
42287 if (p->start_rule == Py_file_input) {
42288 result = file_rule(p);
42289 } else if (p->start_rule == Py_single_input) {
42290 result = interactive_rule(p);
42291 } else if (p->start_rule == Py_eval_input) {
42292 result = eval_rule(p);
42293 } else if (p->start_rule == Py_func_type_input) {
42294 result = func_type_rule(p);
42295 }
42296
42297 return result;
42298 }