From cba604e0383c598b404b2da27d63571a8171fdb3 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 23 Oct 2026 18:05:04 +0000 Subject: [PATCH] gh-153568: Skip PEG alternatives that cannot match the next token Rules with several alternatives now switch on the next token's type and only try the alternatives that may start with it. Loops stop as soon as the next token cannot start another iteration. Both use FIRST sets from a new analysis, which also replaces the old first_sets.py calculator. Co-authored-by: Pablo Galindo --- .../test_peg_generator/test_c_generator.py | 105 + .../test_peg_generator/test_first_sets.py | 84 +- ...-10-23-18-07-52.gh-issue-153568.Y6LTe5.rst | 3 + Parser/parser.c | 4183 +++++++++++++++++ Parser/pegen.h | 18 + Tools/peg_generator/pegen/c_generator.py | 2 +- .../peg_generator/pegen/c_generator_calls.py | 96 +- .../peg_generator/pegen/c_generator_model.py | 1 + .../peg_generator/pegen/c_generator_rules.py | 89 +- Tools/peg_generator/pegen/first_sets.py | 123 +- Tools/peg_generator/pegen/grammar_analysis.py | 77 +- Tools/peg_generator/pegen/parser_generator.py | 4 +- 12 files changed, 4641 insertions(+), 144 deletions(-) create mode 100644 Misc/NEWS.d/next/Core_and_Builtins/2026-10-23-18-07-52.gh-issue-153568.Y6LTe5.rst diff --git a/Lib/test/test_peg_generator/test_c_generator.py b/Lib/test/test_peg_generator/test_c_generator.py index 0c2840bc297cd11..e9f7ae48f6ad9a2 100644 --- a/Lib/test/test_peg_generator/test_c_generator.py +++ b/Lib/test/test_peg_generator/test_c_generator.py @@ -1,4 +1,5 @@ import io +import token import unittest from pathlib import PurePath from unittest import mock @@ -27,6 +28,10 @@ def emit_parser(self, parser): CParserEmitter(parser, output).emit() return output.getvalue() + def prepare_rules(self, source): + parser = self.make_generator(source).prepare(PurePath("example.gram")) + return {rule.signature.name: rule for rule in parser.rules} + def test_rule_types_distinguish_implicit_and_explicit_void_pointer(self): generator = self.make_generator(""" start: &implicit implicit explicit @@ -286,6 +291,106 @@ def test_keywords_are_numbered_once(self): self.assertEqual(generator.keywords, {"if": 500, "else": 501, "pass": 502}) self.assertEqual(generator.soft_keywords, {"soft"}) + def test_first_set_dispatch(self): + rules = self.prepare_rules(""" + start: NAME | '(' NAME | 'if' NAME | "match" NUMBER + """) + self.assertEqual( + rules["start"].first_set_dispatch, + ( + frozenset({token.NAME}), + frozenset({token.LPAR}), + # Keyword types are numbered from 500. + frozenset({500}), + # Soft keywords are NAME tokens. + frozenset({token.NAME}), + ), + ) + + def test_first_set_dispatch_ignores_second_pass_alternatives(self): + rules = self.prepare_rules(""" + start: NAME | invalid_start | NUMBER + single: NAME | invalid_start + invalid_start: STRING + """) + self.assertEqual( + rules["start"].first_set_dispatch, + (frozenset({token.NAME}), frozenset(), frozenset({token.NUMBER})), + ) + self.assertIsNone(rules["single"].first_set_dispatch) + + def test_no_first_set_dispatch(self): + cases = { + "single": "NAME", + "same_sets": "NAME '+' NAME | NAME", + "unknown": "~ NAME | [NUMBER]", + } + rules = self.prepare_rules( + "start: " + " | ".join(cases) + "\n" + + "".join(f"{name}: {rhs}\n" for name, rhs in cases.items()) + ) + for name in cases: + with self.subTest(name): + self.assertIsNone(rules[name].first_set_dispatch) + + def test_first_set_dispatch_in_second_pass_rules(self): + rules = self.prepare_rules(""" + start: NAME | invalid_start + invalid_start: (NAME | NUMBER) helper + helper: NAME | NUMBER + """) + self.assertEqual( + rules["helper"].first_set_dispatch, + (frozenset({token.NAME}), frozenset({token.NUMBER})), + ) + + def test_first_set_dispatch_emission(self): + generator = self.make_generator(""" + start: disjoint | overlapping + disjoint: NAME | NUMBER + overlapping: NAME '+' NAME | NUMBER | ~ STRING + """) + source = self.emit_parser(generator.prepare(PurePath("example.gram"))) + disjoint = source[source.index("\ndisjoint_rule(") : source.index("\noverlapping_rule(")] + self.assertIn(f"case {token.NAME}:\n goto _first_set_alt_0;", disjoint) + self.assertNotIn("_first_set_mask", disjoint) + overlapping = source[source.index("\noverlapping_rule(") :] + # The alternative with an unknown first set is tried for every token. + self.assertIn( + f"case {token.NAME}:\n _first_set_mask = 0x5ULL;", overlapping + ) + self.assertIn("default:\n _first_set_mask = 0x4ULL;", overlapping) + + def test_loop_first_set_check(self): + rules = self.prepare_rules(""" + start: element+ keyword* NAME* large* + element: NAME | NUMBER + keyword: 'if' NAME + large: tstring_end NAME + tstring_end: TSTRING_END + """) + checks = {} + for name, rule in rules.items(): + if rule.signature.kind in {RuleKind.LOOP0, RuleKind.LOOP1}: + alt, = rule.alternatives + first = alt.calls[0] + if first.function == "_PyPegen_next_token_in": + checks[str(alt.text)] = first.arguments + else: + checks[str(alt.text)] = None + self.assertEqual( + checks, + { + "element": ("p", f"0x{1 << token.NAME | 1 << token.NUMBER:x}ULL", "0x0ULL"), + # Keyword types are numbered from 500. + "keyword": ("p", "0x0ULL", "0x1ULL"), + # Matching the token costs no more than checking it. + "NAME": None, + # The mask has no bit for a token type above 63. + "large": None, + }, + ) + if __name__ == "__main__": unittest.main() diff --git a/Lib/test/test_peg_generator/test_first_sets.py b/Lib/test/test_peg_generator/test_first_sets.py index d6f8322f034f748..3d2caabaa5966f6 100644 --- a/Lib/test/test_peg_generator/test_first_sets.py +++ b/Lib/test/test_peg_generator/test_first_sets.py @@ -7,14 +7,18 @@ with test_tools.imports_under_tool("peg_generator"): from pegen.grammar_parser import GeneratedParser as GrammarParser from pegen.testutil import parse_string - from pegen.first_sets import FirstSetCalculator + from pegen.grammar_analysis import FirstSetVisitor from pegen.grammar import Grammar class TestFirstSets(unittest.TestCase): - def calculate_first_sets(self, grammar_source: str) -> Dict[str, Set[str]]: + def calculate_first_sets(self, grammar_source: str) -> Dict[str, Set[str] | None]: grammar: Grammar = parse_string(grammar_source, GrammarParser) - return FirstSetCalculator(grammar.rules).calculate() + first_sets = FirstSetVisitor(grammar.rules).first_sets + return { + name: None if first is None else set(first) + for name, first in first_sets.items() + } def test_alternatives(self) -> None: grammar = """ @@ -178,10 +182,12 @@ def test_negative_lookahead(self) -> None: """ self.assertEqual( self.calculate_first_sets(grammar), + # A negative lookahead doesn't narrow the first set, but its own + # first set is included for the effects it may have. { "opt": {"'b'", "'a'", "'c'"}, - "expr": {"'b'", "'c'"}, - "start": {"'b'", "'c'"}, + "expr": {"'a'", "'b'", "'c'"}, + "start": {"'a'", "'b'", "'c'"}, }, ) @@ -213,7 +219,8 @@ def test_advance_left_recursion(self) -> None: """ self.assertEqual( self.calculate_first_sets(grammar), - {"sign": {"'-'", ""}, "start": {"'-'", "NUMBER"}}, + # sign may match whatever the next token is. + {"sign": None, "start": None}, ) def test_mutual_left_recursion(self) -> None: @@ -226,13 +233,12 @@ def test_mutual_left_recursion(self) -> None: self.calculate_first_sets(grammar), { "foo": {"'D'", "'B'"}, - "bar": {"'D'"}, + "bar": {"'D'", "'B'"}, "start": {"'D'", "'B'"}, }, ) def test_nasty_left_recursion(self) -> None: - # TODO: Validate this grammar = """ start: target '=' target: maybe '+' | NAME @@ -240,7 +246,7 @@ def test_nasty_left_recursion(self) -> None: """ self.assertEqual( self.calculate_first_sets(grammar), - {"maybe": set(), "target": {"NAME"}, "start": {"NAME"}}, + {"maybe": {"NAME"}, "target": {"NAME"}, "start": {"NAME"}}, ) def test_nullable_rule(self) -> None: @@ -252,9 +258,9 @@ def test_nullable_rule(self) -> None: self.assertEqual( self.calculate_first_sets(grammar), { - "sign": {"", "'-'"}, + "sign": None, "thing": {"NUMBER"}, - "start": {"NUMBER", "'-'"}, + "start": None, }, ) @@ -277,10 +283,60 @@ def test_multiple_nullable_rules(self) -> None: self.assertEqual( self.calculate_first_sets(grammar), { - "sign": {"", "'-'"}, - "thing": {"'+'", ""}, - "start": {"'+'", "'-'", "'*'"}, + "sign": None, + "thing": None, + "start": None, "other": {"'*'"}, "another": {"'/'"}, }, ) + + def test_keywords_and_exact_tokens(self) -> None: + grammar = """ + start: 'if' NAME | '(' NAME ')' + """ + self.assertEqual(self.calculate_first_sets(grammar), {"start": {"'if'", "'('"}}) + + def test_soft_keywords(self) -> None: + grammar = """ + start: "match" NAME | SOFT_KEYWORD NUMBER + """ + self.assertEqual(self.calculate_first_sets(grammar), {"start": {"NAME"}}) + + def test_leading_cut(self) -> None: + grammar = """ + start: choice NEWLINE + choice: ~ NAME | NUMBER + """ + self.assertEqual( + self.calculate_first_sets(grammar), {"choice": None, "start": None} + ) + + def test_forced(self) -> None: + grammar = """ + start: choice NEWLINE + choice: &&'+' | NAME &&':' NUMBER + """ + self.assertEqual( + self.calculate_first_sets(grammar), {"choice": None, "start": None} + ) + grammar = """ + start: NAME &&':' NUMBER + """ + self.assertEqual(self.calculate_first_sets(grammar), {"start": {"NAME"}}) + + def test_negative_lookahead_effects(self) -> None: + grammar = """ + start: !guard NAME + guard: NUMBER + """ + self.assertEqual( + self.calculate_first_sets(grammar), + {"guard": {"NUMBER"}, "start": {"NAME", "NUMBER"}}, + ) + + def test_positive_lookahead_alone(self) -> None: + grammar = """ + start: &NUMBER + """ + self.assertEqual(self.calculate_first_sets(grammar), {"start": {"NUMBER"}}) diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-10-23-18-07-52.gh-issue-153568.Y6LTe5.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-10-23-18-07-52.gh-issue-153568.Y6LTe5.rst new file mode 100644 index 000000000000000..6e51be84536bce6 --- /dev/null +++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-10-23-18-07-52.gh-issue-153568.Y6LTe5.rst @@ -0,0 +1,3 @@ +Speed up the parser by computing the first set of each rule and skipping +alternatives that cannot start with the next token based on those first +sets. diff --git a/Parser/parser.c b/Parser/parser.c index 0568d13845609b1..6fcfae45c1cccdc 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -1230,6 +1230,66 @@ statement_rule(Parser *p) } asdl_stmt_seq* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 49: + case 512: + case 513: + case 514: + case 515: + case 516: + case 517: + case 518: + case 519: + _first_set_mask = 0x1ULL; + break; + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 16: + case 25: + case 31: + case 52: + case 59: + case 62: + case 500: + case 501: + case 502: + case 503: + case 504: + case 505: + case 506: + case 507: + case 508: + case 509: + case 510: + case 511: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x2ULL; + break; + case 1: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // compound_stmt if (p->error_indicator) { p->level--; @@ -1254,6 +1314,7 @@ statement_rule(Parser *p) D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt")); } + if (_first_set_mask & 0x2ULL) { // simple_stmts if (p->error_indicator) { p->level--; @@ -1349,6 +1410,67 @@ statement_newline_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 49: + case 512: + case 513: + case 514: + case 515: + case 516: + case 517: + case 518: + case 519: + _first_set_mask = 0x1ULL; + break; + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 16: + case 25: + case 31: + case 52: + case 59: + case 62: + case 500: + case 501: + case 502: + case 503: + case 504: + case 505: + case 506: + case 507: + case 508: + case 509: + case 510: + case 511: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x2ULL; + break; + case 1: + _first_set_mask = 0x3ULL; + break; + case 4: + _first_set_mask = 0x4ULL; + break; + case 0: + _first_set_mask = 0x8ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // single_compound_stmt NEWLINE if (p->error_indicator) { p->level--; @@ -1376,6 +1498,7 @@ statement_newline_rule(Parser *p) D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_compound_stmt NEWLINE")); } + if (_first_set_mask & 0x2ULL) { // simple_stmts if (p->error_indicator) { p->level--; @@ -1395,6 +1518,7 @@ statement_newline_rule(Parser *p) D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts")); } + if (_first_set_mask & 0x4ULL) { // NEWLINE if (p->error_indicator) { p->level--; @@ -1428,6 +1552,7 @@ statement_newline_rule(Parser *p) D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } + if (_first_set_mask & 0x8ULL) { // $ if (p->error_indicator) { p->level--; @@ -1577,6 +1702,72 @@ simple_stmt_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 500: + case 501: + _first_set_mask = 0x4ULL; + break; + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 16: + case 25: + case 31: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x9ULL; + break; + case 1: + _first_set_mask = 0xfULL; + break; + case 502: + _first_set_mask = 0x10ULL; + break; + case 503: + _first_set_mask = 0x20ULL; + break; + case 504: + _first_set_mask = 0x49ULL; + break; + case 505: + _first_set_mask = 0x80ULL; + break; + case 506: + _first_set_mask = 0x101ULL; + break; + case 507: + _first_set_mask = 0x200ULL; + break; + case 508: + _first_set_mask = 0x409ULL; + break; + case 509: + _first_set_mask = 0x809ULL; + break; + case 510: + _first_set_mask = 0x1000ULL; + break; + case 511: + _first_set_mask = 0x2000ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // assignment if (p->error_indicator) { p->level--; @@ -1596,6 +1787,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment")); } + if (_first_set_mask & 0x2ULL) { // &"type" type_alias if (p->error_indicator) { p->level--; @@ -1617,6 +1809,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&\"type\" type_alias")); } + if (_first_set_mask & 0x4ULL) { // &('import' | 'from' | "lazy") import_stmt if (p->error_indicator) { p->level--; @@ -1638,6 +1831,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('import' | 'from' | \"lazy\") import_stmt")); } + if (_first_set_mask & 0x8ULL) { // star_expressions if (p->error_indicator) { p->level--; @@ -1671,6 +1865,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); } + if (_first_set_mask & 0x10ULL) { // &'return' return_stmt if (p->error_indicator) { p->level--; @@ -1692,6 +1887,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'return' return_stmt")); } + if (_first_set_mask & 0x20ULL) { // &'raise' raise_stmt if (p->error_indicator) { p->level--; @@ -1713,6 +1909,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'raise' raise_stmt")); } + if (_first_set_mask & 0x40ULL) { // &'pass' pass_stmt if (p->error_indicator) { p->level--; @@ -1734,6 +1931,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'pass' pass_stmt")); } + if (_first_set_mask & 0x80ULL) { // &'del' del_stmt if (p->error_indicator) { p->level--; @@ -1755,6 +1953,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'del' del_stmt")); } + if (_first_set_mask & 0x100ULL) { // &'yield' yield_stmt if (p->error_indicator) { p->level--; @@ -1776,6 +1975,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'yield' yield_stmt")); } + if (_first_set_mask & 0x200ULL) { // &'assert' assert_stmt if (p->error_indicator) { p->level--; @@ -1797,6 +1997,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'assert' assert_stmt")); } + if (_first_set_mask & 0x400ULL) { // &'break' break_stmt if (p->error_indicator) { p->level--; @@ -1818,6 +2019,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'break' break_stmt")); } + if (_first_set_mask & 0x800ULL) { // &'continue' continue_stmt if (p->error_indicator) { p->level--; @@ -1839,6 +2041,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'continue' continue_stmt")); } + if (_first_set_mask & 0x1000ULL) { // &'global' global_stmt if (p->error_indicator) { p->level--; @@ -1860,6 +2063,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'global' global_stmt")); } + if (_first_set_mask & 0x2000ULL) { // &'nonlocal' nonlocal_stmt if (p->error_indicator) { p->level--; @@ -1909,6 +2113,50 @@ compound_stmt_rule(Parser *p) } stmt_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 512: + _first_set_mask = 0x1ULL; + break; + case 514: + _first_set_mask = 0x2ULL; + break; + case 515: + _first_set_mask = 0x4ULL; + break; + case 49: + _first_set_mask = 0x5ULL; + break; + case 516: + _first_set_mask = 0x8ULL; + break; + case 517: + _first_set_mask = 0x10ULL; + break; + case 513: + _first_set_mask = 0x19ULL; + break; + case 518: + _first_set_mask = 0x20ULL; + break; + case 519: + _first_set_mask = 0x40ULL; + break; + case 1: + _first_set_mask = 0x80ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // &('def' | '@' | 'async') function_def if (p->error_indicator) { p->level--; @@ -1930,6 +2178,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('def' | '@' | 'async') function_def")); } + if (_first_set_mask & 0x2ULL) { // &'if' if_stmt if (p->error_indicator) { p->level--; @@ -1951,6 +2200,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'if' if_stmt")); } + if (_first_set_mask & 0x4ULL) { // &('class' | '@') class_def if (p->error_indicator) { p->level--; @@ -1972,6 +2222,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('class' | '@') class_def")); } + if (_first_set_mask & 0x8ULL) { // &('with' | 'async') with_stmt if (p->error_indicator) { p->level--; @@ -1993,6 +2244,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('with' | 'async') with_stmt")); } + if (_first_set_mask & 0x10ULL) { // &('for' | 'async') for_stmt if (p->error_indicator) { p->level--; @@ -2014,6 +2266,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('for' | 'async') for_stmt")); } + if (_first_set_mask & 0x20ULL) { // &'try' try_stmt if (p->error_indicator) { p->level--; @@ -2035,6 +2288,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'try' try_stmt")); } + if (_first_set_mask & 0x40ULL) { // &'while' while_stmt if (p->error_indicator) { p->level--; @@ -2056,6 +2310,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'while' while_stmt")); } + if (_first_set_mask & 0x80ULL) { // match_stmt if (p->error_indicator) { p->level--; @@ -2108,6 +2363,34 @@ assignment_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x4ULL; + break; + case 2: + case 3: + case 7: + case 9: + case 25: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + _first_set_mask = 0xeULL; + break; + case 1: + _first_set_mask = 0xfULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // NAME ':' expression ['=' annotated_rhs] if (p->error_indicator) { p->level--; @@ -2150,6 +2433,7 @@ assignment_rule(Parser *p) D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]")); } + if (_first_set_mask & 0x2ULL) { // ('(' single_target ')' | attribute_or_subscript_target) ':' expression ['=' annotated_rhs] if (p->error_indicator) { p->level--; @@ -2192,6 +2476,7 @@ assignment_rule(Parser *p) D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('(' single_target ')' | attribute_or_subscript_target) ':' expression ['=' annotated_rhs]")); } + if (_first_set_mask & 0x4ULL) { // ((star_targets '='))+ annotated_rhs !'=' TYPE_COMMENT? if (p->error_indicator) { p->level--; @@ -2233,6 +2518,7 @@ assignment_rule(Parser *p) D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))+ annotated_rhs !'=' TYPE_COMMENT?")); } + if (_first_set_mask & 0x8ULL) { // single_target augassign ~ annotated_rhs if (p->error_indicator) { p->level--; @@ -2279,6 +2565,7 @@ assignment_rule(Parser *p) return NULL; } } + if (_first_set_mask & 0x10ULL) if (p->call_invalid_rules) { // invalid_assignment if (p->error_indicator) { p->level--; @@ -2317,6 +2604,44 @@ annotated_rhs_rule(Parser *p) } expr_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 506: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 16: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // yield_expr if (p->error_indicator) { p->level--; @@ -2336,6 +2661,10 @@ annotated_rhs_rule(Parser *p) D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // star_expressions if (p->error_indicator) { p->level--; @@ -2355,6 +2684,11 @@ annotated_rhs_rule(Parser *p) D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -2387,6 +2721,45 @@ augassign_rule(Parser *p) } AugOperator* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 36: + goto _first_set_alt_0; + case 37: + goto _first_set_alt_1; + case 38: + goto _first_set_alt_2; + case 50: + goto _first_set_alt_3; + case 39: + goto _first_set_alt_4; + case 40: + goto _first_set_alt_5; + case 41: + goto _first_set_alt_6; + case 42: + goto _first_set_alt_7; + case 43: + goto _first_set_alt_8; + case 44: + goto _first_set_alt_9; + case 45: + goto _first_set_alt_10; + case 46: + goto _first_set_alt_11; + case 48: + goto _first_set_alt_12; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '+=' if (p->error_indicator) { p->level--; @@ -2411,6 +2784,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '-=' if (p->error_indicator) { p->level--; @@ -2435,6 +2812,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '*=' if (p->error_indicator) { p->level--; @@ -2459,6 +2840,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_3: { // '@=' if (p->error_indicator) { p->level--; @@ -2483,6 +2868,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_4: { // '/=' if (p->error_indicator) { p->level--; @@ -2507,6 +2896,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_5: { // '%=' if (p->error_indicator) { p->level--; @@ -2531,6 +2924,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_6: { // '&=' if (p->error_indicator) { p->level--; @@ -2555,6 +2952,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_7: { // '|=' if (p->error_indicator) { p->level--; @@ -2579,6 +2980,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_8: { // '^=' if (p->error_indicator) { p->level--; @@ -2603,6 +3008,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_9: { // '<<=' if (p->error_indicator) { p->level--; @@ -2627,6 +3036,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_10: { // '>>=' if (p->error_indicator) { p->level--; @@ -2651,6 +3064,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_11: { // '**=' if (p->error_indicator) { p->level--; @@ -2675,6 +3092,10 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_12: { // '//=' if (p->error_indicator) { p->level--; @@ -2699,6 +3120,11 @@ augassign_rule(Parser *p) D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -3491,6 +3917,29 @@ import_stmt_rule(Parser *p) return _res; } int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 500: + _first_set_mask = 0x2ULL; + break; + case 501: + _first_set_mask = 0x4ULL; + break; + case 1: + _first_set_mask = 0x6ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) if (p->call_invalid_rules) { // invalid_import if (p->error_indicator) { p->level--; @@ -3510,6 +3959,7 @@ import_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import")); } + if (_first_set_mask & 0x2ULL) { // import_name if (p->error_indicator) { p->level--; @@ -3529,6 +3979,7 @@ import_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_name")); } + if (_first_set_mask & 0x4ULL) { // import_from if (p->error_indicator) { p->level--; @@ -3791,6 +4242,20 @@ import_from_targets_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 7: + goto _first_set_alt_0; + case 1: + goto _first_set_alt_1; + case 16: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '(' import_from_as_names ','? ')' if (p->error_indicator) { p->level--; @@ -3825,6 +4290,10 @@ import_from_targets_rule(Parser *p) D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' import_from_as_names ','? ')'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // import_from_as_names !',' if (p->error_indicator) { p->level--; @@ -3846,6 +4315,10 @@ import_from_targets_rule(Parser *p) D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names !','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '*' if (p->error_indicator) { p->level--; @@ -3879,6 +4352,9 @@ import_from_targets_rule(Parser *p) D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } if (p->call_invalid_rules) { // invalid_import_from_targets if (p->error_indicator) { p->level--; @@ -3898,6 +4374,11 @@ import_from_targets_rule(Parser *p) D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import_from_targets")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -4279,6 +4760,53 @@ block_rule(Parser *p) return _res; } int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 4: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 16: + case 25: + case 31: + case 52: + case 59: + case 62: + case 500: + case 501: + case 502: + case 503: + case 504: + case 505: + case 506: + case 507: + case 508: + case 509: + case 510: + case 511: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // NEWLINE INDENT statements DEDENT if (p->error_indicator) { p->level--; @@ -4312,6 +4840,10 @@ block_rule(Parser *p) D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT statements DEDENT")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // simple_stmts if (p->error_indicator) { p->level--; @@ -4331,6 +4863,9 @@ block_rule(Parser *p) D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } if (p->call_invalid_rules) { // invalid_block if (p->error_indicator) { p->level--; @@ -4350,6 +4885,11 @@ block_rule(Parser *p) D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_block")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: _PyPegen_insert_memo(p, _mark, block_type, _res); @@ -4413,6 +4953,23 @@ class_def_rule(Parser *p) } stmt_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 49: + goto _first_set_alt_0; + case 515: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // decorators class_def_raw if (p->error_indicator) { p->level--; @@ -4440,6 +4997,10 @@ class_def_rule(Parser *p) D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators class_def_raw")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // class_def_raw if (p->error_indicator) { p->level--; @@ -4459,6 +5020,11 @@ class_def_rule(Parser *p) D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_def_raw")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -4575,6 +5141,24 @@ function_def_rule(Parser *p) } stmt_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 49: + goto _first_set_alt_0; + case 512: + case 513: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // decorators function_def_raw if (p->error_indicator) { p->level--; @@ -4602,6 +5186,10 @@ function_def_rule(Parser *p) D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators function_def_raw")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // function_def_raw if (p->error_indicator) { p->level--; @@ -4621,6 +5209,11 @@ function_def_rule(Parser *p) D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "function_def_raw")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -4652,6 +5245,17 @@ function_def_raw_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 512: + goto _first_set_alt_1; + case 513: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } if (p->call_invalid_rules) { // invalid_def_raw if (p->error_indicator) { p->level--; @@ -4671,6 +5275,10 @@ function_def_raw_rule(Parser *p) D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_def_raw")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block if (p->error_indicator) { p->level--; @@ -4731,6 +5339,10 @@ function_def_raw_rule(Parser *p) D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // 'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block if (p->error_indicator) { p->level--; @@ -4794,6 +5406,11 @@ function_def_raw_rule(Parser *p) D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -4875,6 +5492,27 @@ parameters_rule(Parser *p) } arguments_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + _first_set_mask = 0xfULL; + break; + case 16: + case 35: + _first_set_mask = 0x10ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // slash_no_default param_no_default* param_with_default* star_etc? if (p->error_indicator) { p->level--; @@ -4908,6 +5546,7 @@ parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?")); } + if (_first_set_mask & 0x2ULL) { // slash_with_default param_with_default* star_etc? if (p->error_indicator) { p->level--; @@ -4938,6 +5577,7 @@ parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default param_with_default* star_etc?")); } + if (_first_set_mask & 0x4ULL) { // param_no_default+ param_with_default* star_etc? if (p->error_indicator) { p->level--; @@ -4968,6 +5608,7 @@ parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ param_with_default* star_etc?")); } + if (_first_set_mask & 0x8ULL) { // param_with_default+ star_etc? if (p->error_indicator) { p->level--; @@ -4995,6 +5636,7 @@ parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+ star_etc?")); } + if (_first_set_mask & 0x10ULL) { // star_etc if (p->error_indicator) { p->level--; @@ -5207,6 +5849,26 @@ star_etc_rule(Parser *p) } StarEtc* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0xeULL; + break; + case 35: + _first_set_mask = 0x10ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) if (p->call_invalid_rules) { // invalid_star_etc if (p->error_indicator) { p->level--; @@ -5226,6 +5888,7 @@ star_etc_rule(Parser *p) D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_star_etc")); } + if (_first_set_mask & 0x2ULL) { // '*' param_no_default param_maybe_default* kwds? if (p->error_indicator) { p->level--; @@ -5259,6 +5922,7 @@ star_etc_rule(Parser *p) D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?")); } + if (_first_set_mask & 0x4ULL) { // '*' param_no_default_star_annotation param_maybe_default* kwds? if (p->error_indicator) { p->level--; @@ -5292,6 +5956,7 @@ star_etc_rule(Parser *p) D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default_star_annotation param_maybe_default* kwds?")); } + if (_first_set_mask & 0x8ULL) { // '*' ',' param_maybe_default+ kwds? if (p->error_indicator) { p->level--; @@ -5325,6 +5990,7 @@ star_etc_rule(Parser *p) D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' param_maybe_default+ kwds?")); } + if (_first_set_mask & 0x10ULL) { // kwds if (p->error_indicator) { p->level--; @@ -6499,6 +7165,17 @@ for_stmt_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 517: + goto _first_set_alt_1; + case 513: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } if (p->call_invalid_rules) { // invalid_for_stmt if (p->error_indicator) { p->level--; @@ -6518,6 +7195,10 @@ for_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_stmt")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? if (p->error_indicator) { p->level--; @@ -6579,6 +7260,10 @@ for_stmt_rule(Parser *p) return NULL; } } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // 'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? if (p->error_indicator) { p->level--; @@ -6643,6 +7328,9 @@ for_stmt_rule(Parser *p) return NULL; } } + if (!p->call_invalid_rules) { + goto _first_set_done; + } if (p->call_invalid_rules) { // invalid_for_target if (p->error_indicator) { p->level--; @@ -6662,6 +7350,11 @@ for_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -6696,6 +7389,21 @@ with_stmt_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 516: + _first_set_mask = 0x6ULL; + break; + case 513: + _first_set_mask = 0x18ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) if (p->call_invalid_rules) { // invalid_with_stmt_indent if (p->error_indicator) { p->level--; @@ -6715,6 +7423,7 @@ with_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt_indent")); } + if (_first_set_mask & 0x2ULL) { // 'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block if (p->error_indicator) { p->level--; @@ -6770,6 +7479,7 @@ with_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block")); } + if (_first_set_mask & 0x4ULL) { // 'with' ','.with_item+ ':' TYPE_COMMENT? block if (p->error_indicator) { p->level--; @@ -6815,6 +7525,7 @@ with_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block")); } + if (_first_set_mask & 0x8ULL) { // 'async' 'with' '(' ','.with_item+ ','? ')' ':' block if (p->error_indicator) { p->level--; @@ -6870,6 +7581,7 @@ with_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'with' '(' ','.with_item+ ','? ')' ':' block")); } + if (_first_set_mask & 0x10ULL) { // 'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block if (p->error_indicator) { p->level--; @@ -6918,6 +7630,7 @@ with_stmt_rule(Parser *p) D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block")); } + if (_first_set_mask & 0x20ULL) if (p->call_invalid_rules) { // invalid_with_stmt if (p->error_indicator) { p->level--; @@ -7874,6 +8587,41 @@ subject_expr_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x1ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // star_named_expression ',' star_named_expressions? if (p->error_indicator) { p->level--; @@ -7913,6 +8661,7 @@ subject_expr_rule(Parser *p) D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); } + if (_first_set_mask & 0x2ULL) { // named_expression if (p->error_indicator) { p->level--; @@ -8080,6 +8829,33 @@ patterns_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x1ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 59: + case 62: + case 526: + case 527: + case 528: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // open_sequence_pattern if (p->error_indicator) { p->level--; @@ -8113,6 +8889,7 @@ patterns_rule(Parser *p) D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "open_sequence_pattern")); } + if (_first_set_mask & 0x2ULL) { // pattern if (p->error_indicator) { p->level--; @@ -8367,6 +9144,43 @@ closed_pattern_rule(Parser *p) return _res; } int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + case 3: + case 14: + case 15: + case 59: + case 62: + case 526: + case 527: + case 528: + _first_set_mask = 0x1ULL; + break; + case 9: + _first_set_mask = 0x20ULL; + break; + case 7: + _first_set_mask = 0x30ULL; + break; + case 25: + _first_set_mask = 0x40ULL; + break; + case 1: + _first_set_mask = 0x8eULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // literal_pattern if (p->error_indicator) { p->level--; @@ -8386,6 +9200,7 @@ closed_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_pattern")); } + if (_first_set_mask & 0x2ULL) { // capture_pattern if (p->error_indicator) { p->level--; @@ -8405,6 +9220,7 @@ closed_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "capture_pattern")); } + if (_first_set_mask & 0x4ULL) { // wildcard_pattern if (p->error_indicator) { p->level--; @@ -8424,6 +9240,7 @@ closed_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "wildcard_pattern")); } + if (_first_set_mask & 0x8ULL) { // value_pattern if (p->error_indicator) { p->level--; @@ -8443,6 +9260,7 @@ closed_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "value_pattern")); } + if (_first_set_mask & 0x10ULL) { // group_pattern if (p->error_indicator) { p->level--; @@ -8462,6 +9280,7 @@ closed_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group_pattern")); } + if (_first_set_mask & 0x20ULL) { // sequence_pattern if (p->error_indicator) { p->level--; @@ -8481,6 +9300,7 @@ closed_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sequence_pattern")); } + if (_first_set_mask & 0x40ULL) { // mapping_pattern if (p->error_indicator) { p->level--; @@ -8500,6 +9320,7 @@ closed_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "mapping_pattern")); } + if (_first_set_mask & 0x80ULL) { // class_pattern if (p->error_indicator) { p->level--; @@ -8554,6 +9375,34 @@ literal_pattern_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + case 14: + case 15: + _first_set_mask = 0x3ULL; + break; + case 3: + case 59: + case 62: + _first_set_mask = 0x4ULL; + break; + case 526: + _first_set_mask = 0x8ULL; + break; + case 527: + _first_set_mask = 0x10ULL; + break; + case 528: + _first_set_mask = 0x20ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // signed_number !('+' | '-') if (p->error_indicator) { p->level--; @@ -8589,6 +9438,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')")); } + if (_first_set_mask & 0x2ULL) { // complex_number if (p->error_indicator) { p->level--; @@ -8622,6 +9472,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); } + if (_first_set_mask & 0x4ULL) { // strings if (p->error_indicator) { p->level--; @@ -8655,6 +9506,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings")); } + if (_first_set_mask & 0x8ULL) { // 'None' if (p->error_indicator) { p->level--; @@ -8688,6 +9540,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } + if (_first_set_mask & 0x10ULL) { // 'True' if (p->error_indicator) { p->level--; @@ -8721,6 +9574,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } + if (_first_set_mask & 0x20ULL) { // 'False' if (p->error_indicator) { p->level--; @@ -8788,6 +9642,34 @@ literal_expr_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + case 14: + case 15: + _first_set_mask = 0x3ULL; + break; + case 3: + case 59: + case 62: + _first_set_mask = 0x4ULL; + break; + case 526: + _first_set_mask = 0x8ULL; + break; + case 527: + _first_set_mask = 0x10ULL; + break; + case 528: + _first_set_mask = 0x20ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // signed_number !('+' | '-') if (p->error_indicator) { p->level--; @@ -8809,6 +9691,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')")); } + if (_first_set_mask & 0x2ULL) { // complex_number if (p->error_indicator) { p->level--; @@ -8828,6 +9711,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number")); } + if (_first_set_mask & 0x4ULL) { // &(STRING | FSTRING_START | TSTRING_START) strings if (p->error_indicator) { p->level--; @@ -8849,6 +9733,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings")); } + if (_first_set_mask & 0x8ULL) { // 'None' if (p->error_indicator) { p->level--; @@ -8882,6 +9767,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } + if (_first_set_mask & 0x10ULL) { // 'True' if (p->error_indicator) { p->level--; @@ -8915,6 +9801,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } + if (_first_set_mask & 0x20ULL) { // 'False' if (p->error_indicator) { p->level--; @@ -9084,6 +9971,20 @@ signed_number_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + goto _first_set_alt_0; + case 14: + goto _first_set_alt_1; + case 15: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // NUMBER if (p->error_indicator) { p->level--; @@ -9103,6 +10004,10 @@ signed_number_rule(Parser *p) D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '+' NUMBER if (p->error_indicator) { p->level--; @@ -9139,6 +10044,10 @@ signed_number_rule(Parser *p) D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' NUMBER")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '-' NUMBER if (p->error_indicator) { p->level--; @@ -9175,6 +10084,11 @@ signed_number_rule(Parser *p) D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' NUMBER")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -9203,6 +10117,20 @@ signed_real_number_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + goto _first_set_alt_0; + case 14: + goto _first_set_alt_1; + case 15: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // real_number if (p->error_indicator) { p->level--; @@ -9222,6 +10150,10 @@ signed_real_number_rule(Parser *p) D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "real_number")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '+' real_number if (p->error_indicator) { p->level--; @@ -9258,6 +10190,10 @@ signed_real_number_rule(Parser *p) D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' real_number")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '-' real_number if (p->error_indicator) { p->level--; @@ -9294,6 +10230,11 @@ signed_real_number_rule(Parser *p) D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' real_number")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -9852,6 +10793,18 @@ sequence_pattern_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 9: + goto _first_set_alt_0; + case 7: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '[' maybe_sequence_pattern? ']' if (p->error_indicator) { p->level--; @@ -9891,6 +10844,10 @@ sequence_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' maybe_sequence_pattern? ']'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '(' open_sequence_pattern? ')' if (p->error_indicator) { p->level--; @@ -9930,6 +10887,11 @@ sequence_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' open_sequence_pattern? ')'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -10045,6 +11007,35 @@ maybe_star_pattern_rule(Parser *p) } pattern_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 59: + case 62: + case 526: + case 527: + case 528: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // star_pattern if (p->error_indicator) { p->level--; @@ -10064,6 +11055,10 @@ maybe_star_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_pattern")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // pattern if (p->error_indicator) { p->level--; @@ -10083,6 +11078,11 @@ maybe_star_pattern_rule(Parser *p) D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -11133,6 +12133,20 @@ type_param_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + goto _first_set_alt_0; + case 16: + goto _first_set_alt_2; + case 35: + goto _first_set_alt_3; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // NAME type_param_bound? type_param_default? if (p->error_indicator) { p->level--; @@ -11172,6 +12186,9 @@ type_param_rule(Parser *p) D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME type_param_bound? type_param_default?")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } if (p->call_invalid_rules) { // invalid_type_param if (p->error_indicator) { p->level--; @@ -11191,6 +12208,10 @@ type_param_rule(Parser *p) D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_type_param")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '*' NAME type_param_starred_default? if (p->error_indicator) { p->level--; @@ -11230,6 +12251,10 @@ type_param_rule(Parser *p) D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' NAME type_param_starred_default?")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_3: { // '**' NAME type_param_default? if (p->error_indicator) { p->level--; @@ -11269,6 +12294,11 @@ type_param_rule(Parser *p) D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' NAME type_param_default?")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: _PyPegen_insert_memo(p, _mark, type_param_type, _res); @@ -11562,6 +12592,42 @@ expression_rule(Parser *p) return _res; } int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + case 531: + case 533: + _first_set_mask = 0x18ULL; + break; + case 534: + _first_set_mask = 0x20ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) if (p->call_invalid_rules) { // invalid_if_expression if (p->error_indicator) { p->level--; @@ -11581,6 +12647,7 @@ expression_rule(Parser *p) D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_if_expression")); } + if (_first_set_mask & 0x2ULL) if (p->call_invalid_rules) { // invalid_expression if (p->error_indicator) { p->level--; @@ -11600,6 +12667,7 @@ expression_rule(Parser *p) D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_expression")); } + if (_first_set_mask & 0x4ULL) if (p->call_invalid_rules) { // invalid_legacy_expression if (p->error_indicator) { p->level--; @@ -11619,6 +12687,7 @@ expression_rule(Parser *p) D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_legacy_expression")); } + if (_first_set_mask & 0x8ULL) { // if_expression if (p->error_indicator) { p->level--; @@ -11638,6 +12707,7 @@ expression_rule(Parser *p) D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "if_expression")); } + if (_first_set_mask & 0x10ULL) { // disjunction if (p->error_indicator) { p->level--; @@ -11657,6 +12727,7 @@ expression_rule(Parser *p) D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction")); } + if (_first_set_mask & 0x20ULL) { // lambdef if (p->error_indicator) { p->level--; @@ -12013,6 +13084,38 @@ star_expression_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '*' bitwise_or if (p->error_indicator) { p->level--; @@ -12049,6 +13152,10 @@ star_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // expression if (p->error_indicator) { p->level--; @@ -12068,6 +13175,11 @@ star_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: _PyPegen_insert_memo(p, _mark, star_expression_type, _res); @@ -12144,6 +13256,38 @@ star_named_expression_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '*' bitwise_or if (p->error_indicator) { p->level--; @@ -12180,6 +13324,10 @@ star_named_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // named_expression if (p->error_indicator) { p->level--; @@ -12199,6 +13347,11 @@ star_named_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -12292,6 +13445,45 @@ named_expression_rule(Parser *p) } expr_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x4ULL; + break; + case 1: + _first_set_mask = 0x5ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // assignment_expression if (p->error_indicator) { p->level--; @@ -12311,6 +13503,7 @@ named_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } + if (_first_set_mask & 0x2ULL) if (p->call_invalid_rules) { // invalid_named_expression if (p->error_indicator) { p->level--; @@ -12330,6 +13523,7 @@ named_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_named_expression")); } + if (_first_set_mask & 0x4ULL) { // expression !':=' if (p->error_indicator) { p->level--; @@ -12563,6 +13757,33 @@ inversion_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 531: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + case 533: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'not' inversion if (p->error_indicator) { p->level--; @@ -12599,6 +13820,10 @@ inversion_rule(Parser *p) D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' inversion")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // comparison if (p->error_indicator) { p->level--; @@ -12618,6 +13843,11 @@ inversion_rule(Parser *p) D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: _PyPegen_insert_memo(p, _mark, inversion_type, _res); @@ -12734,6 +13964,47 @@ compare_op_bitwise_or_pair_rule(Parser *p) } CmpopExprPair* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 27: + _first_set_mask = 0x1ULL; + break; + case 28: + _first_set_mask = 0x2ULL; + break; + case 29: + _first_set_mask = 0x4ULL; + break; + case 20: + _first_set_mask = 0x10ULL; + break; + case 30: + _first_set_mask = 0x20ULL; + break; + case 21: + _first_set_mask = 0x40ULL; + break; + case 531: + _first_set_mask = 0x80ULL; + break; + case 523: + _first_set_mask = 0x100ULL; + break; + case 532: + _first_set_mask = 0x600ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // '==' bitwise_or if (p->error_indicator) { p->level--; @@ -12761,6 +14032,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'==' bitwise_or")); } + if (_first_set_mask & 0x2ULL) { // ('!=') bitwise_or if (p->error_indicator) { p->level--; @@ -12788,6 +14060,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('!=') bitwise_or")); } + if (_first_set_mask & 0x4ULL) { // '<=' bitwise_or if (p->error_indicator) { p->level--; @@ -12815,6 +14088,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<=' bitwise_or")); } + if (_first_set_mask & 0x8ULL) if (p->call_invalid_rules) { // invalid_noteq if (p->error_indicator) { p->level--; @@ -12834,6 +14108,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_noteq")); } + if (_first_set_mask & 0x10ULL) { // '<' bitwise_or if (p->error_indicator) { p->level--; @@ -12861,6 +14136,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<' bitwise_or")); } + if (_first_set_mask & 0x20ULL) { // '>=' bitwise_or if (p->error_indicator) { p->level--; @@ -12888,6 +14164,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>=' bitwise_or")); } + if (_first_set_mask & 0x40ULL) { // '>' bitwise_or if (p->error_indicator) { p->level--; @@ -12915,6 +14192,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>' bitwise_or")); } + if (_first_set_mask & 0x80ULL) { // 'not' 'in' bitwise_or if (p->error_indicator) { p->level--; @@ -12945,6 +14223,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' 'in' bitwise_or")); } + if (_first_set_mask & 0x100ULL) { // 'in' bitwise_or if (p->error_indicator) { p->level--; @@ -12972,6 +14251,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'in' bitwise_or")); } + if (_first_set_mask & 0x200ULL) { // 'is' 'not' bitwise_or if (p->error_indicator) { p->level--; @@ -13002,6 +14282,7 @@ compare_op_bitwise_or_pair_rule(Parser *p) D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' 'not' bitwise_or")); } + if (_first_set_mask & 0x400ULL) { // 'is' bitwise_or if (p->error_indicator) { p->level--; @@ -14108,6 +15389,34 @@ factor_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 14: + goto _first_set_alt_0; + case 15: + goto _first_set_alt_1; + case 31: + goto _first_set_alt_2; + case 1: + case 2: + case 3: + case 7: + case 9: + case 25: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + case 533: + goto _first_set_alt_3; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '+' factor if (p->error_indicator) { p->level--; @@ -14144,6 +15453,10 @@ factor_rule(Parser *p) D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' factor")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '-' factor if (p->error_indicator) { p->level--; @@ -14180,6 +15493,10 @@ factor_rule(Parser *p) D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' factor")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '~' factor if (p->error_indicator) { p->level--; @@ -14216,6 +15533,10 @@ factor_rule(Parser *p) D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~' factor")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_3: { // power if (p->error_indicator) { p->level--; @@ -14235,6 +15556,9 @@ factor_rule(Parser *p) D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } if (p->call_invalid_rules) { // invalid_factor if (p->error_indicator) { p->level--; @@ -14254,6 +15578,11 @@ factor_rule(Parser *p) D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_factor")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: _PyPegen_insert_memo(p, _mark, factor_type, _res); @@ -14375,6 +15704,29 @@ await_primary_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 533: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 25: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'await' primary if (p->error_indicator) { p->level--; @@ -14411,6 +15763,10 @@ await_primary_rule(Parser *p) D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'await' primary")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // primary if (p->error_indicator) { p->level--; @@ -14430,6 +15786,11 @@ await_primary_rule(Parser *p) D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: _PyPegen_insert_memo(p, _mark, await_primary_type, _res); @@ -14710,6 +16071,42 @@ slices_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x2ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 11: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // slice !',' if (p->error_indicator) { p->level--; @@ -14736,6 +16133,7 @@ slices_rule(Parser *p) D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice !','")); } + if (_first_set_mask & 0x2ULL) { // ','.(slice | starred_expression)+ ','? if (p->error_indicator) { p->level--; @@ -14801,6 +16199,41 @@ slice_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 11: + _first_set_mask = 0x1ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // expression? ':' expression? [':' expression?] if (p->error_indicator) { p->level--; @@ -14843,6 +16276,7 @@ slice_rule(Parser *p) D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?]")); } + if (_first_set_mask & 0x2ULL) { // named_expression if (p->error_indicator) { p->level--; @@ -14905,6 +16339,36 @@ atom_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + goto _first_set_alt_0; + case 527: + goto _first_set_alt_1; + case 528: + goto _first_set_alt_2; + case 526: + goto _first_set_alt_3; + case 3: + case 59: + case 62: + goto _first_set_alt_4; + case 2: + goto _first_set_alt_5; + case 7: + goto _first_set_alt_6; + case 9: + goto _first_set_alt_7; + case 25: + goto _first_set_alt_8; + case 52: + goto _first_set_alt_9; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // NAME if (p->error_indicator) { p->level--; @@ -14924,6 +16388,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // 'True' if (p->error_indicator) { p->level--; @@ -14957,6 +16425,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // 'False' if (p->error_indicator) { p->level--; @@ -14990,6 +16462,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_3: { // 'None' if (p->error_indicator) { p->level--; @@ -15023,6 +16499,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_4: { // &(STRING | FSTRING_START | TSTRING_START) strings if (p->error_indicator) { p->level--; @@ -15044,6 +16524,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_5: { // NUMBER if (p->error_indicator) { p->level--; @@ -15063,6 +16547,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_6: { // &'(' (genexp | tuple | group) if (p->error_indicator) { p->level--; @@ -15084,6 +16572,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (genexp | tuple | group)")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_7: { // &'[' (listcomp | list) if (p->error_indicator) { p->level--; @@ -15105,6 +16597,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (listcomp | list)")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_8: { // &'{' (dictcomp | setcomp | dict | set) if (p->error_indicator) { p->level--; @@ -15126,6 +16622,10 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dictcomp | setcomp | dict | set)")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_9: { // '...' if (p->error_indicator) { p->level--; @@ -15159,6 +16659,11 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -15378,6 +16883,27 @@ lambda_parameters_rule(Parser *p) } arguments_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + _first_set_mask = 0xfULL; + break; + case 16: + case 35: + _first_set_mask = 0x10ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc? if (p->error_indicator) { p->level--; @@ -15411,6 +16937,7 @@ lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?")); } + if (_first_set_mask & 0x2ULL) { // lambda_slash_with_default lambda_param_with_default* lambda_star_etc? if (p->error_indicator) { p->level--; @@ -15441,6 +16968,7 @@ lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?")); } + if (_first_set_mask & 0x4ULL) { // lambda_param_no_default+ lambda_param_with_default* lambda_star_etc? if (p->error_indicator) { p->level--; @@ -15471,6 +16999,7 @@ lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?")); } + if (_first_set_mask & 0x8ULL) { // lambda_param_with_default+ lambda_star_etc? if (p->error_indicator) { p->level--; @@ -15498,6 +17027,7 @@ lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?")); } + if (_first_set_mask & 0x10ULL) { // lambda_star_etc if (p->error_indicator) { p->level--; @@ -15711,6 +17241,26 @@ lambda_star_etc_rule(Parser *p) } StarEtc* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x6ULL; + break; + case 35: + _first_set_mask = 0x8ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) if (p->call_invalid_rules) { // invalid_lambda_star_etc if (p->error_indicator) { p->level--; @@ -15730,6 +17280,7 @@ lambda_star_etc_rule(Parser *p) D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_star_etc")); } + if (_first_set_mask & 0x2ULL) { // '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds? if (p->error_indicator) { p->level--; @@ -15763,6 +17314,7 @@ lambda_star_etc_rule(Parser *p) D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?")); } + if (_first_set_mask & 0x4ULL) { // '*' ',' lambda_param_maybe_default+ lambda_kwds? if (p->error_indicator) { p->level--; @@ -15796,6 +17348,7 @@ lambda_star_etc_rule(Parser *p) D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?")); } + if (_first_set_mask & 0x8ULL) { // lambda_kwds if (p->error_indicator) { p->level--; @@ -16193,6 +17746,23 @@ fstring_middle_rule(Parser *p) } expr_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 25: + goto _first_set_alt_0; + case 60: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // fstring_replacement_field if (p->error_indicator) { p->level--; @@ -16212,6 +17782,10 @@ fstring_middle_rule(Parser *p) D(fprintf(stderr, "%*c%s fstring_middle[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_replacement_field")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // FSTRING_MIDDLE if (p->error_indicator) { p->level--; @@ -16236,6 +17810,11 @@ fstring_middle_rule(Parser *p) D(fprintf(stderr, "%*c%s fstring_middle[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -16462,6 +18041,23 @@ fstring_format_spec_rule(Parser *p) } expr_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 60: + goto _first_set_alt_0; + case 25: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // FSTRING_MIDDLE if (p->error_indicator) { p->level--; @@ -16486,6 +18082,10 @@ fstring_format_spec_rule(Parser *p) D(fprintf(stderr, "%*c%s fstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // fstring_replacement_field if (p->error_indicator) { p->level--; @@ -16505,6 +18105,11 @@ fstring_format_spec_rule(Parser *p) D(fprintf(stderr, "%*c%s fstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_replacement_field")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -16670,6 +18275,23 @@ tstring_format_spec_rule(Parser *p) } expr_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 63: + goto _first_set_alt_0; + case 25: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // TSTRING_MIDDLE if (p->error_indicator) { p->level--; @@ -16694,6 +18316,10 @@ tstring_format_spec_rule(Parser *p) D(fprintf(stderr, "%*c%s tstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_MIDDLE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // tstring_format_spec_replacement_field if (p->error_indicator) { p->level--; @@ -16713,6 +18339,11 @@ tstring_format_spec_rule(Parser *p) D(fprintf(stderr, "%*c%s tstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_format_spec_replacement_field")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -16893,6 +18524,23 @@ tstring_middle_rule(Parser *p) } expr_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 25: + goto _first_set_alt_0; + case 63: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // tstring_replacement_field if (p->error_indicator) { p->level--; @@ -16912,6 +18560,10 @@ tstring_middle_rule(Parser *p) D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_replacement_field")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // TSTRING_MIDDLE if (p->error_indicator) { p->level--; @@ -16936,6 +18588,11 @@ tstring_middle_rule(Parser *p) D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_MIDDLE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -17065,6 +18722,18 @@ strings_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 3: + case 59: + goto _first_set_alt_1; + case 62: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } if (p->call_invalid_rules) { // invalid_string_tstring_concat if (p->error_indicator) { p->level--; @@ -17084,6 +18753,10 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_string_tstring_concat")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ((fstring | string))+ if (p->error_indicator) { p->level--; @@ -17117,6 +18790,10 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((fstring | string))+")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // tstring+ if (p->error_indicator) { p->level--; @@ -17150,6 +18827,11 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring+")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: _PyPegen_insert_memo(p, _mark, strings_type, _res); @@ -17614,6 +19296,43 @@ double_starred_kvpair_rule(Parser *p) } KeyValuePair* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 35: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '**' bitwise_or if (p->error_indicator) { p->level--; @@ -17641,6 +19360,10 @@ double_starred_kvpair_rule(Parser *p) D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // kvpair if (p->error_indicator) { p->level--; @@ -17660,6 +19383,11 @@ double_starred_kvpair_rule(Parser *p) D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kvpair")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -17775,6 +19503,23 @@ for_if_clause_rule(Parser *p) } comprehension_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 513: + goto _first_set_alt_0; + case 517: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))* if (p->error_indicator) { p->level--; @@ -17821,6 +19566,10 @@ for_if_clause_rule(Parser *p) return NULL; } } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))* if (p->error_indicator) { p->level--; @@ -17864,6 +19613,9 @@ for_if_clause_rule(Parser *p) return NULL; } } + if (!p->call_invalid_rules) { + goto _first_set_done; + } if (p->call_invalid_rules) { // invalid_for_if_clause if (p->error_indicator) { p->level--; @@ -17883,6 +19635,9 @@ for_if_clause_rule(Parser *p) D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_if_clause")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } if (p->call_invalid_rules) { // invalid_for_target if (p->error_indicator) { p->level--; @@ -17902,6 +19657,11 @@ for_if_clause_rule(Parser *p) D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -18389,6 +20149,42 @@ args_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 35: + _first_set_mask = 0x2ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 16: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs] if (p->error_indicator) { p->level--; @@ -18425,6 +20221,7 @@ args_rule(Parser *p) D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]")); } + if (_first_set_mask & 0x2ULL) { // kwargs if (p->error_indicator) { p->level--; @@ -18479,6 +20276,47 @@ kwargs_rule(Parser *p) } asdl_seq* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x1ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 35: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // ','.kwarg_or_starred+ [',' ','.kwarg_or_double_starred+] if (p->error_indicator) { p->level--; @@ -18506,6 +20344,7 @@ kwargs_rule(Parser *p) D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+ [',' ','.kwarg_or_double_starred+]")); } + if (_first_set_mask & 0x2ULL) { // ','.kwarg_or_double_starred+ if (p->error_indicator) { p->level--; @@ -18658,6 +20497,17 @@ kwarg_or_starred_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + goto _first_set_alt_1; + case 16: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } if (p->call_invalid_rules) { // invalid_kwarg if (p->error_indicator) { p->level--; @@ -18677,6 +20527,10 @@ kwarg_or_starred_rule(Parser *p) D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // NAME '=' expression if (p->error_indicator) { p->level--; @@ -18716,6 +20570,10 @@ kwarg_or_starred_rule(Parser *p) D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // starred_expression if (p->error_indicator) { p->level--; @@ -18740,6 +20598,11 @@ kwarg_or_starred_rule(Parser *p) D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -18768,6 +20631,17 @@ kwarg_or_double_starred_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + goto _first_set_alt_1; + case 35: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } if (p->call_invalid_rules) { // invalid_kwarg if (p->error_indicator) { p->level--; @@ -18787,6 +20661,10 @@ kwarg_or_double_starred_rule(Parser *p) D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // NAME '=' expression if (p->error_indicator) { p->level--; @@ -18826,6 +20704,10 @@ kwarg_or_double_starred_rule(Parser *p) D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '**' expression if (p->error_indicator) { p->level--; @@ -18862,6 +20744,11 @@ kwarg_or_double_starred_rule(Parser *p) D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -18990,6 +20877,29 @@ star_target_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 25: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '*' (!'*' star_target) if (p->error_indicator) { p->level--; @@ -19026,6 +20936,10 @@ star_target_rule(Parser *p) D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (!'*' star_target)")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // target if (p->error_indicator) { p->level--; @@ -19045,6 +20959,11 @@ star_target_rule(Parser *p) D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "target")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: _PyPegen_insert_memo(p, _mark, star_target_type, _res); @@ -19346,6 +21265,49 @@ type_expressions_rule(Parser *p) } asdl_expr_seq* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x18ULL; + break; + case 35: + _first_set_mask = 0x20ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x47ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // ','.expression+ ',' '*' expression ',' '**' expression if (p->error_indicator) { p->level--; @@ -19388,6 +21350,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression")); } + if (_first_set_mask & 0x2ULL) { // ','.expression+ ',' '*' expression if (p->error_indicator) { p->level--; @@ -19421,6 +21384,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression")); } + if (_first_set_mask & 0x4ULL) { // ','.expression+ ',' '**' expression if (p->error_indicator) { p->level--; @@ -19454,6 +21418,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '**' expression")); } + if (_first_set_mask & 0x8ULL) { // '*' expression ',' '**' expression if (p->error_indicator) { p->level--; @@ -19490,6 +21455,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression ',' '**' expression")); } + if (_first_set_mask & 0x10ULL) { // '*' expression if (p->error_indicator) { p->level--; @@ -19517,6 +21483,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression")); } + if (_first_set_mask & 0x20ULL) { // '**' expression if (p->error_indicator) { p->level--; @@ -19544,6 +21511,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression")); } + if (_first_set_mask & 0x40ULL) { // ','.expression+ if (p->error_indicator) { p->level--; @@ -19590,6 +21558,23 @@ func_type_comment_rule(Parser *p) } Token* _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 4: + goto _first_set_alt_0; + case 57: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // NEWLINE TYPE_COMMENT &(NEWLINE INDENT) if (p->error_indicator) { p->level--; @@ -19619,6 +21604,9 @@ func_type_comment_rule(Parser *p) D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } if (p->call_invalid_rules) { // invalid_double_type_comments if (p->error_indicator) { p->level--; @@ -19638,6 +21626,10 @@ func_type_comment_rule(Parser *p) D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_double_type_comments")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // TYPE_COMMENT if (p->error_indicator) { p->level--; @@ -19657,6 +21649,11 @@ func_type_comment_rule(Parser *p) D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -19683,6 +21680,49 @@ invalid_arguments_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + case 35: + _first_set_mask = 0x79ULL; + break; + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x7bULL; + break; + case 1: + _first_set_mask = 0x7fULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // ((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+ if (p->error_indicator) { p->level--; @@ -19713,6 +21753,7 @@ invalid_arguments_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+")); } + if (_first_set_mask & 0x2ULL) { // expression for_if_clauses ',' [args | expression for_if_clauses] if (p->error_indicator) { p->level--; @@ -19747,6 +21788,7 @@ invalid_arguments_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]")); } + if (_first_set_mask & 0x4ULL) { // NAME '=' expression for_if_clauses if (p->error_indicator) { p->level--; @@ -19780,6 +21822,7 @@ invalid_arguments_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses")); } + if (_first_set_mask & 0x8ULL) { // [(args ',')] NAME '=' &(',' | ')') if (p->error_indicator) { p->level--; @@ -19813,6 +21856,7 @@ invalid_arguments_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')")); } + if (_first_set_mask & 0x10ULL) { // args for_if_clauses if (p->error_indicator) { p->level--; @@ -19840,6 +21884,7 @@ invalid_arguments_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args for_if_clauses")); } + if (_first_set_mask & 0x20ULL) { // args ',' expression for_if_clauses if (p->error_indicator) { p->level--; @@ -19873,6 +21918,7 @@ invalid_arguments_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' expression for_if_clauses")); } + if (_first_set_mask & 0x40ULL) { // args ',' args if (p->error_indicator) { p->level--; @@ -19928,6 +21974,54 @@ invalid_kwarg_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 531: + case 533: + case 534: + _first_set_mask = 0x10ULL; + break; + case 527: + _first_set_mask = 0x11ULL; + break; + case 528: + _first_set_mask = 0x12ULL; + break; + case 526: + _first_set_mask = 0x14ULL; + break; + case 1: + _first_set_mask = 0x18ULL; + break; + case 35: + _first_set_mask = 0x20ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // 'True' '=' if (p->error_indicator) { p->level--; @@ -19955,6 +22049,7 @@ invalid_kwarg_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True' '='")); } + if (_first_set_mask & 0x2ULL) { // 'False' '=' if (p->error_indicator) { p->level--; @@ -19982,6 +22077,7 @@ invalid_kwarg_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False' '='")); } + if (_first_set_mask & 0x4ULL) { // 'None' '=' if (p->error_indicator) { p->level--; @@ -20009,6 +22105,7 @@ invalid_kwarg_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None' '='")); } + if (_first_set_mask & 0x8ULL) { // NAME '=' expression for_if_clauses if (p->error_indicator) { p->level--; @@ -20042,6 +22139,7 @@ invalid_kwarg_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses")); } + if (_first_set_mask & 0x10ULL) { // !(NAME '=') expression '=' if (p->error_indicator) { p->level--; @@ -20071,6 +22169,7 @@ invalid_kwarg_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='")); } + if (_first_set_mask & 0x20ULL) { // '**' expression '=' expression if (p->error_indicator) { p->level--; @@ -20141,6 +22240,37 @@ expression_without_invalid_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + case 531: + case 533: + _first_set_mask = 0x3ULL; + break; + case 534: + _first_set_mask = 0x4ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // disjunction 'if' disjunction 'else' expression if (p->error_indicator) { p->call_invalid_rules = _prev_call_invalid; @@ -20189,6 +22319,7 @@ expression_without_invalid_rule(Parser *p) D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); } + if (_first_set_mask & 0x2ULL) { // disjunction if (p->error_indicator) { p->call_invalid_rules = _prev_call_invalid; @@ -20209,6 +22340,7 @@ expression_without_invalid_rule(Parser *p) D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction")); } + if (_first_set_mask & 0x4ULL) { // lambdef if (p->error_indicator) { p->call_invalid_rules = _prev_call_invalid; @@ -20297,6 +22429,23 @@ invalid_type_param_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + goto _first_set_alt_0; + case 35: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '*' NAME ':' expression if (p->error_indicator) { p->level--; @@ -20330,6 +22479,10 @@ invalid_type_param_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_type_param[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' NAME ':' expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '**' NAME ':' expression if (p->error_indicator) { p->level--; @@ -20363,6 +22516,11 @@ invalid_type_param_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_type_param[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' NAME ':' expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -20391,6 +22549,49 @@ invalid_expression_rule(Parser *p) int _mark = p->mark; expr_ty _prefix_12_result = NULL; int _prefix_12_end = 0, _prefix_12_valid = 0; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + case 2: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + case 531: + case 533: + _first_set_mask = 0xeULL; + break; + case 3: + _first_set_mask = 0xfULL; + break; + case 504: + case 508: + case 509: + _first_set_mask = 0x10ULL; + break; + case 534: + _first_set_mask = 0x60ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // STRING ((!STRING expression_without_invalid))+ STRING if (p->error_indicator) { p->level--; @@ -20421,6 +22622,7 @@ invalid_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING ((!STRING expression_without_invalid))+ STRING")); } + if (_first_set_mask & 0x2ULL) { // !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid if (p->error_indicator) { p->level--; @@ -20450,6 +22652,7 @@ invalid_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid")); } + if (_first_set_mask & 0x4ULL) { // disjunction 'if' disjunction !('else' | ':') if (p->error_indicator) { p->level--; @@ -20482,6 +22685,7 @@ invalid_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); } + if (_first_set_mask & 0x8ULL) { // disjunction 'if' disjunction 'else' !expression if (p->error_indicator) { p->level--; @@ -20517,6 +22721,7 @@ invalid_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' !expression")); } + if (_first_set_mask & 0x10ULL) { // (pass_stmt | break_stmt | continue_stmt) 'if' disjunction 'else' simple_stmt if (p->error_indicator) { p->level--; @@ -20553,6 +22758,7 @@ invalid_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(pass_stmt | break_stmt | continue_stmt) 'if' disjunction 'else' simple_stmt")); } + if (_first_set_mask & 0x20ULL) { // 'lambda' lambda_params? ':' &FSTRING_MIDDLE if (p->error_indicator) { p->level--; @@ -20586,6 +22792,7 @@ invalid_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE")); } + if (_first_set_mask & 0x40ULL) { // 'lambda' lambda_params? ':' &TSTRING_MIDDLE if (p->error_indicator) { p->level--; @@ -20740,6 +22947,47 @@ invalid_named_expression_rule(Parser *p) return _res; } int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 504: + case 508: + case 509: + case 531: + case 534: + _first_set_mask = 0x1ULL; + break; + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + case 533: + _first_set_mask = 0x5ULL; + break; + case 1: + _first_set_mask = 0x7ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // expression ':=' expression if (p->error_indicator) { p->level--; @@ -20770,6 +23018,7 @@ invalid_named_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':=' expression")); } + if (_first_set_mask & 0x2ULL) { // NAME '=' bitwise_or !('=' | ':=') if (p->error_indicator) { p->level--; @@ -20802,6 +23051,7 @@ invalid_named_expression_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); } + if (_first_set_mask & 0x4ULL) { // !(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=') if (p->error_indicator) { p->level--; @@ -20862,6 +23112,53 @@ invalid_assignment_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 506: + _first_set_mask = 0x10ULL; + break; + case 14: + case 15: + case 31: + case 504: + case 508: + case 509: + case 531: + case 533: + case 534: + _first_set_mask = 0x2eULL; + break; + case 16: + _first_set_mask = 0x3aULL; + break; + case 1: + case 2: + case 3: + case 25: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + _first_set_mask = 0x3eULL; + break; + case 7: + case 9: + _first_set_mask = 0x3fULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // invalid_ann_assign_target ':' expression if (p->error_indicator) { p->level--; @@ -20892,6 +23189,7 @@ invalid_assignment_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_ann_assign_target ':' expression")); } + if (_first_set_mask & 0x2ULL) { // star_named_expression ',' star_named_expressions* ':' expression if (p->error_indicator) { p->level--; @@ -20928,6 +23226,7 @@ invalid_assignment_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression")); } + if (_first_set_mask & 0x4ULL) { // expression ':' expression if (p->error_indicator) { p->level--; @@ -20958,6 +23257,7 @@ invalid_assignment_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression")); } + if (_first_set_mask & 0x8ULL) { // ((star_targets '='))* star_expressions '=' if (p->error_indicator) { p->level--; @@ -20988,6 +23288,7 @@ invalid_assignment_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* star_expressions '='")); } + if (_first_set_mask & 0x10ULL) { // ((star_targets '='))* yield_expr '=' if (p->error_indicator) { p->level--; @@ -21018,6 +23319,7 @@ invalid_assignment_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* yield_expr '='")); } + if (_first_set_mask & 0x20ULL) { // star_expressions augassign annotated_rhs if (p->error_indicator) { p->level--; @@ -21067,6 +23369,26 @@ invalid_ann_assign_target_rule(Parser *p) } expr_ty _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 9: + _first_set_mask = 0x1ULL; + break; + case 7: + _first_set_mask = 0x6ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // list if (p->error_indicator) { p->level--; @@ -21086,6 +23408,7 @@ invalid_ann_assign_target_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); } + if (_first_set_mask & 0x2ULL) { // tuple if (p->error_indicator) { p->level--; @@ -21105,6 +23428,7 @@ invalid_ann_assign_target_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); } + if (_first_set_mask & 0x4ULL) { // '(' invalid_ann_assign_target ')' if (p->error_indicator) { p->level--; @@ -21492,6 +23816,29 @@ invalid_comprehension_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 7: + _first_set_mask = 0x2ULL; + break; + case 25: + _first_set_mask = 0xcULL; + break; + case 9: + _first_set_mask = 0xdULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // '[' '**' expression for_if_clauses if (p->error_indicator) { p->level--; @@ -21525,6 +23872,7 @@ invalid_comprehension_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' '**' expression for_if_clauses")); } + if (_first_set_mask & 0x2ULL) { // '(' '**' expression for_if_clauses if (p->error_indicator) { p->level--; @@ -21558,6 +23906,7 @@ invalid_comprehension_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' '**' expression for_if_clauses")); } + if (_first_set_mask & 0x4ULL) { // ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses if (p->error_indicator) { p->level--; @@ -21594,6 +23943,7 @@ invalid_comprehension_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); } + if (_first_set_mask & 0x8ULL) { // ('[' | '{') star_named_expression ',' for_if_clauses if (p->error_indicator) { p->level--; @@ -21652,6 +24002,29 @@ invalid_parameters_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 7: + _first_set_mask = 0x9ULL; + break; + case 16: + _first_set_mask = 0x11ULL; + break; + case 1: + _first_set_mask = 0x3fULL; + break; + default: + _first_set_mask = 0x1ULL; + } + } + if (_first_set_mask & 0x1ULL) { // "/" ',' if (p->error_indicator) { p->level--; @@ -21679,6 +24052,7 @@ invalid_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','")); } + if (_first_set_mask & 0x2ULL) { // (slash_no_default | slash_with_default) param_maybe_default* '/' if (p->error_indicator) { p->level--; @@ -21709,6 +24083,7 @@ invalid_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'")); } + if (_first_set_mask & 0x4ULL) { // slash_no_default? param_no_default* invalid_parameters_helper param_no_default if (p->error_indicator) { p->level--; @@ -21743,6 +24118,7 @@ invalid_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default? param_no_default* invalid_parameters_helper param_no_default")); } + if (_first_set_mask & 0x8ULL) { // param_no_default* '(' param_no_default+ ','? ')' if (p->error_indicator) { p->level--; @@ -21780,6 +24156,7 @@ invalid_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* '(' param_no_default+ ','? ')'")); } + if (_first_set_mask & 0x10ULL) { // [(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/' if (p->error_indicator) { p->level--; @@ -21820,6 +24197,7 @@ invalid_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'")); } + if (_first_set_mask & 0x20ULL) { // param_maybe_default+ '/' '*' if (p->error_indicator) { p->level--; @@ -22243,6 +24621,29 @@ invalid_lambda_parameters_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 7: + _first_set_mask = 0x9ULL; + break; + case 16: + _first_set_mask = 0x11ULL; + break; + case 1: + _first_set_mask = 0x3fULL; + break; + default: + _first_set_mask = 0x1ULL; + } + } + if (_first_set_mask & 0x1ULL) { // "/" ',' if (p->error_indicator) { p->level--; @@ -22270,6 +24671,7 @@ invalid_lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','")); } + if (_first_set_mask & 0x2ULL) { // (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/' if (p->error_indicator) { p->level--; @@ -22300,6 +24702,7 @@ invalid_lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'")); } + if (_first_set_mask & 0x4ULL) { // lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default if (p->error_indicator) { p->level--; @@ -22334,6 +24737,7 @@ invalid_lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default")); } + if (_first_set_mask & 0x8ULL) { // lambda_param_no_default* '(' ','.lambda_param+ ','? ')' if (p->error_indicator) { p->level--; @@ -22371,6 +24775,7 @@ invalid_lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'")); } + if (_first_set_mask & 0x10ULL) { // [(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/' if (p->error_indicator) { p->level--; @@ -22411,6 +24816,7 @@ invalid_lambda_parameters_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', 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* '/'")); } + if (_first_set_mask & 0x20ULL) { // lambda_param_maybe_default+ '/' '*' if (p->error_indicator) { p->level--; @@ -23287,6 +25693,23 @@ invalid_import_from_targets_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + goto _first_set_alt_0; + case 4: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // import_from_as_names ',' NEWLINE if (p->error_indicator) { p->level--; @@ -23317,6 +25740,10 @@ invalid_import_from_targets_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names ',' NEWLINE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // NEWLINE if (p->error_indicator) { p->level--; @@ -23341,6 +25768,11 @@ invalid_import_from_targets_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -25481,6 +27913,49 @@ invalid_double_starred_kvpairs_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x1ULL; + break; + case 35: + _first_set_mask = 0x3ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x7ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // invalid_kvpair_unpacking ','? if (p->error_indicator) { p->level--; @@ -25504,6 +27979,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kvpair_unpacking ','?")); } + if (_first_set_mask & 0x2ULL) { // ','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking) if (p->error_indicator) { p->level--; @@ -25529,6 +28005,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking)")); } + if (_first_set_mask & 0x4ULL) { // expression ':' &('}' | ',') if (p->error_indicator) { p->level--; @@ -25584,6 +28061,49 @@ invalid_kvpair_unpacking_rule(Parser *p) int _mark = p->mark; expr_ty _prefix_14_result = NULL; int _prefix_14_end = 0, _prefix_14_valid = 0; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + _first_set_mask = 0x2ULL; + break; + case 35: + _first_set_mask = 0x5ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x18ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // '**' if_expression if (p->error_indicator) { p->level--; @@ -25611,6 +28131,7 @@ invalid_kvpair_unpacking_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' if_expression")); } + if (_first_set_mask & 0x2ULL) { // '*' bitwise_or ':' expression if (p->error_indicator) { p->level--; @@ -25644,6 +28165,7 @@ invalid_kvpair_unpacking_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or ':' expression")); } + if (_first_set_mask & 0x4ULL) { // '**' bitwise_or ':' expression if (p->error_indicator) { p->level--; @@ -25677,6 +28199,7 @@ invalid_kvpair_unpacking_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or ':' expression")); } + if (_first_set_mask & 0x8ULL) { // expression ':' '*' bitwise_or if (p->error_indicator) { p->level--; @@ -25710,6 +28233,7 @@ invalid_kvpair_unpacking_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or")); } + if (_first_set_mask & 0x10ULL) { // expression ':' '**' bitwise_or if (p->error_indicator) { p->level--; @@ -26983,6 +29507,24 @@ invalid_string_tstring_concat_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 3: + case 59: + goto _first_set_alt_0; + case 62: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ((fstring | string))+ tstring if (p->error_indicator) { p->level--; @@ -27010,6 +29552,10 @@ invalid_string_tstring_concat_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_string_tstring_concat[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((fstring | string))+ tstring")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // tstring+ (fstring | string) if (p->error_indicator) { p->level--; @@ -27037,6 +29583,11 @@ invalid_string_tstring_concat_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_string_tstring_concat[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring+ (fstring | string)")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -27419,6 +29970,8 @@ _loop1_2_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement")); asdl_stmt_seq* statement_var; while ( + _PyPegen_next_token_in(p, 0x481200008201c28eULL, 0x69c0fffffULL) // first set + && (statement_var = statement_rule(p)) // statement ) { @@ -27579,6 +30132,25 @@ _tmp_5_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 500: + goto _first_set_alt_0; + case 501: + goto _first_set_alt_1; + case 1: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'import' if (p->error_indicator) { p->level--; @@ -27598,6 +30170,10 @@ _tmp_5_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_5[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // 'from' if (p->error_indicator) { p->level--; @@ -27617,6 +30193,10 @@ _tmp_5_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_5[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // "lazy" if (p->error_indicator) { p->level--; @@ -27636,6 +30216,11 @@ _tmp_5_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_5[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"lazy\"")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -27655,6 +30240,25 @@ _tmp_6_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 512: + goto _first_set_alt_0; + case 49: + goto _first_set_alt_1; + case 513: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'def' if (p->error_indicator) { p->level--; @@ -27674,6 +30278,10 @@ _tmp_6_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '@' if (p->error_indicator) { p->level--; @@ -27693,6 +30301,10 @@ _tmp_6_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // 'async' if (p->error_indicator) { p->level--; @@ -27712,6 +30324,11 @@ _tmp_6_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -27731,6 +30348,23 @@ _tmp_7_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 515: + goto _first_set_alt_0; + case 49: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'class' if (p->error_indicator) { p->level--; @@ -27750,6 +30384,10 @@ _tmp_7_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '@' if (p->error_indicator) { p->level--; @@ -27769,6 +30407,11 @@ _tmp_7_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -27788,6 +30431,23 @@ _tmp_8_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 516: + goto _first_set_alt_0; + case 513: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'with' if (p->error_indicator) { p->level--; @@ -27807,6 +30467,10 @@ _tmp_8_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // 'async' if (p->error_indicator) { p->level--; @@ -27826,6 +30490,11 @@ _tmp_8_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -27845,6 +30514,23 @@ _tmp_9_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 517: + goto _first_set_alt_0; + case 513: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'for' if (p->error_indicator) { p->level--; @@ -27864,6 +30550,10 @@ _tmp_9_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // 'async' if (p->error_indicator) { p->level--; @@ -27883,6 +30573,11 @@ _tmp_9_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -27948,6 +30643,36 @@ _tmp_11_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + case 2: + case 3: + case 9: + case 25: + case 52: + case 59: + case 62: + case 526: + case 527: + case 528: + _first_set_mask = 0x2ULL; + break; + case 7: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // '(' single_target ')' if (p->error_indicator) { p->level--; @@ -27978,6 +30703,7 @@ _tmp_11_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_11[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'")); } + if (_first_set_mask & 0x2ULL) { // attribute_or_subscript_target if (p->error_indicator) { p->level--; @@ -28027,6 +30753,8 @@ _loop1_12_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); void *_tmp_157_var; while ( + _PyPegen_next_token_in(p, 0x481000000201028eULL, 0x1c000000ULL) // first set + && (_tmp_157_var = _tmp_157_rule(p)) // star_targets '=' ) { @@ -28187,6 +30915,23 @@ _tmp_15_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 13: + goto _first_set_alt_0; + case 4: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ';' if (p->error_indicator) { p->level--; @@ -28206,6 +30951,10 @@ _tmp_15_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // NEWLINE if (p->error_indicator) { p->level--; @@ -28225,6 +30974,11 @@ _tmp_15_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -28301,6 +31055,8 @@ _loop0_17_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); void *_tmp_158_var; while ( + _PyPegen_next_token_in(p, 0x10000000800000ULL, 0x0ULL) // first set + && (_tmp_158_var = _tmp_158_rule(p)) // '.' | '...' ) { @@ -28359,6 +31115,8 @@ _loop1_18_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); void *_tmp_158_var; while ( + _PyPegen_next_token_in(p, 0x10000000800000ULL, 0x0ULL) // first set + && (_tmp_158_var = _tmp_158_rule(p)) // '.' | '...' ) { @@ -28684,6 +31442,8 @@ _loop1_24_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); void *_tmp_159_var; while ( + _PyPegen_next_token_in(p, 0x2000000000000ULL, 0x0ULL) // first set + && (_tmp_159_var = _tmp_159_rule(p)) // '@' named_expression NEWLINE ) { @@ -28842,6 +31602,8 @@ _loop0_27_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); arg_ty param_no_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { @@ -28900,6 +31662,8 @@ _loop0_28_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); NameDefaultPair* param_with_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (param_with_default_var = param_with_default_rule(p)) // param_with_default ) { @@ -28958,6 +31722,8 @@ _loop1_29_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); arg_ty param_no_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { @@ -29021,6 +31787,8 @@ _loop1_30_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); NameDefaultPair* param_with_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (param_with_default_var = param_with_default_rule(p)) // param_with_default ) { @@ -29084,6 +31852,8 @@ _loop0_31_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default ) { @@ -29142,6 +31912,8 @@ _loop1_32_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); NameDefaultPair* param_maybe_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (param_maybe_default_var = param_maybe_default_rule(p)) // param_maybe_default ) { @@ -29302,6 +32074,25 @@ _tmp_35_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 12: + goto _first_set_alt_0; + case 8: + goto _first_set_alt_1; + case 11: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ',' if (p->error_indicator) { p->level--; @@ -29321,6 +32112,10 @@ _tmp_35_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ')' if (p->error_indicator) { p->level--; @@ -29340,6 +32135,10 @@ _tmp_35_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // ':' if (p->error_indicator) { p->level--; @@ -29359,6 +32158,11 @@ _tmp_35_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -29389,6 +32193,8 @@ _loop1_36_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block")); excepthandler_ty except_block_var; while ( + _PyPegen_next_token_in(p, 0x0ULL, 0x1000000ULL) // first set + && (except_block_var = except_block_rule(p)) // except_block ) { @@ -29452,6 +32258,8 @@ _loop1_37_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block")); excepthandler_ty except_star_block_var; while ( + _PyPegen_next_token_in(p, 0x0ULL, 0x1000000ULL) // first set + && (except_star_block_var = except_star_block_rule(p)) // except_star_block ) { @@ -29515,6 +32323,8 @@ _loop1_38_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "case_block")); match_case_ty case_block_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (case_block_var = case_block_rule(p)) // case_block ) { @@ -29675,6 +32485,23 @@ _tmp_41_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 14: + goto _first_set_alt_0; + case 15: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '+' if (p->error_indicator) { p->level--; @@ -29694,6 +32521,10 @@ _tmp_41_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_41[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '-' if (p->error_indicator) { p->level--; @@ -29713,6 +32544,11 @@ _tmp_41_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_41[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -29732,6 +32568,25 @@ _tmp_42_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 3: + goto _first_set_alt_0; + case 59: + goto _first_set_alt_1; + case 62: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // STRING if (p->error_indicator) { p->level--; @@ -29751,6 +32606,10 @@ _tmp_42_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_42[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // FSTRING_START if (p->error_indicator) { p->level--; @@ -29770,6 +32629,10 @@ _tmp_42_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_42[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_START")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // TSTRING_START if (p->error_indicator) { p->level--; @@ -29789,6 +32652,11 @@ _tmp_42_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_42[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -29808,6 +32676,25 @@ _tmp_43_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 23: + goto _first_set_alt_0; + case 7: + goto _first_set_alt_1; + case 22: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '.' if (p->error_indicator) { p->level--; @@ -29827,6 +32714,10 @@ _tmp_43_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '(' if (p->error_indicator) { p->level--; @@ -29846,6 +32737,10 @@ _tmp_43_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '=' if (p->error_indicator) { p->level--; @@ -29865,6 +32760,11 @@ _tmp_43_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -30100,6 +33000,31 @@ _tmp_48_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + case 3: + case 14: + case 15: + case 59: + case 62: + case 526: + case 527: + case 528: + goto _first_set_alt_0; + case 1: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // literal_expr if (p->error_indicator) { p->level--; @@ -30119,6 +33044,10 @@ _tmp_48_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_48[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_expr")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // attr if (p->error_indicator) { p->level--; @@ -30138,6 +33067,11 @@ _tmp_48_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_48[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -30492,6 +33426,8 @@ _loop1_55_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)")); void *_tmp_16_var; while ( + _PyPegen_next_token_in(p, 0x1000ULL, 0x0ULL) // first set + && (_tmp_16_var = _tmp_16_rule(p)) // ',' expression ) { @@ -30555,6 +33491,8 @@ _loop1_56_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); void *_tmp_160_var; while ( + _PyPegen_next_token_in(p, 0x1000ULL, 0x0ULL) // first set + && (_tmp_160_var = _tmp_160_rule(p)) // ',' star_expression ) { @@ -30726,6 +33664,8 @@ _loop1_59_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); void *_tmp_161_var; while ( + _PyPegen_next_token_in(p, 0x0ULL, 0x20000000ULL) // first set + && (_tmp_161_var = _tmp_161_rule(p)) // 'or' conjunction ) { @@ -30789,6 +33729,8 @@ _loop1_60_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); void *_tmp_162_var; while ( + _PyPegen_next_token_in(p, 0x0ULL, 0x40000000ULL) // first set + && (_tmp_162_var = _tmp_162_rule(p)) // 'and' inversion ) { @@ -30852,6 +33794,8 @@ _loop1_61_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair")); CmpopExprPair* compare_op_bitwise_or_pair_var; while ( + _PyPegen_next_token_in(p, 0x78300000ULL, 0x180800000ULL) // first set + && (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p)) // compare_op_bitwise_or_pair ) { @@ -31101,6 +34045,27 @@ _tmp_66_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 9: + case 25: + _first_set_mask = 0x1ULL; + break; + case 7: + _first_set_mask = 0x7ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // genexp if (p->error_indicator) { p->level--; @@ -31120,6 +34085,7 @@ _tmp_66_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); } + if (_first_set_mask & 0x2ULL) { // tuple if (p->error_indicator) { p->level--; @@ -31139,6 +34105,7 @@ _tmp_66_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); } + if (_first_set_mask & 0x4ULL) { // group if (p->error_indicator) { p->level--; @@ -31177,6 +34144,27 @@ _tmp_67_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 7: + case 25: + _first_set_mask = 0x1ULL; + break; + case 9: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // listcomp if (p->error_indicator) { p->level--; @@ -31196,6 +34184,7 @@ _tmp_67_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp")); } + if (_first_set_mask & 0x2ULL) { // list if (p->error_indicator) { p->level--; @@ -31234,6 +34223,27 @@ _tmp_68_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 7: + case 9: + _first_set_mask = 0x2ULL; + break; + case 25: + _first_set_mask = 0xfULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // dictcomp if (p->error_indicator) { p->level--; @@ -31253,6 +34263,7 @@ _tmp_68_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp")); } + if (_first_set_mask & 0x2ULL) { // setcomp if (p->error_indicator) { p->level--; @@ -31272,6 +34283,7 @@ _tmp_68_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp")); } + if (_first_set_mask & 0x4ULL) { // dict if (p->error_indicator) { p->level--; @@ -31291,6 +34303,7 @@ _tmp_68_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict")); } + if (_first_set_mask & 0x8ULL) { // set if (p->error_indicator) { p->level--; @@ -31329,6 +34342,43 @@ _tmp_69_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 506: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // yield_expr if (p->error_indicator) { p->level--; @@ -31348,6 +34398,10 @@ _tmp_69_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // named_expression if (p->error_indicator) { p->level--; @@ -31367,6 +34421,11 @@ _tmp_69_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -31397,6 +34456,8 @@ _loop0_70_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default ) { @@ -31455,6 +34516,8 @@ _loop0_71_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default ) { @@ -31513,6 +34576,8 @@ _loop1_72_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default ) { @@ -31576,6 +34641,8 @@ _loop1_73_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default ) { @@ -31639,6 +34706,8 @@ _loop0_74_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default ) { @@ -31697,6 +34766,8 @@ _loop1_75_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( + _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL) // first set + && (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default ) { @@ -31760,6 +34831,8 @@ _loop0_76_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec")); expr_ty fstring_format_spec_var; while ( + _PyPegen_next_token_in(p, 0x1000000002000000ULL, 0x0ULL) // first set + && (fstring_format_spec_var = fstring_format_spec_rule(p)) // fstring_format_spec ) { @@ -31818,6 +34891,8 @@ _loop0_77_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_middle")); expr_ty fstring_middle_var; while ( + _PyPegen_next_token_in(p, 0x1000000002000000ULL, 0x0ULL) // first set + && (fstring_middle_var = fstring_middle_rule(p)) // fstring_middle ) { @@ -31876,6 +34951,8 @@ _loop0_78_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_format_spec")); expr_ty tstring_format_spec_var; while ( + _PyPegen_next_token_in(p, 0x8000000002000000ULL, 0x0ULL) // first set + && (tstring_format_spec_var = tstring_format_spec_rule(p)) // tstring_format_spec ) { @@ -31934,6 +35011,8 @@ _loop0_79_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_middle")); expr_ty tstring_middle_var; while ( + _PyPegen_next_token_in(p, 0x8000000002000000ULL, 0x0ULL) // first set + && (tstring_middle_var = tstring_middle_rule(p)) // tstring_middle ) { @@ -31992,6 +35071,8 @@ _loop1_80_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); void *_tmp_154_var; while ( + _PyPegen_next_token_in(p, 0x800000000000008ULL, 0x0ULL) // first set + && (_tmp_154_var = _tmp_154_rule(p)) // fstring | string ) { @@ -32055,6 +35136,8 @@ _loop1_81_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring")); expr_ty tstring_var; while ( + _PyPegen_next_token_in(p, 0x4000000000000000ULL, 0x0ULL) // first set + && (tstring_var = tstring_rule(p)) // tstring ) { @@ -32383,6 +35466,8 @@ _loop1_87_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); comprehension_ty for_if_clause_var; while ( + _PyPegen_next_token_in(p, 0x0ULL, 0x22000ULL) // first set + && (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause ) { @@ -32446,6 +35531,8 @@ _loop0_88_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); void *_tmp_164_var; while ( + _PyPegen_next_token_in(p, 0x0ULL, 0x4000ULL) // first set + && (_tmp_164_var = _tmp_164_rule(p)) // 'if' disjunction ) { @@ -32493,6 +35580,48 @@ _tmp_89_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x2ULL; + break; + case 1: + _first_set_mask = 0x3ULL; + break; + case 16: + _first_set_mask = 0x4ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // assignment_expression if (p->error_indicator) { p->level--; @@ -32512,6 +35641,7 @@ _tmp_89_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } + if (_first_set_mask & 0x2ULL) { // expression !':=' if (p->error_indicator) { p->level--; @@ -32533,6 +35663,7 @@ _tmp_89_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); } + if (_first_set_mask & 0x4ULL) { // starred_expression if (p->error_indicator) { p->level--; @@ -32999,6 +36130,8 @@ _loop0_98_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); void *_tmp_166_var; while ( + _PyPegen_next_token_in(p, 0x1000ULL, 0x0ULL) // first set + && (_tmp_166_var = _tmp_166_rule(p)) // ',' star_target ) { @@ -33086,6 +36219,25 @@ _tmp_100_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 7: + goto _first_set_alt_0; + case 9: + goto _first_set_alt_1; + case 23: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '(' if (p->error_indicator) { p->level--; @@ -33105,6 +36257,10 @@ _tmp_100_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '[' if (p->error_indicator) { p->level--; @@ -33124,6 +36280,10 @@ _tmp_100_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '.' if (p->error_indicator) { p->level--; @@ -33143,6 +36303,11 @@ _tmp_100_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -33421,6 +36586,47 @@ _tmp_106_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 35: + _first_set_mask = 0x2ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 16: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) if (p->error_indicator) { p->level--; @@ -33440,6 +36646,7 @@ _tmp_106_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_106[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); } + if (_first_set_mask & 0x2ULL) { // kwargs if (p->error_indicator) { p->level--; @@ -33586,6 +36793,47 @@ _tmp_109_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + case 35: + _first_set_mask = 0x1ULL; + break; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // args if (p->error_indicator) { p->level--; @@ -33605,6 +36853,7 @@ _tmp_109_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args")); } + if (_first_set_mask & 0x2ULL) { // expression for_if_clauses if (p->error_indicator) { p->level--; @@ -33687,6 +36936,23 @@ _tmp_111_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 12: + goto _first_set_alt_0; + case 8: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ',' if (p->error_indicator) { p->level--; @@ -33706,6 +36972,10 @@ _tmp_111_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ')' if (p->error_indicator) { p->level--; @@ -33725,6 +36995,11 @@ _tmp_111_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -33796,6 +37071,8 @@ _loop1_113_rule(Parser *p) D(fprintf(stderr, "%*c> _loop1_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(!STRING expression_without_invalid)")); void *_tmp_169_var; while ( + _PyPegen_next_token_in(p, 0x481000008200c28eULL, 0x69c000000ULL) // first set + && (_tmp_169_var = _tmp_169_rule(p)) // !STRING expression_without_invalid ) { @@ -33908,6 +37185,23 @@ _tmp_115_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 522: + goto _first_set_alt_0; + case 11: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'else' if (p->error_indicator) { p->level--; @@ -33927,6 +37221,10 @@ _tmp_115_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ':' if (p->error_indicator) { p->level--; @@ -33946,6 +37244,11 @@ _tmp_115_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -33965,6 +37268,25 @@ _tmp_116_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 504: + goto _first_set_alt_0; + case 508: + goto _first_set_alt_1; + case 509: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // pass_stmt if (p->error_indicator) { p->level--; @@ -33984,6 +37306,10 @@ _tmp_116_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pass_stmt")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // break_stmt if (p->error_indicator) { p->level--; @@ -34003,6 +37329,10 @@ _tmp_116_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "break_stmt")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // continue_stmt if (p->error_indicator) { p->level--; @@ -34022,6 +37352,11 @@ _tmp_116_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "continue_stmt")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34041,6 +37376,23 @@ _tmp_117_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 22: + goto _first_set_alt_0; + case 53: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '=' if (p->error_indicator) { p->level--; @@ -34060,6 +37412,10 @@ _tmp_117_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ':=' if (p->error_indicator) { p->level--; @@ -34079,6 +37435,11 @@ _tmp_117_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34098,6 +37459,38 @@ _tmp_118_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 25: + _first_set_mask = 0x4ULL; + break; + case 9: + _first_set_mask = 0x5ULL; + break; + case 7: + _first_set_mask = 0x6ULL; + break; + case 527: + _first_set_mask = 0x8ULL; + break; + case 526: + _first_set_mask = 0x10ULL; + break; + case 528: + _first_set_mask = 0x20ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // list if (p->error_indicator) { p->level--; @@ -34117,6 +37510,7 @@ _tmp_118_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); } + if (_first_set_mask & 0x2ULL) { // tuple if (p->error_indicator) { p->level--; @@ -34136,6 +37530,7 @@ _tmp_118_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); } + if (_first_set_mask & 0x4ULL) { // genexp if (p->error_indicator) { p->level--; @@ -34155,6 +37550,7 @@ _tmp_118_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); } + if (_first_set_mask & 0x8ULL) { // 'True' if (p->error_indicator) { p->level--; @@ -34174,6 +37570,7 @@ _tmp_118_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } + if (_first_set_mask & 0x10ULL) { // 'None' if (p->error_indicator) { p->level--; @@ -34193,6 +37590,7 @@ _tmp_118_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } + if (_first_set_mask & 0x20ULL) { // 'False' if (p->error_indicator) { p->level--; @@ -34242,6 +37640,8 @@ _loop0_119_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); asdl_expr_seq* star_named_expressions_var; while ( + _PyPegen_next_token_in(p, 0x481000008201c28eULL, 0x69c000310ULL) // first set + && (star_named_expressions_var = star_named_expressions_rule(p)) // star_named_expressions ) { @@ -34300,6 +37700,8 @@ _loop0_120_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); void *_tmp_157_var; while ( + _PyPegen_next_token_in(p, 0x481000000201028eULL, 0x1c000000ULL) // first set + && (_tmp_157_var = _tmp_157_rule(p)) // star_targets '=' ) { @@ -34347,6 +37749,23 @@ _tmp_121_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 9: + goto _first_set_alt_0; + case 25: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '[' if (p->error_indicator) { p->level--; @@ -34366,6 +37785,10 @@ _tmp_121_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '{' if (p->error_indicator) { p->level--; @@ -34385,6 +37808,11 @@ _tmp_121_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34461,6 +37889,23 @@ _tmp_123_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 12: + goto _first_set_alt_0; + case 1: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ',' if (p->error_indicator) { p->level--; @@ -34480,6 +37925,10 @@ _tmp_123_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // param_no_default if (p->error_indicator) { p->level--; @@ -34499,6 +37948,11 @@ _tmp_123_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34518,6 +37972,23 @@ _tmp_124_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 8: + goto _first_set_alt_0; + case 12: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ')' if (p->error_indicator) { p->level--; @@ -34537,6 +38008,10 @@ _tmp_124_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ',' if (p->error_indicator) { p->level--; @@ -34556,6 +38031,11 @@ _tmp_124_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34575,6 +38055,23 @@ _tmp_125_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 8: + goto _first_set_alt_0; + case 12: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ')' if (p->error_indicator) { p->level--; @@ -34594,6 +38091,10 @@ _tmp_125_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ',' (')' | '**') if (p->error_indicator) { p->level--; @@ -34616,6 +38117,11 @@ _tmp_125_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34635,6 +38141,23 @@ _tmp_126_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + goto _first_set_alt_0; + case 12: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // param_no_default if (p->error_indicator) { p->level--; @@ -34654,6 +38177,10 @@ _tmp_126_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ',' if (p->error_indicator) { p->level--; @@ -34673,6 +38200,11 @@ _tmp_126_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34692,6 +38224,25 @@ _tmp_127_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + goto _first_set_alt_0; + case 35: + goto _first_set_alt_1; + case 17: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '*' if (p->error_indicator) { p->level--; @@ -34711,6 +38262,10 @@ _tmp_127_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '**' if (p->error_indicator) { p->level--; @@ -34730,6 +38285,10 @@ _tmp_127_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '/' if (p->error_indicator) { p->level--; @@ -34749,6 +38308,11 @@ _tmp_127_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34933,6 +38497,23 @@ _tmp_131_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 12: + goto _first_set_alt_0; + case 1: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ',' if (p->error_indicator) { p->level--; @@ -34952,6 +38533,10 @@ _tmp_131_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // lambda_param_no_default if (p->error_indicator) { p->level--; @@ -34971,6 +38556,11 @@ _tmp_131_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -34990,6 +38580,23 @@ _tmp_132_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 11: + goto _first_set_alt_0; + case 12: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ':' if (p->error_indicator) { p->level--; @@ -35009,6 +38616,10 @@ _tmp_132_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ',' (':' | '**') if (p->error_indicator) { p->level--; @@ -35031,6 +38642,11 @@ _tmp_132_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -35050,6 +38666,23 @@ _tmp_133_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + goto _first_set_alt_0; + case 12: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // lambda_param_no_default if (p->error_indicator) { p->level--; @@ -35069,6 +38702,10 @@ _tmp_133_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_133[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ',' if (p->error_indicator) { p->level--; @@ -35088,6 +38725,11 @@ _tmp_133_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_133[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -35517,6 +39159,23 @@ _tmp_142_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 524: + goto _first_set_alt_0; + case 525: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // 'except' if (p->error_indicator) { p->level--; @@ -35536,6 +39195,10 @@ _tmp_142_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // 'finally' if (p->error_indicator) { p->level--; @@ -35555,6 +39218,11 @@ _tmp_142_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -35585,6 +39253,8 @@ _loop0_143_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); asdl_stmt_seq* block_var; while ( + _PyPegen_next_token_in(p, 0x481000008201c29eULL, 0x69c000fffULL) // first set + && (block_var = block_rule(p)) // block ) { @@ -35674,6 +39344,23 @@ _tmp_145_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 4: + goto _first_set_alt_0; + case 11: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // NEWLINE if (p->error_indicator) { p->level--; @@ -35693,6 +39380,10 @@ _tmp_145_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ':' if (p->error_indicator) { p->level--; @@ -35712,6 +39403,11 @@ _tmp_145_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -35870,6 +39566,23 @@ _tmp_149_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 26: + goto _first_set_alt_0; + case 12: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '}' if (p->error_indicator) { p->level--; @@ -35889,6 +39602,10 @@ _tmp_149_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ',' if (p->error_indicator) { p->level--; @@ -35908,6 +39625,11 @@ _tmp_149_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -35927,6 +39649,27 @@ _tmp_150_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 22: + goto _first_set_alt_0; + case 54: + goto _first_set_alt_1; + case 11: + goto _first_set_alt_2; + case 26: + goto _first_set_alt_3; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '=' if (p->error_indicator) { p->level--; @@ -35946,6 +39689,10 @@ _tmp_150_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '!' if (p->error_indicator) { p->level--; @@ -35965,6 +39712,10 @@ _tmp_150_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // ':' if (p->error_indicator) { p->level--; @@ -35984,6 +39735,10 @@ _tmp_150_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_3: { // '}' if (p->error_indicator) { p->level--; @@ -36003,6 +39758,11 @@ _tmp_150_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -36022,6 +39782,25 @@ _tmp_151_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 54: + goto _first_set_alt_0; + case 11: + goto _first_set_alt_1; + case 26: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '!' if (p->error_indicator) { p->level--; @@ -36041,6 +39820,10 @@ _tmp_151_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ':' if (p->error_indicator) { p->level--; @@ -36060,6 +39843,10 @@ _tmp_151_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '}' if (p->error_indicator) { p->level--; @@ -36079,6 +39866,11 @@ _tmp_151_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -36139,6 +39931,23 @@ _tmp_153_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 11: + goto _first_set_alt_0; + case 26: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ':' if (p->error_indicator) { p->level--; @@ -36158,6 +39967,10 @@ _tmp_153_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '}' if (p->error_indicator) { p->level--; @@ -36177,6 +39990,11 @@ _tmp_153_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -36196,6 +40014,23 @@ _tmp_154_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 59: + goto _first_set_alt_0; + case 3: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // fstring if (p->error_indicator) { p->level--; @@ -36215,6 +40050,10 @@ _tmp_154_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // string if (p->error_indicator) { p->level--; @@ -36234,6 +40073,11 @@ _tmp_154_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "string")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -36253,6 +40097,33 @@ _tmp_155_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 14: + goto _first_set_alt_0; + case 15: + goto _first_set_alt_1; + case 16: + goto _first_set_alt_2; + case 17: + goto _first_set_alt_3; + case 24: + goto _first_set_alt_4; + case 47: + goto _first_set_alt_5; + case 49: + goto _first_set_alt_6; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '+' if (p->error_indicator) { p->level--; @@ -36272,6 +40143,10 @@ _tmp_155_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '-' if (p->error_indicator) { p->level--; @@ -36291,6 +40166,10 @@ _tmp_155_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '*' if (p->error_indicator) { p->level--; @@ -36310,6 +40189,10 @@ _tmp_155_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_3: { // '/' if (p->error_indicator) { p->level--; @@ -36329,6 +40212,10 @@ _tmp_155_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_4: { // '%' if (p->error_indicator) { p->level--; @@ -36348,6 +40235,10 @@ _tmp_155_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_5: { // '//' if (p->error_indicator) { p->level--; @@ -36367,6 +40258,10 @@ _tmp_155_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_6: { // '@' if (p->error_indicator) { p->level--; @@ -36386,6 +40281,11 @@ _tmp_155_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -36405,6 +40305,25 @@ _tmp_156_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 14: + goto _first_set_alt_0; + case 15: + goto _first_set_alt_1; + case 31: + goto _first_set_alt_2; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '+' if (p->error_indicator) { p->level--; @@ -36424,6 +40343,10 @@ _tmp_156_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '-' if (p->error_indicator) { p->level--; @@ -36443,6 +40366,10 @@ _tmp_156_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // '~' if (p->error_indicator) { p->level--; @@ -36462,6 +40389,11 @@ _tmp_156_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -36527,6 +40459,23 @@ _tmp_158_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 23: + goto _first_set_alt_0; + case 52: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // '.' if (p->error_indicator) { p->level--; @@ -36546,6 +40495,10 @@ _tmp_158_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '...' if (p->error_indicator) { p->level--; @@ -36565,6 +40518,11 @@ _tmp_158_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -36771,6 +40729,44 @@ _tmp_163_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 1: + case 2: + case 3: + case 7: + case 9: + case 11: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + goto _first_set_alt_0; + case 16: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // slice if (p->error_indicator) { p->level--; @@ -36790,6 +40786,10 @@ _tmp_163_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_163[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // starred_expression if (p->error_indicator) { p->level--; @@ -36809,6 +40809,11 @@ _tmp_163_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_163[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -36874,6 +40879,43 @@ _tmp_165_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 16: + goto _first_set_alt_0; + case 1: + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // starred_expression if (p->error_indicator) { p->level--; @@ -36893,6 +40935,10 @@ _tmp_165_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // (assignment_expression | expression !':=') !'=' if (p->error_indicator) { p->level--; @@ -36914,6 +40960,11 @@ _tmp_165_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -37104,6 +41155,23 @@ _tmp_170_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 8: + goto _first_set_alt_0; + case 35: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ')' if (p->error_indicator) { p->level--; @@ -37123,6 +41191,10 @@ _tmp_170_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '**' if (p->error_indicator) { p->level--; @@ -37142,6 +41214,11 @@ _tmp_170_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -37161,6 +41238,23 @@ _tmp_171_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 11: + goto _first_set_alt_0; + case 35: + goto _first_set_alt_1; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ':' if (p->error_indicator) { p->level--; @@ -37180,6 +41274,10 @@ _tmp_171_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // '**' if (p->error_indicator) { p->level--; @@ -37199,6 +41297,11 @@ _tmp_171_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -37229,6 +41332,8 @@ _loop0_172_rule(Parser *p) D(fprintf(stderr, "%*c> _loop0_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); void *_tmp_177_var; while ( + _PyPegen_next_token_in(p, 0x1000ULL, 0x0ULL) // first set + && (_tmp_177_var = _tmp_177_rule(p)) // ',' bitwise_or ) { @@ -37276,6 +41381,27 @@ _tmp_173_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 12: + goto _first_set_alt_0; + case 8: + goto _first_set_alt_1; + case 13: + goto _first_set_alt_2; + case 4: + goto _first_set_alt_3; + default: + goto _first_set_done; + } + } + _first_set_alt_0: { // ',' if (p->error_indicator) { p->level--; @@ -37295,6 +41421,10 @@ _tmp_173_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_1: { // ')' if (p->error_indicator) { p->level--; @@ -37314,6 +41444,10 @@ _tmp_173_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_2: { // ';' if (p->error_indicator) { p->level--; @@ -37333,6 +41467,10 @@ _tmp_173_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_alt_3: { // NEWLINE if (p->error_indicator) { p->level--; @@ -37352,6 +41490,11 @@ _tmp_173_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } + if (!p->call_invalid_rules) { + goto _first_set_done; + } + _first_set_done: + ; _res = NULL; done: p->level--; @@ -37455,6 +41598,45 @@ _tmp_176_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + p->level--; + return NULL; + } + int _current_token_type = p->tokens[_mark]->type; + unsigned long long _first_set_mask = ~0ULL; + if (!p->call_invalid_rules) { + switch (_current_token_type) { + case 2: + case 3: + case 7: + case 9: + case 14: + case 15: + case 25: + case 31: + case 52: + case 59: + case 62: + case 504: + case 508: + case 509: + case 526: + case 527: + case 528: + case 531: + case 533: + case 534: + _first_set_mask = 0x2ULL; + break; + case 1: + _first_set_mask = 0x3ULL; + break; + default: + _first_set_mask = 0x0ULL; + } + } + if (_first_set_mask & 0x1ULL) { // assignment_expression if (p->error_indicator) { p->level--; @@ -37474,6 +41656,7 @@ _tmp_176_rule(Parser *p) D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } + if (_first_set_mask & 0x2ULL) { // expression !':=' if (p->error_indicator) { p->level--; diff --git a/Parser/pegen.h b/Parser/pegen.h index 95ad2c9b7c0a843..62ce39339b21558 100644 --- a/Parser/pegen.h +++ b/Parser/pegen.h @@ -193,6 +193,24 @@ expr_ty _PyPegen_soft_keyword_token(Parser *p); expr_ty _PyPegen_fstring_middle_token(Parser* p); Token *_PyPegen_get_last_nonnwhitespace_token(Parser *); int _PyPegen_fill_token(Parser *p); + +// Return whether the type of the next token is in a first set, given as masks +// of the token types below 64 and of the keyword types (numbered from 500). +static inline int +_PyPegen_next_token_in(Parser *p, uint64_t token_mask, uint64_t keyword_mask) +{ + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + return 0; + } + int type = p->tokens[p->mark]->type; + if (type < 64) { + return (token_mask >> type) & 1; + } + type -= 500; + return 0 <= type && type < 64 && ((keyword_mask >> type) & 1); +} + // Return -1 on failure, leaving the buffer and capacity unchanged. int _PyPegen_grow_loop_buffer(void ***buffer, Py_ssize_t *capacity); expr_ty _PyPegen_name_token(Parser *p); diff --git a/Tools/peg_generator/pegen/c_generator.py b/Tools/peg_generator/pegen/c_generator.py index d1f87811445483d..71988e05a001fe6 100644 --- a/Tools/peg_generator/pegen/c_generator.py +++ b/Tools/peg_generator/pegen/c_generator.py @@ -70,7 +70,7 @@ def __init__( ): super().__init__(grammar, set(tokens.values()), file) self.callmakervisitor: CCallMakerVisitor = CCallMakerVisitor( - self, exact_tokens, non_exact_tokens + self, exact_tokens, non_exact_tokens, tokens ) self._collected = False self.debug = debug diff --git a/Tools/peg_generator/pegen/c_generator_calls.py b/Tools/peg_generator/pegen/c_generator_calls.py index dc3c0cca1304121..400f118aca28e53 100644 --- a/Tools/peg_generator/pegen/c_generator_calls.py +++ b/Tools/peg_generator/pegen/c_generator_calls.py @@ -2,7 +2,7 @@ import ast import re -from collections.abc import Mapping +from collections.abc import Callable, Mapping from dataclasses import replace from types import MappingProxyType from typing import TYPE_CHECKING, Any @@ -44,6 +44,8 @@ RuleKind, StringLeaf, ) +from pegen.grammar_analysis import FirstSetVisitor +from pegen.parser_generator import KEYWORD_TYPE_BASE if TYPE_CHECKING: from pegen.parser_generator import ParserGenerator @@ -110,11 +112,13 @@ def __init__( parser_generator: "ParserGenerator", exact_tokens: dict[str, int], non_exact_tokens: set[str], + tokens: dict[int, str], ): self._registry = parser_generator self._keywords = parser_generator.keywords self._exact_tokens = exact_tokens self._non_exact_tokens = non_exact_tokens + self._token_types = {name: token_type for token_type, name in tokens.items()} self._helper_cache: dict[tuple[type, str], str] = {} self._calls: dict[NamedItem, tuple[Item, FunctionCall]] = {} @@ -340,8 +344,47 @@ def _resolve_artificial_rule(self, node: _HelperNode) -> CRuleSignature: self._helper_cache[key] = name return rule_signature(self._registry.all_rules[name]) + def _token_type(self, terminal: str) -> int | None: + if not terminal.startswith("'"): + return self._token_types.get(terminal) + value = ast.literal_eval(terminal) + if value in self._keywords: + return self._keywords[value] + return self._exact_tokens.get(value) + + def _first_set( + self, first_sets: FirstSetVisitor, alt: Alt + ) -> frozenset[int] | None: + if (first := first_sets.visit(alt)) is None: + return None + token_types = set() + for terminal in first: + if (token_type := self._token_type(terminal)) is None: + return None + token_types.add(token_type) + return frozenset(token_types) + + def _next_token_check(self, token_types: frozenset[int]) -> FunctionCall | None: + token_mask = keyword_mask = 0 + for token_type in token_types: + if token_type < 64: + token_mask |= 1 << token_type + elif 0 <= token_type - KEYWORD_TYPE_BASE < 64: + keyword_mask |= 1 << (token_type - KEYWORD_TYPE_BASE) + else: + return None + return FunctionCall( + function="_PyPegen_next_token_in", + arguments=("p", f"0x{token_mask:x}ULL", f"0x{keyword_mask:x}ULL"), + return_type="int", + comment="first set", + ) + def make_lowerer(self) -> "CCallLowerer": + first_sets = FirstSetVisitor(self._registry.all_rules) return CCallLowerer( + first_set=lambda alt: self._first_set(first_sets, alt), + next_token_check=self._next_token_check, calls=self._calls, rules=self._registry.all_rules, original_rules=self._registry.rules, @@ -360,11 +403,17 @@ class CCallLowerer: def __init__( self, *, + first_set: Callable[[Alt], frozenset[int] | None] = lambda alt: None, + next_token_check: Callable[[frozenset[int]], FunctionCall | None] = ( + lambda token_types: None + ), calls: Mapping[NamedItem, tuple[Item, FunctionCall]], rules: Mapping[str, Rule], original_rules: dict[str, Rule], signatures: Mapping[str, CRuleSignature], ): + self._first_set = first_set + self._next_token_check = next_token_check self._calls = MappingProxyType(dict(calls)) self._signatures = MappingProxyType(dict(signatures)) self._prefixes: dict[str, tuple[CPrefix, ...]] = {} @@ -410,13 +459,19 @@ def prepare_rule(self, rule: Rule, *, skip_actions: bool = False) -> CRule: if (signature := self._signatures.get(rule.name)) is None: raise RuntimeError(f"Rule {rule.name!r} was not discovered") rhs = rule.flatten() - if signature.kind in {RuleKind.LOOP0, RuleKind.LOOP1}: + is_loop = signature.kind in {RuleKind.LOOP0, RuleKind.LOOP1} + if is_loop: assert len(rhs.alts) == 1 return CRule( signature=signature, text=str(rule), alternatives=tuple( - self.prepare_alt(alt, kind=signature.kind, skip_actions=skip_actions) + self.prepare_alt( + alt, + kind=signature.kind, + skip_actions=skip_actions, + first_set_check=self._loop_check(alt) if is_loop else None, + ) for alt in rhs.alts ), left_recursive=rule.left_recursive, @@ -424,16 +479,49 @@ def prepare_rule(self, rule: Rule, *, skip_actions: bool = False) -> CRule: memoize="memo" in rule.flags and not rule.left_recursive, disable_invalid_rules=rule.name.endswith("without_invalid"), prefixes=self._prefixes.get(rule.name, ()), + first_set_dispatch=None if is_loop else self._first_set_dispatch(rhs), ) + def _loop_check(self, alt: Alt) -> FunctionCall | None: + # Matching a token costs no more than checking it. + match alt.items: + case [NamedItem(item=StringLeaf()), *_]: + return None + case [NamedItem(item=NameLeaf(value=name)), *_] if name not in self._signatures: + return None + if (token_types := self._first_set(alt)) is None: + return None + return self._next_token_check(token_types) + + def _first_set_dispatch(self, rhs: Rhs) -> tuple[frozenset[int] | None, ...] | None: + # The dispatch mask has a bit per alternative. + if not 2 <= len(rhs.alts) <= 64: + return None + dispatch: list[frozenset[int] | None] = [] + tried: list[frozenset[int] | None] = [] + for alt in rhs.alts: + if self._requires_invalid_rules(alt): + # Only the second pass tries it, and doesn't dispatch. + dispatch.append(frozenset()) + else: + dispatch.append(token_types := self._first_set(alt)) + tried.append(token_types) + # Worthless if all first sets are unknown, or are the same: the rule + # is then rarely tried on a token that rules out an alternative. + known = [token_types for token_types in tried if token_types is not None] + if not known or (len(known) == len(tried) and len(set(known)) == 1): + return None + return tuple(dispatch) + def prepare_alt( self, node: Alt, *, kind: RuleKind = RuleKind.NORMAL, skip_actions: bool = False, + first_set_check: FunctionCall | None = None, ) -> CAlternative: - calls: list[FunctionCall] = [] + calls = [first_set_check] if first_set_check is not None else [] variables: dict[str, CVariable] = {} cut_variable = None for item in node.items: diff --git a/Tools/peg_generator/pegen/c_generator_model.py b/Tools/peg_generator/pegen/c_generator_model.py index 7b25977d70efb5f..b0b90d17cc22d56 100644 --- a/Tools/peg_generator/pegen/c_generator_model.py +++ b/Tools/peg_generator/pegen/c_generator_model.py @@ -123,6 +123,7 @@ class CRule: memoize: bool disable_invalid_rules: bool prefixes: tuple[CPrefix, ...] = () + first_set_dispatch: tuple[frozenset[int] | None, ...] | None = None @property def uses_locations(self) -> bool: diff --git a/Tools/peg_generator/pegen/c_generator_rules.py b/Tools/peg_generator/pegen/c_generator_rules.py index f6cf2d954e4e7bb..7acd335d072821f 100644 --- a/Tools/peg_generator/pegen/c_generator_rules.py +++ b/Tools/peg_generator/pegen/c_generator_rules.py @@ -187,9 +187,12 @@ def _emit_rule_body(self) -> None: self._print(f"int {prefix.end} = 0, {prefix.valid} = 0;") if self._rule.uses_locations: self._emit_token_start_metadata() - for alt in self._rule.alternatives: - with self._alternative(alt): - self._emit_normal_alt(alt) + if (dispatch := self._rule.first_set_dispatch) is not None: + self._emit_first_set_dispatch(dispatch) + else: + for alt in self._rule.alternatives: + with self._alternative(alt): + self._emit_normal_alt(alt) if self._debug: self._print(f'D(fprintf(stderr, "Fail at %d: {signature.name}\\n", p->mark));') self._print("_res = NULL;") @@ -199,6 +202,86 @@ def _emit_rule_body(self) -> None: self._print(f"_PyPegen_insert_memo(p, _mark, {signature.name}_type, _res);") self._returns.emit("_res") + def _emit_first_set_dispatch(self, dispatch: tuple[frozenset[int] | None, ...]) -> None: + if not self._rule.uses_locations: + self._print("if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {") + with self._indent(): + self._print("p->error_indicator = 1;") + self._returns.emit("NULL") + self._print("}") + self._print("int _current_token_type = p->tokens[_mark]->type;") + # The second pass tries every alternative in order, so that it reports + # the same errors as without dispatch. + known = [token_types for token_types in dispatch if token_types is not None] + if len(known) == len(dispatch) and sum(map(len, known)) == len(frozenset().union(*known)): + # At most one alternative may match the next token. + self._emit_first_set_jumps(known) + else: + self._emit_first_set_mask(dispatch) + + def _emit_first_set_jumps(self, dispatch: list[frozenset[int]]) -> None: + self._print("if (!p->call_invalid_rules) {") + with self._indent(): + self._print("switch (_current_token_type) {") + with self._indent(): + for index, token_types in enumerate(dispatch): + if not token_types: + continue + for token_type in sorted(token_types): + self._print(f"case {token_type}:") + with self._indent(): + self._print(f"goto _first_set_alt_{index};") + self._print("default:") + with self._indent(): + self._print("goto _first_set_done;") + self._print("}") + self._print("}") + for index, (alt, token_types) in enumerate(zip(self._rule.alternatives, dispatch)): + if token_types: + self._print(f"_first_set_alt_{index}:") + with self._alternative(alt): + self._emit_normal_alt(alt) + self._print("if (!p->call_invalid_rules) {") + with self._indent(): + self._print("goto _first_set_done;") + self._print("}") + self._print("_first_set_done:") + self._print(";") + + def _emit_first_set_mask(self, dispatch: tuple[frozenset[int] | None, ...]) -> None: + # Bits of the alternatives that may match the next token. + unknown = sum( + 1 << index for index, token_types in enumerate(dispatch) if token_types is None + ) + masks: dict[int, int] = {} + for index, token_types in enumerate(dispatch): + for token_type in token_types or (): + masks[token_type] = masks.get(token_type, unknown) | (1 << index) + token_types_by_mask: dict[int, list[int]] = {} + for token_type, mask in sorted(masks.items()): + token_types_by_mask.setdefault(mask, []).append(token_type) + + self._print("unsigned long long _first_set_mask = ~0ULL;") + self._print("if (!p->call_invalid_rules) {") + with self._indent(): + self._print("switch (_current_token_type) {") + with self._indent(): + for mask, cases in sorted(token_types_by_mask.items()): + for token_type in cases: + self._print(f"case {token_type}:") + with self._indent(): + self._print(f"_first_set_mask = 0x{mask:x}ULL;") + self._print("break;") + self._print("default:") + with self._indent(): + self._print(f"_first_set_mask = 0x{unknown:x}ULL;") + self._print("}") + self._print("}") + for index, alt in enumerate(self._rule.alternatives): + self._print(f"if (_first_set_mask & 0x{1 << index:x}ULL)") + with self._alternative(alt): + self._emit_normal_alt(alt) + def _emit_loop_body(self) -> None: rule = self._rule signature = rule.signature diff --git a/Tools/peg_generator/pegen/first_sets.py b/Tools/peg_generator/pegen/first_sets.py index 9980f76666518d7..a336aca17c33f9e 100755 --- a/Tools/peg_generator/pegen/first_sets.py +++ b/Tools/peg_generator/pegen/first_sets.py @@ -6,24 +6,7 @@ import sys from pegen.build import build_parser -from pegen.grammar import ( - Alt, - Cut, - Gather, - GrammarVisitor, - Group, - Lookahead, - NamedItem, - NameLeaf, - NegativeLookahead, - Opt, - Repeat0, - Repeat1, - Rhs, - Rule, - StringLeaf, -) -from pegen.parser_generator import compute_nullables +from pegen.grammar_analysis import FirstSetVisitor argparser = argparse.ArgumentParser( prog="calculate_first_sets", @@ -32,106 +15,6 @@ argparser.add_argument("grammar_file", type=pathlib.Path, help="The grammar file") -class FirstSetCalculator(GrammarVisitor): - def __init__(self, rules: dict[str, Rule]) -> None: - self.rules = rules - self.nullables = compute_nullables(rules) - self.first_sets: dict[str, set[str]] = dict() - self.in_process: set[str] = set() - - def calculate(self) -> dict[str, set[str]]: - for name, rule in self.rules.items(): - self.visit(rule) - return self.first_sets - - def visit_Alt(self, item: Alt) -> set[str]: - result: set[str] = set() - to_remove: set[str] = set() - for other in item.items: - new_terminals = self.visit(other) - if isinstance(other.item, NegativeLookahead): - to_remove |= new_terminals - result |= new_terminals - if to_remove: - result -= to_remove - - # If the set of new terminals can start with the empty string, - # it means that the item is completely nullable and we should - # also considering at least the next item in case the current - # one fails to parse. - - if "" in new_terminals: - continue - - if not isinstance(other.item, (Opt, NegativeLookahead, Repeat0)): - break - - # Do not allow the empty string to propagate. - result.discard("") - - return result - - def visit_Cut(self, item: Cut) -> set[str]: - return set() - - def visit_Group(self, item: Group) -> set[str]: - return self.visit(item.rhs) - - def visit_PositiveLookahead(self, item: Lookahead) -> set[str]: - return self.visit(item.node) - - def visit_NegativeLookahead(self, item: NegativeLookahead) -> set[str]: - return self.visit(item.node) - - def visit_NamedItem(self, item: NamedItem) -> set[str]: - return self.visit(item.item) - - def visit_Opt(self, item: Opt) -> set[str]: - return self.visit(item.node) - - def visit_Gather(self, item: Gather) -> set[str]: - return self.visit(item.node) - - def visit_Repeat0(self, item: Repeat0) -> set[str]: - return self.visit(item.node) - - def visit_Repeat1(self, item: Repeat1) -> set[str]: - return self.visit(item.node) - - def visit_NameLeaf(self, item: NameLeaf) -> set[str]: - if item.value not in self.rules: - return {item.value} - - if item.value not in self.first_sets: - self.first_sets[item.value] = self.visit(self.rules[item.value]) - return self.first_sets[item.value] - elif item.value in self.in_process: - return set() - - return self.first_sets[item.value] - - def visit_StringLeaf(self, item: StringLeaf) -> set[str]: - return {item.value} - - def visit_Rhs(self, item: Rhs) -> set[str]: - result: set[str] = set() - for alt in item.alts: - result |= self.visit(alt) - return result - - def visit_Rule(self, item: Rule) -> set[str]: - if item.name in self.in_process: - return set() - elif item.name not in self.first_sets: - self.in_process.add(item.name) - terminals = self.visit(item.rhs) - if item in self.nullables: - terminals.add("") - self.first_sets[item.name] = terminals - self.in_process.remove(item.name) - return self.first_sets[item.name] - - def main() -> None: args = argparser.parse_args() @@ -141,8 +24,8 @@ def main() -> None: print("ERROR: Failed to parse grammar file", err, file=sys.stderr) sys.exit(1) - firs_sets = FirstSetCalculator(grammar.rules).calculate() - pprint.pprint(firs_sets) + first_sets = FirstSetVisitor(grammar.rules).first_sets + pprint.pprint(first_sets) if __name__ == "__main__": diff --git a/Tools/peg_generator/pegen/grammar_analysis.py b/Tools/peg_generator/pegen/grammar_analysis.py index 5b716cf209e000a..91dca331a155f31 100644 --- a/Tools/peg_generator/pegen/grammar_analysis.py +++ b/Tools/peg_generator/pegen/grammar_analysis.py @@ -1,5 +1,6 @@ -"""Nullable and left-recursion analysis for source grammar rules.""" +"""Nullable, first set and left-recursion analysis for source grammar rules.""" +import ast from collections.abc import Iterable, Set from typing import Any @@ -13,11 +14,14 @@ Group, NamedItem, NameLeaf, + NegativeLookahead, Opt, + PositiveLookahead, Repeat0, Repeat1, Rhs, Rule, + RuleKind, StringLeaf, ) @@ -106,6 +110,77 @@ def visit(self, node: Any, *args: Any, **kwargs: Any) -> set[Any]: return self.generic_visit(node, *args, **kwargs) +# A set of terminals (token names, quoted keywords and quoted exact tokens) +# such that an item may only match, or have any effect, if the next token is in +# it. None if the item may match whatever the next token is, or have an effect +# (commit to a cut, raise for a forced token or in an action) before it fails. +FirstSet = frozenset[str] | None + + +class FirstSetVisitor(GrammarVisitor): + + def __init__(self, rules: dict[str, Rule]) -> None: + self.rules = rules + self.first_sets: dict[str, FirstSet] = {name: frozenset() for name in rules} + # Grow the first sets until they cover each other's in recursive rules. + changed = True + while changed: + changed = False + for name, rule in rules.items(): + first = None if rule.kind is RuleKind.LOOP0 else self.visit(rule.rhs) + if first != self.first_sets[name]: + self.first_sets[name] = first + changed = True + + def visit(self, node: Any, *args: Any, **kwargs: Any) -> FirstSet: + match node: + case Rhs(alts=alts): + result: set[str] = set() + for alt in alts: + if (first := self.visit(alt)) is None: + return None + result |= first + return frozenset(result) + case Alt(items=items): + result = set() + for item in items: + match item.item: + case Cut() | Forced(): + return None + case NegativeLookahead() | Opt() | Repeat0() as optional: + # Matches whatever the next token is, but only has + # an effect when it's in its own first set. + if (first := self.visit(optional.node)) is None: + return None + result |= first + case required: + if (first := self.visit(required)) is None: + return None + return frozenset(result | first) + return None + case NamedItem(item=item): + return self.visit(item) + case Group(rhs=rhs): + return self.visit(rhs) + case Repeat1(node=child) | Gather(node=child) | PositiveLookahead(node=child): + return self.visit(child) + case Opt() | Repeat0() | NegativeLookahead() | Cut() | Forced(): + return None + case NameLeaf(value=name): + if name in self.rules: + return self.first_sets[name] + # Soft keywords are NAME tokens. + return frozenset({"NAME" if name == "SOFT_KEYWORD" else name}) + case StringLeaf(value=value): + if not ast.literal_eval(value): + return None + if value.startswith('"') and value[1:-1].isidentifier(): + return frozenset({"NAME"}) + return frozenset({value}) + case _: + raise TypeError(f"Unexpected grammar node {node!r}") + + def compute_left_recursives( rules: dict[str, Rule] ) -> tuple[dict[str, Set[str]], list[Set[str]]]: diff --git a/Tools/peg_generator/pegen/parser_generator.py b/Tools/peg_generator/pegen/parser_generator.py index 65486aa972a068a..1d8e67eb9090356 100644 --- a/Tools/peg_generator/pegen/parser_generator.py +++ b/Tools/peg_generator/pegen/parser_generator.py @@ -37,6 +37,8 @@ make_first_graph as make_first_graph, ) +KEYWORD_TYPE_BASE = 500 + class RuleCollectorVisitor(GrammarVisitor): """Visitor that invokes a provided callmaker visitor with just the NamedItem nodes""" @@ -108,7 +110,7 @@ def __init__(self, grammar: Grammar, tokens: set[str], file: IO[str] | None): self.level = 0 self.first_graph, self.first_sccs = compute_left_recursives(self.rules) self.counter = 0 # For name_rule()/name_loop() - self.keyword_counter = 499 # For keyword_type() + self.keyword_counter = KEYWORD_TYPE_BASE - 1 # For keyword_type() self.all_rules: dict[str, Rule] = self.rules.copy() # Rules + temporal rules self._local_variable_stack: list[list[str]] = []