Mailman 3 January 2026 - Python-checkins

gh-143055: Implementation of PEP 798 (#143056)
by JelleZijlstra Jan. 31, 2026

Jan. 31, 2026

https://github.com/python/cpython/commit/ccbe41e27cdb441033189f06148c235282… commit: ccbe41e27cdb441033189f06148c23528275214b branch: main author: adam j hartz <hz(a)mit.edu> committer: JelleZijlstra <jelle.zijlstra(a)gmail.com> date: 2026-01-30T20:37:52-08:00 summary: gh-143055: Implementation of PEP 798 (#143056) Co-authored-by: Jelle Zijlstra <jelle.zijlstra(a)gmail.com> files: A Misc/NEWS.d/next/Core_and_Builtins/2025-12-21-18-12-30.gh-issue-143055.PzwccL.rst M Doc/reference/expressions.rst M Doc/tutorial/classes.rst M Doc/tutorial/datastructures.rst M Doc/whatsnew/3.15.rst M Grammar/python.gram M Lib/test/test_exceptions.py M Lib/test/test_unpack_ex.py M Parser/Python.asdl M Parser/parser.c M Python/Python-ast.c M Python/ast.c M Python/ast_preprocess.c M Python/codegen.c diff --git a/Doc/reference/expressions.rst b/Doc/reference/expressions.rst index 165dfa69f880d0..32f2d4596fe632 100644 --- a/Doc/reference/expressions.rst +++ b/Doc/reference/expressions.rst @@ -266,17 +266,19 @@ called "displays", each of them in two flavors: Common syntax elements for comprehensions are: .. productionlist:: python-grammar - comprehension: `assignment_expression` `comp_for` + comprehension: `flexible_expression` `comp_for` comp_for: ["async"] "for" `target_list` "in" `or_test` [`comp_iter`] comp_iter: `comp_for` | `comp_if` comp_if: "if" `or_test` [`comp_iter`] The comprehension consists of a single expression followed by at least one -:keyword:`!for` clause and zero or more :keyword:`!for` or :keyword:`!if` clauses. -In this case, the elements of the new container are those that would be produced -by considering each of the :keyword:`!for` or :keyword:`!if` clauses a block, -nesting from left to right, and evaluating the expression to produce an element -each time the innermost block is reached. +:keyword:`!for` clause and zero or more :keyword:`!for` or :keyword:`!if` +clauses. In this case, the elements of the new container are those that would +be produced by considering each of the :keyword:`!for` or :keyword:`!if` +clauses a block, nesting from left to right, and evaluating the expression to +produce an element each time the innermost block is reached. If the expression +is starred, the result will instead be unpacked to produce zero or more +elements. However, aside from the iterable expression in the leftmost :keyword:`!for` clause, the comprehension is executed in a separate implicitly nested scope. This ensures @@ -321,6 +323,9 @@ See also :pep:`530`. asynchronous functions. Outer comprehensions implicitly become asynchronous. +.. versionchanged:: next + Unpacking with the ``*`` operator is now allowed in the expression. + .. _lists: @@ -396,8 +401,8 @@ enclosed in curly braces: .. productionlist:: python-grammar dict_display: "{" [`dict_item_list` | `dict_comprehension`] "}" dict_item_list: `dict_item` ("," `dict_item`)* [","] + dict_comprehension: `dict_item` `comp_for` dict_item: `expression` ":" `expression` | "**" `or_expr` - dict_comprehension: `expression` ":" `expression` `comp_for` A dictionary display yields a new dictionary object. @@ -419,10 +424,21 @@ earlier dict items and earlier dictionary unpackings. .. versionadded:: 3.5 Unpacking into dictionary displays, originally proposed by :pep:`448`. -A dict comprehension, in contrast to list and set comprehensions, needs two -expressions separated with a colon followed by the usual "for" and "if" clauses. -When the comprehension is run, the resulting key and value elements are inserted -in the new dictionary in the order they are produced. +A dict comprehension may take one of two forms: + +- The first form uses two expressions separated with a colon followed by the + usual "for" and "if" clauses. When the comprehension is run, the resulting + key and value elements are inserted in the new dictionary in the order they + are produced. + +- The second form uses a single expression prefixed by the ``**`` dictionary + unpacking operator followed by the usual "for" and "if" clauses. When the + comprehension is evaluated, the expression is evaluated and then unpacked, + inserting zero or more key/value pairs into the new dictionary. + +Both forms of dictionary comprehension retain the property that if the same key +is specified multiple times, the associated value in the resulting dictionary +will be the last one specified. .. index:: pair: immutable; object hashable @@ -439,6 +455,8 @@ prevails. the key. Starting with 3.8, the key is evaluated before the value, as proposed by :pep:`572`. +.. versionchanged:: next + Unpacking with the ``**`` operator is now allowed in dictionary comprehensions. .. _genexpr: @@ -453,7 +471,7 @@ Generator expressions A generator expression is a compact generator notation in parentheses: .. productionlist:: python-grammar - generator_expression: "(" `expression` `comp_for` ")" + generator_expression: "(" `flexible_expression` `comp_for` ")" A generator expression yields a new generator object. Its syntax is the same as for comprehensions, except that it is enclosed in parentheses instead of diff --git a/Doc/tutorial/classes.rst b/Doc/tutorial/classes.rst index 9ab003d5cd3dd5..7ab0b427a6cb52 100644 --- a/Doc/tutorial/classes.rst +++ b/Doc/tutorial/classes.rst @@ -929,6 +929,25 @@ Examples:: >>> list(data[i] for i in range(len(data)-1, -1, -1)) ['f', 'l', 'o', 'g'] + >>> x = [[1,2,3], [], [4, 5]] + >>> g = (*i for i in x) + >>> list(g) + [1, 2, 3, 4, 5] + +In most cases, generator expressions must be wrapped in parentheses. As a +special case, however, when provided as the sole argument to a function (as in +the examples involving ``sum``, ``set``, ``max``, and ``list`` above), the +generator expression does not need to be wrapped in an additional set of +parentheses. That is to say, the following two pieces of code are semantically +equivalent:: + + >>> f(x for x in y) + >>> f((x for x in y)) + +as are the following:: + + >>> f(*x for x in y) + >>> f((*x for x in y)) .. rubric:: Footnotes diff --git a/Doc/tutorial/datastructures.rst b/Doc/tutorial/datastructures.rst index 7e02e74177c457..ccad53a5b2d33b 100644 --- a/Doc/tutorial/datastructures.rst +++ b/Doc/tutorial/datastructures.rst @@ -333,6 +333,47 @@ The :func:`zip` function would do a great job for this use case:: See :ref:`tut-unpacking-arguments` for details on the asterisk in this line. +Unpacking in Lists and List Comprehensions +------------------------------------------ + +The section on :ref:`tut-unpacking-arguments` describes the use of ``*`` to +"unpack" the elements of an iterable object, providing each one seperately as +an argument to a function. Unpacking can also be used in other contexts, for +example, when creating lists. When specifying elements of a list, prefixing an +expression by a ``*`` will unpack the result of that expression, adding each of +its elements to the list we're creating:: + + >>> x = [1, 2, 3] + >>> [0, *x, 4, 5, 6] + [0, 1, 2, 3, 4, 5, 6] + +This only works if the expression following the ``*`` evaluates to an iterable +object; trying to unpack a non-iterable object will raise an exception:: + + >>> x = 1 + >>> [0, *x, 2, 3, 4] + Traceback (most recent call last): + File "<python-input-1>", line 1, in <module> + [0, *x, 2, 3, 4] + TypeError: Value after * must be an iterable, not int + +Unpacking can also be used in list comprehensions, as a way to build a new list +representing the concatenation of an arbitrary number of iterables:: + + >>> x = [[1, 2, 3], [4, 5, 6], [], [7], [8, 9]] + >>> [*element for element in x] + [1, 2, 3, 4, 5, 6, 7, 8, 9] + +Note that the effect is that each element from ``x`` is unpacked. This works +for arbitrary iterable objects, not just lists:: + + >>> x = [[1, 2, 3], 'cat', {'spam': 'eggs'}] + >>> [*element for element in x] + [1, 2, 3, 'c', 'a', 't', 'spam'] + +But if the objects in ``x`` are not iterable, this expression would again raise +an exception. + .. _tut-del: The :keyword:`!del` statement @@ -394,7 +435,10 @@ A tuple consists of a number of values separated by commas, for instance:: >>> v = ([1, 2, 3], [3, 2, 1]) >>> v ([1, 2, 3], [3, 2, 1]) - + >>> # they support unpacking just like lists: + >>> x = [1, 2, 3] + >>> 0, *x, 4 + (0, 1, 2, 3, 4) As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding @@ -480,12 +524,16 @@ Here is a brief demonstration:: {'r', 'd', 'b', 'm', 'z', 'l'} Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions -are also supported:: +are also supported, including comprehensions with unpacking:: >>> a = {x for x in 'abracadabra' if x not in 'abc'} >>> a {'r', 'd'} + >>> fruits = [{'apple', 'avocado', 'apricot'}, {'banana', 'blueberry'}] + >>> {*fruit for fruit in fruits} + {'blueberry', 'banana', 'avocado', 'apple', 'apricot'} + .. _tut-dictionaries: @@ -563,6 +611,18 @@ arbitrary key and value expressions:: >>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36} +And dictionary unpacking (via ``**``) can be used to merge multiple +dictionaries:: + + >>> odds = {i: i**2 for i in (1, 3, 5)} + >>> evens = {i: i**2 for i in (2, 4, 6)} + >>> {**odds, **evens} + {1: 1, 3: 9, 5: 25, 2: 4, 4: 16, 6: 36} + + >>> all_values = [odds, evens, {0: 0}] + >>> {**i for i in all_values} + {1: 1, 3: 9, 5: 25, 2: 4, 4: 16, 6: 36, 0: 0} + When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments:: diff --git a/Doc/whatsnew/3.15.rst b/Doc/whatsnew/3.15.rst index 637dd0cca24bb9..b9178fb794a71e 100644 --- a/Doc/whatsnew/3.15.rst +++ b/Doc/whatsnew/3.15.rst @@ -69,6 +69,8 @@ Summary -- Release highlights profiling tools <whatsnew315-profiling-package>` * :pep:`799`: :ref:`Tachyon: High frequency statistical sampling profiler profiling tools <whatsnew315-sampling-profiler>` +* :pep:`798`: :ref:`Unpacking in Comprehensions + <whatsnew315-unpacking-in-comprehensions>` * :pep:`686`: :ref:`Python now uses UTF-8 as the default encoding <whatsnew315-utf8-default>` * :pep:`782`: :ref:`A new PyBytesWriter C API to create a Python bytes object @@ -187,6 +189,45 @@ available output formats, profiling modes, and configuration options. (Contributed by Pablo Galindo and László Kiss Kollár in :gh:`135953` and :gh:`138122`.) +.. _whatsnew315-unpacking-in-comprehensions: + +:pep:`798`: Unpacking in Comprehensions +--------------------------------------- + +List, set, and dictionary comprehensions, as well as generator expressions, now +support unpacking with ``*`` and ``**``. This extends the unpacking syntax +from :pep:`448` to comprehensions, providing a new syntax for combining an +arbitrary number of iterables or dictionaries into a single flat structure. +This new syntax is a direct alternative to nested comprehensions, +:func:`itertools.chain`, and :meth:`itertools.chain.from_iterable`. For +example:: + + >>> lists = [[1, 2], [3, 4], [5]] + >>> [*L for L in lists] # equivalent to [x for L in lists for x in L] + [1, 2, 3, 4, 5] + + >>> sets = [{1, 2}, {2, 3}, {3, 4}] + >>> {*s for s in sets} # equivalent to {x for s in sets for x in s} + {1, 2, 3, 4} + + >>> dicts = [{'a': 1}, {'b': 2}, {'a': 3}] + >>> {**d for d in dicts} # equivalent to {k: v for d in dicts for k,v in d.items()} + {'a': 3, 'b': 2} + +Generator expressions can similarly use unpacking to yield values from multiple +iterables:: + + >>> gen = (*L for L in lists) # equivalent to (x for L in lists for x in L) + >>> list(gen) + [1, 2, 3, 4, 5] + +This change also extends to asynchronous generator expressions, such that, for +example, ``(*a async for a in agen())`` is equivalent to ``(x async for a in +agen() for x in a)``. + +.. seealso:: :pep:`798` for further details. + +(Contributed by Adam Hartz in :gh:`143055`.) .. _whatsnew315-improved-error-messages: diff --git a/Grammar/python.gram b/Grammar/python.gram index 110136af81b596..9698d6e20100c6 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -709,12 +709,16 @@ expressions[expr_ty]: | expression expression[expr_ty] (memo): + | invalid_if_expression | invalid_expression | invalid_legacy_expression - | a=disjunction 'if' b=disjunction 'else' c=expression { _PyAST_IfExp(b, a, c, EXTRA) } + | if_expression | disjunction | lambdef +if_expression[expr_ty]: + | a=disjunction 'if' b=disjunction 'else' c=expression { _PyAST_IfExp(b, a, c, EXTRA) } + yield_expr[expr_ty]: | 'yield' 'from' a=expression { _PyAST_YieldFrom(a, EXTRA) } | 'yield' a=[star_expressions] { _PyAST_Yield(a, EXTRA) } @@ -731,10 +735,16 @@ star_expression[expr_ty] (memo): star_named_expressions[asdl_expr_seq*]: a[asdl_expr_seq*]=','.star_named_expression+ [','] { a } +star_named_expressions_sequence[asdl_expr_seq*]: a[asdl_expr_seq*]=','.star_named_expression_sequence+ [','] { a } + star_named_expression[expr_ty]: | '*' a=bitwise_or { _PyAST_Starred(a, Load, EXTRA) } | named_expression +star_named_expression_sequence[expr_ty]: + | invalid_starred_expression_unpacking_sequence + | star_named_expression + assignment_expression[expr_ty]: | a=NAME ':=' ~ b=expression { CHECK_VERSION(expr_ty, 8, "Assignment expressions are", @@ -882,9 +892,9 @@ atom[expr_ty]: | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) } | &(STRING|FSTRING_START|TSTRING_START) strings | NUMBER - | &'(' (tuple | group | genexp) - | &'[' (list | listcomp) - | &'{' (dict | set | dictcomp | setcomp) + | &'(' (genexp | tuple | group) + | &'[' (listcomp | list) + | &'{' (dictcomp | setcomp | dict | set) | '...' { _PyAST_Constant(Py_Ellipsis, NULL, EXTRA) } group[expr_ty]: @@ -998,13 +1008,13 @@ strings[expr_ty] (memo): | a[asdl_expr_seq*]=tstring+ { _PyPegen_concatenate_tstrings(p, a, EXTRA) } list[expr_ty]: - | '[' a=[star_named_expressions] ']' { _PyAST_List(a, Load, EXTRA) } + | '[' a=[star_named_expressions_sequence] ']' { _PyAST_List(a, Load, EXTRA) } tuple[expr_ty]: - | '(' a=[y=star_named_expression ',' z=[star_named_expressions] { _PyPegen_seq_insert_in_front(p, y, z) } ] ')' { + | '(' a=[y=star_named_expression_sequence ',' z=[star_named_expressions_sequence] { _PyPegen_seq_insert_in_front(p, y, z) } ] ')' { _PyAST_Tuple(a, Load, EXTRA) } -set[expr_ty]: '{' a=star_named_expressions '}' { _PyAST_Set(a, EXTRA) } +set[expr_ty]: '{' a=star_named_expressions_sequence '}' { _PyAST_Set(a, EXTRA) } # Dicts # ----- @@ -1040,20 +1050,20 @@ for_if_clause[comprehension_ty]: | invalid_for_target listcomp[expr_ty]: - | '[' a=named_expression b=for_if_clauses ']' { _PyAST_ListComp(a, b, EXTRA) } + | '[' a=star_named_expression b=for_if_clauses ']' { _PyAST_ListComp(a, b, EXTRA) } | invalid_comprehension setcomp[expr_ty]: - | '{' a=named_expression b=for_if_clauses '}' { _PyAST_SetComp(a, b, EXTRA) } + | '{' a=star_named_expression b=for_if_clauses '}' { _PyAST_SetComp(a, b, EXTRA) } | invalid_comprehension genexp[expr_ty]: - | '(' a=( assignment_expression | expression !':=') b=for_if_clauses ')' { _PyAST_GeneratorExp(a, b, EXTRA) } + | '(' a=( assignment_expression | expression !':=' | starred_expression ) b=for_if_clauses ')' { _PyAST_GeneratorExp(a, b, EXTRA) } | invalid_comprehension dictcomp[expr_ty]: | '{' a=kvpair b=for_if_clauses '}' { _PyAST_DictComp(a->key, a->value, b, EXTRA) } - | invalid_dict_comprehension + | '{' '**' a=expression b=for_if_clauses '}' { _PyAST_DictComp(a, NULL, b, EXTRA) } # FUNCTION CALL ARGUMENTS # ======================= @@ -1262,6 +1272,12 @@ invalid_expression: | a='lambda' [lambda_params] b=':' &TSTRING_MIDDLE { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "t-string: lambda expressions are not allowed without parentheses") } +invalid_if_expression: + | disjunction 'if' b=disjunction 'else' a='*' { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot unpack only part of a conditional expression") } + | disjunction 'if' b=disjunction 'else' a='**' { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot use dict unpacking on only part of a conditional expression") } + invalid_named_expression(memo): | a=expression ':=' expression { RAISE_SYNTAX_ERROR_KNOWN_LOCATION( @@ -1326,16 +1342,15 @@ invalid_assert_stmt: invalid_block: | NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block") } invalid_comprehension: - | ('[' | '(' | '{') a=starred_expression for_if_clauses { - RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "iterable unpacking cannot be used in comprehension") } + | '[' a='**' b=expression for_if_clauses { + RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use dict unpacking in list comprehension") } + | '(' a='**' b=expression for_if_clauses { + RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use dict unpacking in generator expression") } | ('[' | '{') a=star_named_expression ',' b=star_named_expressions for_if_clauses { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, PyPegen_last_item(b, expr_ty), "did you forget parentheses around the comprehension target?") } | ('[' | '{') a=star_named_expression b=',' for_if_clauses { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "did you forget parentheses around the comprehension target?") } -invalid_dict_comprehension: - | '{' a='**' bitwise_or for_if_clauses '}' { - RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "dict unpacking cannot be used in dict comprehension") } invalid_parameters: | a="/" ',' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "at least one parameter must precede /") } @@ -1530,19 +1545,32 @@ invalid_class_def_raw: RAISE_INDENTATION_ERROR("expected an indented block after class definition on line %d", a->lineno) } invalid_double_starred_kvpairs: - | ','.double_starred_kvpair+ ',' invalid_kvpair - | expression ':' a='*' bitwise_or { RAISE_SYNTAX_ERROR_STARTING_FROM(a, "cannot use a starred expression in a dictionary value") } + | invalid_kvpair_unpacking [','] + | ','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking) | expression a=':' &('}'|',') { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expression expected after dictionary key and ':'") } +invalid_kvpair_unpacking: + | a='**' b=if_expression { + RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "invalid double starred expression. Did you forget to wrap the conditional expression in parentheses?") } + | a='*' b=bitwise_or ':' expression { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use a starred expression in a dictionary key") } + | a='**' b=bitwise_or ':' expression { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use dict unpacking in a dictionary key") } + | expression ':' a='*' b=bitwise_or { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use a starred expression in a dictionary value") } + | expression ':' a='**' b=bitwise_or { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use dict unpacking in a dictionary value") } invalid_kvpair: | a=expression !(':') { RAISE_ERROR_KNOWN_LOCATION(p, PyExc_SyntaxError, a->lineno, a->end_col_offset - 1, a->end_lineno, -1, "':' expected after dictionary key") } | expression ':' a='*' bitwise_or { RAISE_SYNTAX_ERROR_STARTING_FROM(a, "cannot use a starred expression in a dictionary value") } + | expression ':' a='**' bitwise_or { RAISE_SYNTAX_ERROR_STARTING_FROM(a, "cannot use dict unpacking in a dictionary value") } | expression a=':' &('}'|',') {RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expression expected after dictionary key and ':'") } invalid_starred_expression_unpacking: + | a='*' b=if_expression { + RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "invalid starred expression. Did you forget to wrap the conditional expression in parentheses?") } | a='*' expression '=' b=expression { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot assign to iterable argument unpacking") } +invalid_starred_expression_unpacking_sequence: + | a='**' bitwise_or { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot use dict unpacking here") } + | invalid_starred_expression_unpacking invalid_starred_expression: | '*' { RAISE_SYNTAX_ERROR("Invalid star expression") } - invalid_fstring_replacement_field: | '{' a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '='") } | '{' a='!' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '!'") } diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py index 6f212d2f91efb1..7354f8281d9682 100644 --- a/Lib/test/test_exceptions.py +++ b/Lib/test/test_exceptions.py @@ -337,7 +337,6 @@ def baz(): check('x=1\nfrom __future__ import division', 2, 1) check('foo(1=2)', 1, 5) check('def f():\n x, y: int', 2, 3) - check('[*x for x in xs]', 1, 2) check('foo(x for x in range(10), 100)', 1, 5) check('for 1 in []: pass', 1, 5) check('(yield i) = 2', 1, 2) @@ -2433,7 +2432,8 @@ def test_encodings(self): ) err = run_script(source.encode('cp437')) self.assertEqual(err[-3], ' "┬ó┬ó┬ó┬ó┬ó┬ó" + f(4, x for x in range(1))') - self.assertEqual(err[-2], ' ^^^') + self.assertEqual(err[-2], ' ^^^^^^^^^^^^^^^^^^^') + self.assertEqual(err[-1], 'SyntaxError: Generator expression must be parenthesized') # Check backwards tokenizer errors source = '# -*- coding: ascii -*-\n\n(\n' diff --git a/Lib/test/test_unpack_ex.py b/Lib/test/test_unpack_ex.py index 9e2d54bd3a8c4e..d147cd96d207db 100644 --- a/Lib/test/test_unpack_ex.py +++ b/Lib/test/test_unpack_ex.py @@ -141,7 +141,7 @@ >>> {0:1, **{0:2}, 0:3, 0:4} {0: 4} -List comprehension element unpacking +Comprehension element unpacking >>> a, b, c = [0, 1, 2], 3, 4 >>> [*a, b, c] @@ -149,46 +149,206 @@ >>> l = [a, (3, 4), {5}, {6: None}, (i for i in range(7, 10))] >>> [*item for item in l] + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + + >>> [*[0, 1] for i in range(5)] + [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] + + >>> [*'a' for i in range(5)] + ['a', 'a', 'a', 'a', 'a'] + + >>> [*[] for i in range(10)] + [] + + >>> [*(x*2) for x in [[1, 2, 3], [], 'cat']] + [1, 2, 3, 1, 2, 3, 'c', 'a', 't', 'c', 'a', 't'] + + >>> {**{} for a in [1]} + {} + + >>> {**{7: i} for i in range(10)} + {7: 9} + + >>> dicts = [{1: 2}, {3: 4}, {5: 6, 7: 8}, {}, {9: 10}, {1: 0}] + >>> {**d for d in dicts} + {1: 0, 3: 4, 5: 6, 7: 8, 9: 10} + + >>> gen = (*(0, 1) for i in range(5)) + >>> next(gen) + 0 + >>> list(gen) + [1, 0, 1, 0, 1, 0, 1, 0, 1] + +Comprehension unpacking with conditionals and double loops + + >>> [*[i, i+1] for i in range(5) if i % 2 == 0] + [0, 1, 2, 3, 4, 5] + + >>> [*y for x in [[[0], [1, 2, 3], [], [4, 5]], [[6, 7]]] for y in x] + [0, 1, 2, 3, 4, 5, 6, 7] + + >>> [*y for x in [[[0], [1, 2, 3], [], [4, 5]], [[6, 7]]] for y in x if y and y[0]>0] + [1, 2, 3, 4, 5, 6, 7] + + >>> dicts = [{1: 2}, {3: 4}, {5: 6, 7: 8}, {}, {9: 10}, {1: 0}] + >>> {**d for d in dicts if len(d) != 2} + {1: 0, 3: 4, 9: 10} + +Scoping of assignment expressions in comprehensions + + >>> [*((y := i**2), 2*y) for i in range(4)] + [0, 0, 1, 2, 4, 8, 9, 18] + >>> y + 9 + + >>> [*(y := [i, i+1, i+2]) for i in range(4)] + [0, 1, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5] + >>> y + [3, 4, 5] + + >>> g = (*(z := [i, i+1, i+2]) for i in range(4)) + >>> z Traceback (most recent call last): ... - SyntaxError: iterable unpacking cannot be used in comprehension + NameError: name 'z' is not defined + >>> next(g) + 0 + >>> z + [0, 1, 2] + >>> next(g) + 1 + >>> z + [0, 1, 2] + >>> next(g) + 2 + >>> z + [0, 1, 2] + >>> next(g) + 1 + >>> z + [1, 2, 3] + + >>> x = [1, 2, 3] + >>> y = [4, 5, 6] + >>> def f(*args): + ... print(args) + + >>> f(*x if x else y) + (1, 2, 3) + + +Malformed comperehension element unpacking + + >>> [*x for x in [1, 2, 3]] + Traceback (most recent call last): + ... + [*x for x in [1, 2, 3]] + ^^ + TypeError: Value after * must be an iterable, not int + + +Error messages for specific failure modes of unpacking - >>> [*[0, 1] for i in range(10)] + >>> [*x if x else y for x in z] Traceback (most recent call last): ... - SyntaxError: iterable unpacking cannot be used in comprehension + [*x if x else y for x in z] + ^^^^^^^^^^^^^^ + SyntaxError: invalid starred expression. Did you forget to wrap the conditional expression in parentheses? - >>> [*'a' for i in range(10)] + >>> [*x if x else y] Traceback (most recent call last): ... - SyntaxError: iterable unpacking cannot be used in comprehension + [*x if x else y] + ^^^^^^^^^^^^^^ + SyntaxError: invalid starred expression. Did you forget to wrap the conditional expression in parentheses? - >>> [*[] for i in range(10)] + >>> [x if x else *y for x in z] Traceback (most recent call last): ... - SyntaxError: iterable unpacking cannot be used in comprehension + [x if x else *y for x in z] + ^ + SyntaxError: cannot unpack only part of a conditional expression - >>> {**{} for a in [1]} + >>> [x if x else *y] Traceback (most recent call last): ... - SyntaxError: dict unpacking cannot be used in dict comprehension + [x if x else *y] + ^ + SyntaxError: cannot unpack only part of a conditional expression -# Pegen is better here. -# Generator expression in function arguments + >>> {**x if x else y} + Traceback (most recent call last): + ... + {**x if x else y} + ^^^^^^^^^^^^^^^^ + SyntaxError: invalid double starred expression. Did you forget to wrap the conditional expression in parentheses? + >>> {x if x else **y} + Traceback (most recent call last): + ... + {x if x else **y} + ^^ + SyntaxError: cannot use dict unpacking on only part of a conditional expression -# >>> list(*x for x in (range(5) for i in range(3))) -# Traceback (most recent call last): -# ... -# list(*x for x in (range(5) for i in range(3))) -# ^ -# SyntaxError: invalid syntax + >>> [**x for x in [{1: 2}]] + Traceback (most recent call last): + ... + [**x for x in [{1: 2}]] + ^^^ + SyntaxError: cannot use dict unpacking in list comprehension + + >>> (**x for x in [{1:2}]) + Traceback (most recent call last): + ... + (**x for x in [{1:2}]) + ^^^ + SyntaxError: cannot use dict unpacking in generator expression >>> dict(**x for x in [{1:2}]) Traceback (most recent call last): ... dict(**x for x in [{1:2}]) - ^ - SyntaxError: invalid syntax + ^^^ + SyntaxError: cannot use dict unpacking in generator expression + + >>> {*a: b for a, b in {1: 2}.items()} + Traceback (most recent call last): + ... + {*a: b for a, b in {1: 2}.items()} + ^^ + SyntaxError: cannot use a starred expression in a dictionary key + + >>> {**a: b for a, b in {1: 2}.items()} + Traceback (most recent call last): + ... + {**a: b for a, b in {1: 2}.items()} + ^^^ + SyntaxError: cannot use dict unpacking in a dictionary key + + >>> {a: *b for a, b in {1: 2}.items()} + Traceback (most recent call last): + ... + {a: *b for a, b in {1: 2}.items()} + ^^ + SyntaxError: cannot use a starred expression in a dictionary value + + >>> {a: **b for a, b in {1: 2}.items()} + Traceback (most recent call last): + ... + {a: **b for a, b in {1: 2}.items()} + ^^^ + SyntaxError: cannot use dict unpacking in a dictionary value + + +# Generator expression in function arguments + + >>> list(*x for x in (range(5) for i in range(3))) + [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4] + + >>> def f(arg): + ... print(type(arg), list(arg), list(arg)) + >>> f(*x for x in [[1,2,3]]) + <class 'generator'> [1, 2, 3] [] Iterable argument unpacking diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2025-12-21-18-12-30.gh-issue-143055.PzwccL.rst b/Misc/NEWS.d/next/Core_and_Builtins/2025-12-21-18-12-30.gh-issue-143055.PzwccL.rst new file mode 100644 index 00000000000000..d3ed40668f6539 --- /dev/null +++ b/Misc/NEWS.d/next/Core_and_Builtins/2025-12-21-18-12-30.gh-issue-143055.PzwccL.rst @@ -0,0 +1 @@ +Implement :pep:`798` (Unpacking in Comprehensions). Patch by Adam Hartz. diff --git a/Parser/Python.asdl b/Parser/Python.asdl index 9c7529c479916d..dbe226f837243c 100644 --- a/Parser/Python.asdl +++ b/Parser/Python.asdl @@ -67,7 +67,7 @@ module Python | Set(expr* elts) | ListComp(expr elt, comprehension* generators) | SetComp(expr elt, comprehension* generators) - | DictComp(expr key, expr value, comprehension* generators) + | DictComp(expr key, expr? value, comprehension* generators) | GeneratorExp(expr elt, comprehension* generators) -- the grammar constrains where yield expressions can occur | Await(expr value) diff --git a/Parser/parser.c b/Parser/parser.c index 09bfb5725a2ec3..b9848a865b6875 100644 --- a/Parser/parser.c +++ b/Parser/parser.c @@ -22,54 +22,54 @@ static KeywordToken *reserved_keywords[] = { (KeywordToken[]) {{NULL, -1}}, (KeywordToken[]) {{NULL, -1}}, (KeywordToken[]) { - {"if", 691}, - {"as", 689}, - {"in", 704}, + {"if", 695}, + {"as", 693}, + {"in", 708}, {"or", 589}, {"is", 597}, {NULL, -1}, }, (KeywordToken[]) { - {"del", 630}, - {"def", 708}, - {"for", 703}, - {"try", 665}, + {"del", 634}, + {"def", 712}, + {"for", 707}, + {"try", 669}, {"and", 590}, - {"not", 712}, + {"not", 716}, {NULL, -1}, }, (KeywordToken[]) { - {"from", 642}, + {"from", 646}, {"pass", 527}, - {"with", 656}, - {"elif", 696}, - {"else", 695}, - {"None", 624}, - {"True", 623}, + {"with", 660}, + {"elif", 700}, + {"else", 699}, + {"None", 628}, + {"True", 627}, {NULL, -1}, }, (KeywordToken[]) { - {"raise", 628}, + {"raise", 632}, {"yield", 588}, {"break", 528}, - {"async", 707}, - {"class", 710}, - {"while", 698}, - {"False", 625}, + {"async", 711}, + {"class", 714}, + {"while", 702}, + {"False", 629}, {"await", 598}, {NULL, -1}, }, (KeywordToken[]) { {"return", 522}, - {"import", 643}, - {"assert", 634}, + {"import", 647}, + {"assert", 638}, {"global", 530}, - {"except", 686}, + {"except", 690}, {"lambda", 622}, {NULL, -1}, }, (KeywordToken[]) { - {"finally", 682}, + {"finally", 686}, {NULL, -1}, }, (KeywordToken[]) { @@ -195,344 +195,352 @@ static char *soft_keywords[] = { #define type_param_starred_default_type 1107 #define expressions_type 1108 #define expression_type 1109 -#define yield_expr_type 1110 -#define star_expressions_type 1111 -#define star_expression_type 1112 -#define star_named_expressions_type 1113 -#define star_named_expression_type 1114 -#define assignment_expression_type 1115 -#define named_expression_type 1116 -#define disjunction_type 1117 -#define conjunction_type 1118 -#define inversion_type 1119 -#define comparison_type 1120 -#define compare_op_bitwise_or_pair_type 1121 -#define eq_bitwise_or_type 1122 -#define noteq_bitwise_or_type 1123 -#define lte_bitwise_or_type 1124 -#define lt_bitwise_or_type 1125 -#define gte_bitwise_or_type 1126 -#define gt_bitwise_or_type 1127 -#define notin_bitwise_or_type 1128 -#define in_bitwise_or_type 1129 -#define isnot_bitwise_or_type 1130 -#define is_bitwise_or_type 1131 -#define bitwise_or_type 1132 // Left-recursive -#define bitwise_xor_type 1133 // Left-recursive -#define bitwise_and_type 1134 // Left-recursive -#define shift_expr_type 1135 // Left-recursive -#define sum_type 1136 // Left-recursive -#define term_type 1137 // Left-recursive -#define factor_type 1138 -#define power_type 1139 -#define await_primary_type 1140 -#define primary_type 1141 // Left-recursive -#define slices_type 1142 -#define slice_type 1143 -#define atom_type 1144 -#define group_type 1145 -#define lambdef_type 1146 -#define lambda_params_type 1147 -#define lambda_parameters_type 1148 -#define lambda_slash_no_default_type 1149 -#define lambda_slash_with_default_type 1150 -#define lambda_star_etc_type 1151 -#define lambda_kwds_type 1152 -#define lambda_param_no_default_type 1153 -#define lambda_param_with_default_type 1154 -#define lambda_param_maybe_default_type 1155 -#define lambda_param_type 1156 -#define fstring_middle_type 1157 -#define fstring_replacement_field_type 1158 -#define fstring_conversion_type 1159 -#define fstring_full_format_spec_type 1160 -#define fstring_format_spec_type 1161 -#define fstring_type 1162 -#define tstring_format_spec_replacement_field_type 1163 -#define tstring_format_spec_type 1164 -#define tstring_full_format_spec_type 1165 -#define tstring_replacement_field_type 1166 -#define tstring_middle_type 1167 -#define tstring_type 1168 -#define string_type 1169 -#define strings_type 1170 -#define list_type 1171 -#define tuple_type 1172 -#define set_type 1173 -#define dict_type 1174 -#define double_starred_kvpairs_type 1175 -#define double_starred_kvpair_type 1176 -#define kvpair_type 1177 -#define for_if_clauses_type 1178 -#define for_if_clause_type 1179 -#define listcomp_type 1180 -#define setcomp_type 1181 -#define genexp_type 1182 -#define dictcomp_type 1183 -#define arguments_type 1184 -#define args_type 1185 -#define kwargs_type 1186 -#define starred_expression_type 1187 -#define kwarg_or_starred_type 1188 -#define kwarg_or_double_starred_type 1189 -#define star_targets_type 1190 -#define star_targets_list_seq_type 1191 -#define star_targets_tuple_seq_type 1192 -#define star_target_type 1193 -#define target_with_star_atom_type 1194 -#define star_atom_type 1195 -#define single_target_type 1196 -#define single_subscript_attribute_target_type 1197 -#define t_primary_type 1198 // Left-recursive -#define t_lookahead_type 1199 -#define del_targets_type 1200 -#define del_target_type 1201 -#define del_t_atom_type 1202 -#define type_expressions_type 1203 -#define func_type_comment_type 1204 -#define invalid_arguments_type 1205 -#define invalid_kwarg_type 1206 -#define expression_without_invalid_type 1207 -#define invalid_legacy_expression_type 1208 -#define invalid_type_param_type 1209 -#define invalid_expression_type 1210 -#define invalid_named_expression_type 1211 -#define invalid_assignment_type 1212 -#define invalid_ann_assign_target_type 1213 -#define invalid_raise_stmt_type 1214 -#define invalid_del_stmt_type 1215 -#define invalid_assert_stmt_type 1216 -#define invalid_block_type 1217 -#define invalid_comprehension_type 1218 -#define invalid_dict_comprehension_type 1219 -#define invalid_parameters_type 1220 -#define invalid_default_type 1221 -#define invalid_star_etc_type 1222 -#define invalid_kwds_type 1223 -#define invalid_parameters_helper_type 1224 -#define invalid_lambda_parameters_type 1225 -#define invalid_lambda_parameters_helper_type 1226 -#define invalid_lambda_star_etc_type 1227 -#define invalid_lambda_kwds_type 1228 -#define invalid_double_type_comments_type 1229 -#define invalid_with_item_type 1230 -#define invalid_for_if_clause_type 1231 -#define invalid_for_target_type 1232 -#define invalid_group_type 1233 -#define invalid_import_type 1234 -#define invalid_dotted_as_name_type 1235 -#define invalid_import_from_as_name_type 1236 -#define invalid_import_from_targets_type 1237 -#define invalid_with_stmt_type 1238 -#define invalid_with_stmt_indent_type 1239 -#define invalid_try_stmt_type 1240 -#define invalid_except_stmt_type 1241 -#define invalid_except_star_stmt_type 1242 -#define invalid_finally_stmt_type 1243 -#define invalid_except_stmt_indent_type 1244 -#define invalid_except_star_stmt_indent_type 1245 -#define invalid_match_stmt_type 1246 -#define invalid_case_block_type 1247 -#define invalid_as_pattern_type 1248 -#define invalid_class_pattern_type 1249 -#define invalid_mapping_pattern_type 1250 -#define invalid_class_argument_pattern_type 1251 -#define invalid_if_stmt_type 1252 -#define invalid_elif_stmt_type 1253 -#define invalid_else_stmt_type 1254 -#define invalid_while_stmt_type 1255 -#define invalid_for_stmt_type 1256 -#define invalid_def_raw_type 1257 -#define invalid_class_def_raw_type 1258 -#define invalid_double_starred_kvpairs_type 1259 -#define invalid_kvpair_type 1260 -#define invalid_starred_expression_unpacking_type 1261 -#define invalid_starred_expression_type 1262 -#define invalid_fstring_replacement_field_type 1263 -#define invalid_fstring_conversion_character_type 1264 -#define invalid_tstring_replacement_field_type 1265 -#define invalid_tstring_conversion_character_type 1266 -#define invalid_string_tstring_concat_type 1267 -#define invalid_arithmetic_type 1268 -#define invalid_factor_type 1269 -#define invalid_type_params_type 1270 -#define _loop0_1_type 1271 -#define _loop1_2_type 1272 -#define _loop0_3_type 1273 -#define _gather_4_type 1274 -#define _tmp_5_type 1275 -#define _tmp_6_type 1276 -#define _tmp_7_type 1277 -#define _tmp_8_type 1278 -#define _tmp_9_type 1279 -#define _tmp_10_type 1280 -#define _tmp_11_type 1281 -#define _loop1_12_type 1282 -#define _loop0_13_type 1283 -#define _gather_14_type 1284 -#define _tmp_15_type 1285 -#define _tmp_16_type 1286 -#define _loop0_17_type 1287 -#define _loop1_18_type 1288 -#define _loop0_19_type 1289 -#define _gather_20_type 1290 -#define _tmp_21_type 1291 -#define _loop0_22_type 1292 -#define _gather_23_type 1293 -#define _loop1_24_type 1294 -#define _tmp_25_type 1295 -#define _tmp_26_type 1296 -#define _loop0_27_type 1297 -#define _loop0_28_type 1298 -#define _loop1_29_type 1299 -#define _loop1_30_type 1300 -#define _loop0_31_type 1301 -#define _loop1_32_type 1302 -#define _loop0_33_type 1303 -#define _gather_34_type 1304 -#define _tmp_35_type 1305 -#define _loop1_36_type 1306 -#define _loop1_37_type 1307 -#define _loop1_38_type 1308 -#define _loop0_39_type 1309 -#define _gather_40_type 1310 -#define _tmp_41_type 1311 -#define _tmp_42_type 1312 -#define _tmp_43_type 1313 -#define _loop0_44_type 1314 -#define _gather_45_type 1315 -#define _loop0_46_type 1316 -#define _gather_47_type 1317 -#define _tmp_48_type 1318 -#define _loop0_49_type 1319 -#define _gather_50_type 1320 -#define _loop0_51_type 1321 -#define _gather_52_type 1322 -#define _loop0_53_type 1323 -#define _gather_54_type 1324 -#define _loop1_55_type 1325 -#define _loop1_56_type 1326 -#define _loop0_57_type 1327 -#define _gather_58_type 1328 -#define _loop1_59_type 1329 -#define _loop1_60_type 1330 -#define _loop1_61_type 1331 -#define _tmp_62_type 1332 -#define _loop0_63_type 1333 -#define _gather_64_type 1334 -#define _tmp_65_type 1335 -#define _tmp_66_type 1336 -#define _tmp_67_type 1337 -#define _tmp_68_type 1338 -#define _tmp_69_type 1339 -#define _loop0_70_type 1340 -#define _loop0_71_type 1341 -#define _loop1_72_type 1342 -#define _loop1_73_type 1343 -#define _loop0_74_type 1344 -#define _loop1_75_type 1345 -#define _loop0_76_type 1346 -#define _loop0_77_type 1347 -#define _loop0_78_type 1348 -#define _loop0_79_type 1349 -#define _loop1_80_type 1350 -#define _loop1_81_type 1351 -#define _tmp_82_type 1352 -#define _loop0_83_type 1353 -#define _gather_84_type 1354 -#define _loop1_85_type 1355 -#define _loop0_86_type 1356 -#define _tmp_87_type 1357 -#define _loop0_88_type 1358 -#define _gather_89_type 1359 -#define _tmp_90_type 1360 -#define _loop0_91_type 1361 -#define _gather_92_type 1362 -#define _loop0_93_type 1363 -#define _gather_94_type 1364 -#define _loop0_95_type 1365 -#define _loop0_96_type 1366 -#define _gather_97_type 1367 -#define _loop1_98_type 1368 -#define _tmp_99_type 1369 -#define _loop0_100_type 1370 -#define _gather_101_type 1371 -#define _loop0_102_type 1372 -#define _gather_103_type 1373 -#define _tmp_104_type 1374 -#define _tmp_105_type 1375 -#define _loop0_106_type 1376 -#define _gather_107_type 1377 -#define _tmp_108_type 1378 -#define _tmp_109_type 1379 -#define _tmp_110_type 1380 -#define _tmp_111_type 1381 -#define _tmp_112_type 1382 -#define _loop1_113_type 1383 -#define _tmp_114_type 1384 -#define _tmp_115_type 1385 -#define _tmp_116_type 1386 -#define _tmp_117_type 1387 -#define _tmp_118_type 1388 -#define _loop0_119_type 1389 -#define _loop0_120_type 1390 -#define _tmp_121_type 1391 -#define _tmp_122_type 1392 -#define _tmp_123_type 1393 -#define _tmp_124_type 1394 -#define _tmp_125_type 1395 -#define _tmp_126_type 1396 -#define _tmp_127_type 1397 -#define _tmp_128_type 1398 -#define _tmp_129_type 1399 -#define _loop0_130_type 1400 -#define _gather_131_type 1401 -#define _tmp_132_type 1402 -#define _tmp_133_type 1403 -#define _tmp_134_type 1404 -#define _tmp_135_type 1405 -#define _loop0_136_type 1406 -#define _gather_137_type 1407 -#define _tmp_138_type 1408 -#define _loop0_139_type 1409 -#define _gather_140_type 1410 -#define _loop0_141_type 1411 -#define _gather_142_type 1412 -#define _tmp_143_type 1413 -#define _loop0_144_type 1414 -#define _tmp_145_type 1415 -#define _tmp_146_type 1416 -#define _tmp_147_type 1417 -#define _tmp_148_type 1418 -#define _tmp_149_type 1419 -#define _tmp_150_type 1420 -#define _tmp_151_type 1421 -#define _tmp_152_type 1422 -#define _tmp_153_type 1423 -#define _tmp_154_type 1424 -#define _tmp_155_type 1425 -#define _tmp_156_type 1426 -#define _tmp_157_type 1427 -#define _tmp_158_type 1428 -#define _tmp_159_type 1429 -#define _tmp_160_type 1430 -#define _tmp_161_type 1431 -#define _tmp_162_type 1432 -#define _tmp_163_type 1433 -#define _tmp_164_type 1434 -#define _tmp_165_type 1435 -#define _tmp_166_type 1436 -#define _tmp_167_type 1437 -#define _tmp_168_type 1438 -#define _tmp_169_type 1439 -#define _tmp_170_type 1440 -#define _tmp_171_type 1441 -#define _loop0_172_type 1442 -#define _tmp_173_type 1443 -#define _tmp_174_type 1444 -#define _tmp_175_type 1445 -#define _tmp_176_type 1446 -#define _tmp_177_type 1447 +#define if_expression_type 1110 +#define yield_expr_type 1111 +#define star_expressions_type 1112 +#define star_expression_type 1113 +#define star_named_expressions_type 1114 +#define star_named_expressions_sequence_type 1115 +#define star_named_expression_type 1116 +#define star_named_expression_sequence_type 1117 +#define assignment_expression_type 1118 +#define named_expression_type 1119 +#define disjunction_type 1120 +#define conjunction_type 1121 +#define inversion_type 1122 +#define comparison_type 1123 +#define compare_op_bitwise_or_pair_type 1124 +#define eq_bitwise_or_type 1125 +#define noteq_bitwise_or_type 1126 +#define lte_bitwise_or_type 1127 +#define lt_bitwise_or_type 1128 +#define gte_bitwise_or_type 1129 +#define gt_bitwise_or_type 1130 +#define notin_bitwise_or_type 1131 +#define in_bitwise_or_type 1132 +#define isnot_bitwise_or_type 1133 +#define is_bitwise_or_type 1134 +#define bitwise_or_type 1135 // Left-recursive +#define bitwise_xor_type 1136 // Left-recursive +#define bitwise_and_type 1137 // Left-recursive +#define shift_expr_type 1138 // Left-recursive +#define sum_type 1139 // Left-recursive +#define term_type 1140 // Left-recursive +#define factor_type 1141 +#define power_type 1142 +#define await_primary_type 1143 +#define primary_type 1144 // Left-recursive +#define slices_type 1145 +#define slice_type 1146 +#define atom_type 1147 +#define group_type 1148 +#define lambdef_type 1149 +#define lambda_params_type 1150 +#define lambda_parameters_type 1151 +#define lambda_slash_no_default_type 1152 +#define lambda_slash_with_default_type 1153 +#define lambda_star_etc_type 1154 +#define lambda_kwds_type 1155 +#define lambda_param_no_default_type 1156 +#define lambda_param_with_default_type 1157 +#define lambda_param_maybe_default_type 1158 +#define lambda_param_type 1159 +#define fstring_middle_type 1160 +#define fstring_replacement_field_type 1161 +#define fstring_conversion_type 1162 +#define fstring_full_format_spec_type 1163 +#define fstring_format_spec_type 1164 +#define fstring_type 1165 +#define tstring_format_spec_replacement_field_type 1166 +#define tstring_format_spec_type 1167 +#define tstring_full_format_spec_type 1168 +#define tstring_replacement_field_type 1169 +#define tstring_middle_type 1170 +#define tstring_type 1171 +#define string_type 1172 +#define strings_type 1173 +#define list_type 1174 +#define tuple_type 1175 +#define set_type 1176 +#define dict_type 1177 +#define double_starred_kvpairs_type 1178 +#define double_starred_kvpair_type 1179 +#define kvpair_type 1180 +#define for_if_clauses_type 1181 +#define for_if_clause_type 1182 +#define listcomp_type 1183 +#define setcomp_type 1184 +#define genexp_type 1185 +#define dictcomp_type 1186 +#define arguments_type 1187 +#define args_type 1188 +#define kwargs_type 1189 +#define starred_expression_type 1190 +#define kwarg_or_starred_type 1191 +#define kwarg_or_double_starred_type 1192 +#define star_targets_type 1193 +#define star_targets_list_seq_type 1194 +#define star_targets_tuple_seq_type 1195 +#define star_target_type 1196 +#define target_with_star_atom_type 1197 +#define star_atom_type 1198 +#define single_target_type 1199 +#define single_subscript_attribute_target_type 1200 +#define t_primary_type 1201 // Left-recursive +#define t_lookahead_type 1202 +#define del_targets_type 1203 +#define del_target_type 1204 +#define del_t_atom_type 1205 +#define type_expressions_type 1206 +#define func_type_comment_type 1207 +#define invalid_arguments_type 1208 +#define invalid_kwarg_type 1209 +#define expression_without_invalid_type 1210 +#define invalid_legacy_expression_type 1211 +#define invalid_type_param_type 1212 +#define invalid_expression_type 1213 +#define invalid_if_expression_type 1214 +#define invalid_named_expression_type 1215 +#define invalid_assignment_type 1216 +#define invalid_ann_assign_target_type 1217 +#define invalid_raise_stmt_type 1218 +#define invalid_del_stmt_type 1219 +#define invalid_assert_stmt_type 1220 +#define invalid_block_type 1221 +#define invalid_comprehension_type 1222 +#define invalid_parameters_type 1223 +#define invalid_default_type 1224 +#define invalid_star_etc_type 1225 +#define invalid_kwds_type 1226 +#define invalid_parameters_helper_type 1227 +#define invalid_lambda_parameters_type 1228 +#define invalid_lambda_parameters_helper_type 1229 +#define invalid_lambda_star_etc_type 1230 +#define invalid_lambda_kwds_type 1231 +#define invalid_double_type_comments_type 1232 +#define invalid_with_item_type 1233 +#define invalid_for_if_clause_type 1234 +#define invalid_for_target_type 1235 +#define invalid_group_type 1236 +#define invalid_import_type 1237 +#define invalid_dotted_as_name_type 1238 +#define invalid_import_from_as_name_type 1239 +#define invalid_import_from_targets_type 1240 +#define invalid_with_stmt_type 1241 +#define invalid_with_stmt_indent_type 1242 +#define invalid_try_stmt_type 1243 +#define invalid_except_stmt_type 1244 +#define invalid_except_star_stmt_type 1245 +#define invalid_finally_stmt_type 1246 +#define invalid_except_stmt_indent_type 1247 +#define invalid_except_star_stmt_indent_type 1248 +#define invalid_match_stmt_type 1249 +#define invalid_case_block_type 1250 +#define invalid_as_pattern_type 1251 +#define invalid_class_pattern_type 1252 +#define invalid_mapping_pattern_type 1253 +#define invalid_class_argument_pattern_type 1254 +#define invalid_if_stmt_type 1255 +#define invalid_elif_stmt_type 1256 +#define invalid_else_stmt_type 1257 +#define invalid_while_stmt_type 1258 +#define invalid_for_stmt_type 1259 +#define invalid_def_raw_type 1260 +#define invalid_class_def_raw_type 1261 +#define invalid_double_starred_kvpairs_type 1262 +#define invalid_kvpair_unpacking_type 1263 +#define invalid_kvpair_type 1264 +#define invalid_starred_expression_unpacking_type 1265 +#define invalid_starred_expression_unpacking_sequence_type 1266 +#define invalid_starred_expression_type 1267 +#define invalid_fstring_replacement_field_type 1268 +#define invalid_fstring_conversion_character_type 1269 +#define invalid_tstring_replacement_field_type 1270 +#define invalid_tstring_conversion_character_type 1271 +#define invalid_string_tstring_concat_type 1272 +#define invalid_arithmetic_type 1273 +#define invalid_factor_type 1274 +#define invalid_type_params_type 1275 +#define _loop0_1_type 1276 +#define _loop1_2_type 1277 +#define _loop0_3_type 1278 +#define _gather_4_type 1279 +#define _tmp_5_type 1280 +#define _tmp_6_type 1281 +#define _tmp_7_type 1282 +#define _tmp_8_type 1283 +#define _tmp_9_type 1284 +#define _tmp_10_type 1285 +#define _tmp_11_type 1286 +#define _loop1_12_type 1287 +#define _loop0_13_type 1288 +#define _gather_14_type 1289 +#define _tmp_15_type 1290 +#define _tmp_16_type 1291 +#define _loop0_17_type 1292 +#define _loop1_18_type 1293 +#define _loop0_19_type 1294 +#define _gather_20_type 1295 +#define _tmp_21_type 1296 +#define _loop0_22_type 1297 +#define _gather_23_type 1298 +#define _loop1_24_type 1299 +#define _tmp_25_type 1300 +#define _tmp_26_type 1301 +#define _loop0_27_type 1302 +#define _loop0_28_type 1303 +#define _loop1_29_type 1304 +#define _loop1_30_type 1305 +#define _loop0_31_type 1306 +#define _loop1_32_type 1307 +#define _loop0_33_type 1308 +#define _gather_34_type 1309 +#define _tmp_35_type 1310 +#define _loop1_36_type 1311 +#define _loop1_37_type 1312 +#define _loop1_38_type 1313 +#define _loop0_39_type 1314 +#define _gather_40_type 1315 +#define _tmp_41_type 1316 +#define _tmp_42_type 1317 +#define _tmp_43_type 1318 +#define _loop0_44_type 1319 +#define _gather_45_type 1320 +#define _loop0_46_type 1321 +#define _gather_47_type 1322 +#define _tmp_48_type 1323 +#define _loop0_49_type 1324 +#define _gather_50_type 1325 +#define _loop0_51_type 1326 +#define _gather_52_type 1327 +#define _loop0_53_type 1328 +#define _gather_54_type 1329 +#define _loop1_55_type 1330 +#define _loop1_56_type 1331 +#define _loop0_57_type 1332 +#define _gather_58_type 1333 +#define _loop0_59_type 1334 +#define _gather_60_type 1335 +#define _loop1_61_type 1336 +#define _loop1_62_type 1337 +#define _loop1_63_type 1338 +#define _tmp_64_type 1339 +#define _loop0_65_type 1340 +#define _gather_66_type 1341 +#define _tmp_67_type 1342 +#define _tmp_68_type 1343 +#define _tmp_69_type 1344 +#define _tmp_70_type 1345 +#define _tmp_71_type 1346 +#define _loop0_72_type 1347 +#define _loop0_73_type 1348 +#define _loop1_74_type 1349 +#define _loop1_75_type 1350 +#define _loop0_76_type 1351 +#define _loop1_77_type 1352 +#define _loop0_78_type 1353 +#define _loop0_79_type 1354 +#define _loop0_80_type 1355 +#define _loop0_81_type 1356 +#define _loop1_82_type 1357 +#define _loop1_83_type 1358 +#define _tmp_84_type 1359 +#define _loop0_85_type 1360 +#define _gather_86_type 1361 +#define _loop1_87_type 1362 +#define _loop0_88_type 1363 +#define _tmp_89_type 1364 +#define _loop0_90_type 1365 +#define _gather_91_type 1366 +#define _tmp_92_type 1367 +#define _loop0_93_type 1368 +#define _gather_94_type 1369 +#define _loop0_95_type 1370 +#define _gather_96_type 1371 +#define _loop0_97_type 1372 +#define _loop0_98_type 1373 +#define _gather_99_type 1374 +#define _loop1_100_type 1375 +#define _tmp_101_type 1376 +#define _loop0_102_type 1377 +#define _gather_103_type 1378 +#define _loop0_104_type 1379 +#define _gather_105_type 1380 +#define _tmp_106_type 1381 +#define _tmp_107_type 1382 +#define _loop0_108_type 1383 +#define _gather_109_type 1384 +#define _tmp_110_type 1385 +#define _tmp_111_type 1386 +#define _tmp_112_type 1387 +#define _tmp_113_type 1388 +#define _tmp_114_type 1389 +#define _loop1_115_type 1390 +#define _tmp_116_type 1391 +#define _tmp_117_type 1392 +#define _tmp_118_type 1393 +#define _tmp_119_type 1394 +#define _tmp_120_type 1395 +#define _loop0_121_type 1396 +#define _loop0_122_type 1397 +#define _tmp_123_type 1398 +#define _tmp_124_type 1399 +#define _tmp_125_type 1400 +#define _tmp_126_type 1401 +#define _tmp_127_type 1402 +#define _tmp_128_type 1403 +#define _tmp_129_type 1404 +#define _tmp_130_type 1405 +#define _loop0_131_type 1406 +#define _gather_132_type 1407 +#define _tmp_133_type 1408 +#define _tmp_134_type 1409 +#define _tmp_135_type 1410 +#define _tmp_136_type 1411 +#define _loop0_137_type 1412 +#define _gather_138_type 1413 +#define _tmp_139_type 1414 +#define _loop0_140_type 1415 +#define _gather_141_type 1416 +#define _loop0_142_type 1417 +#define _gather_143_type 1418 +#define _tmp_144_type 1419 +#define _loop0_145_type 1420 +#define _tmp_146_type 1421 +#define _tmp_147_type 1422 +#define _tmp_148_type 1423 +#define _tmp_149_type 1424 +#define _tmp_150_type 1425 +#define _tmp_151_type 1426 +#define _tmp_152_type 1427 +#define _tmp_153_type 1428 +#define _tmp_154_type 1429 +#define _tmp_155_type 1430 +#define _tmp_156_type 1431 +#define _tmp_157_type 1432 +#define _tmp_158_type 1433 +#define _tmp_159_type 1434 +#define _tmp_160_type 1435 +#define _tmp_161_type 1436 +#define _tmp_162_type 1437 +#define _tmp_163_type 1438 +#define _tmp_164_type 1439 +#define _tmp_165_type 1440 +#define _tmp_166_type 1441 +#define _tmp_167_type 1442 +#define _tmp_168_type 1443 +#define _tmp_169_type 1444 +#define _tmp_170_type 1445 +#define _tmp_171_type 1446 +#define _tmp_172_type 1447 +#define _tmp_173_type 1448 +#define _loop0_174_type 1449 +#define _tmp_175_type 1450 +#define _tmp_176_type 1451 +#define _tmp_177_type 1452 +#define _tmp_178_type 1453 +#define _tmp_179_type 1454 +#define _tmp_180_type 1455 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -644,11 +652,14 @@ static expr_ty type_param_default_rule(Parser *p); static expr_ty type_param_starred_default_rule(Parser *p); static expr_ty expressions_rule(Parser *p); static expr_ty expression_rule(Parser *p); +static expr_ty if_expression_rule(Parser *p); static expr_ty yield_expr_rule(Parser *p); static expr_ty star_expressions_rule(Parser *p); static expr_ty star_expression_rule(Parser *p); static asdl_expr_seq* star_named_expressions_rule(Parser *p); +static asdl_expr_seq* star_named_expressions_sequence_rule(Parser *p); static expr_ty star_named_expression_rule(Parser *p); +static expr_ty star_named_expression_sequence_rule(Parser *p); static expr_ty assignment_expression_rule(Parser *p); static expr_ty named_expression_rule(Parser *p); static expr_ty disjunction_rule(Parser *p); @@ -745,6 +756,7 @@ static expr_ty expression_without_invalid_rule(Parser *p); static void *invalid_legacy_expression_rule(Parser *p); static void *invalid_type_param_rule(Parser *p); static void *invalid_expression_rule(Parser *p); +static void *invalid_if_expression_rule(Parser *p); static void *invalid_named_expression_rule(Parser *p); static void *invalid_assignment_rule(Parser *p); static expr_ty invalid_ann_assign_target_rule(Parser *p); @@ -753,7 +765,6 @@ static void *invalid_del_stmt_rule(Parser *p); static void *invalid_assert_stmt_rule(Parser *p); static void *invalid_block_rule(Parser *p); static void *invalid_comprehension_rule(Parser *p); -static void *invalid_dict_comprehension_rule(Parser *p); static void *invalid_parameters_rule(Parser *p); static void *invalid_default_rule(Parser *p); static void *invalid_star_etc_rule(Parser *p); @@ -794,8 +805,10 @@ static void *invalid_for_stmt_rule(Parser *p); static void *invalid_def_raw_rule(Parser *p); static void *invalid_class_def_raw_rule(Parser *p); static void *invalid_double_starred_kvpairs_rule(Parser *p); +static void *invalid_kvpair_unpacking_rule(Parser *p); static void *invalid_kvpair_rule(Parser *p); static void *invalid_starred_expression_unpacking_rule(Parser *p); +static void *invalid_starred_expression_unpacking_sequence_rule(Parser *p); static void *invalid_starred_expression_rule(Parser *p); static void *invalid_fstring_replacement_field_rule(Parser *p); static void *invalid_fstring_conversion_character_rule(Parser *p); @@ -863,70 +876,70 @@ static asdl_seq *_loop1_55_rule(Parser *p); static asdl_seq *_loop1_56_rule(Parser *p); static asdl_seq *_loop0_57_rule(Parser *p); static asdl_seq *_gather_58_rule(Parser *p); -static asdl_seq *_loop1_59_rule(Parser *p); -static asdl_seq *_loop1_60_rule(Parser *p); +static asdl_seq *_loop0_59_rule(Parser *p); +static asdl_seq *_gather_60_rule(Parser *p); static asdl_seq *_loop1_61_rule(Parser *p); -static void *_tmp_62_rule(Parser *p); -static asdl_seq *_loop0_63_rule(Parser *p); -static asdl_seq *_gather_64_rule(Parser *p); -static void *_tmp_65_rule(Parser *p); -static void *_tmp_66_rule(Parser *p); +static asdl_seq *_loop1_62_rule(Parser *p); +static asdl_seq *_loop1_63_rule(Parser *p); +static void *_tmp_64_rule(Parser *p); +static asdl_seq *_loop0_65_rule(Parser *p); +static asdl_seq *_gather_66_rule(Parser *p); static void *_tmp_67_rule(Parser *p); static void *_tmp_68_rule(Parser *p); static void *_tmp_69_rule(Parser *p); -static asdl_seq *_loop0_70_rule(Parser *p); -static asdl_seq *_loop0_71_rule(Parser *p); -static asdl_seq *_loop1_72_rule(Parser *p); -static asdl_seq *_loop1_73_rule(Parser *p); -static asdl_seq *_loop0_74_rule(Parser *p); +static void *_tmp_70_rule(Parser *p); +static void *_tmp_71_rule(Parser *p); +static asdl_seq *_loop0_72_rule(Parser *p); +static asdl_seq *_loop0_73_rule(Parser *p); +static asdl_seq *_loop1_74_rule(Parser *p); static asdl_seq *_loop1_75_rule(Parser *p); static asdl_seq *_loop0_76_rule(Parser *p); -static asdl_seq *_loop0_77_rule(Parser *p); +static asdl_seq *_loop1_77_rule(Parser *p); static asdl_seq *_loop0_78_rule(Parser *p); static asdl_seq *_loop0_79_rule(Parser *p); -static asdl_seq *_loop1_80_rule(Parser *p); -static asdl_seq *_loop1_81_rule(Parser *p); -static void *_tmp_82_rule(Parser *p); -static asdl_seq *_loop0_83_rule(Parser *p); -static asdl_seq *_gather_84_rule(Parser *p); -static asdl_seq *_loop1_85_rule(Parser *p); -static asdl_seq *_loop0_86_rule(Parser *p); -static void *_tmp_87_rule(Parser *p); +static asdl_seq *_loop0_80_rule(Parser *p); +static asdl_seq *_loop0_81_rule(Parser *p); +static asdl_seq *_loop1_82_rule(Parser *p); +static asdl_seq *_loop1_83_rule(Parser *p); +static void *_tmp_84_rule(Parser *p); +static asdl_seq *_loop0_85_rule(Parser *p); +static asdl_seq *_gather_86_rule(Parser *p); +static asdl_seq *_loop1_87_rule(Parser *p); static asdl_seq *_loop0_88_rule(Parser *p); -static asdl_seq *_gather_89_rule(Parser *p); -static void *_tmp_90_rule(Parser *p); -static asdl_seq *_loop0_91_rule(Parser *p); -static asdl_seq *_gather_92_rule(Parser *p); +static void *_tmp_89_rule(Parser *p); +static asdl_seq *_loop0_90_rule(Parser *p); +static asdl_seq *_gather_91_rule(Parser *p); +static void *_tmp_92_rule(Parser *p); static asdl_seq *_loop0_93_rule(Parser *p); static asdl_seq *_gather_94_rule(Parser *p); static asdl_seq *_loop0_95_rule(Parser *p); -static asdl_seq *_loop0_96_rule(Parser *p); -static asdl_seq *_gather_97_rule(Parser *p); -static asdl_seq *_loop1_98_rule(Parser *p); -static void *_tmp_99_rule(Parser *p); -static asdl_seq *_loop0_100_rule(Parser *p); -static asdl_seq *_gather_101_rule(Parser *p); +static asdl_seq *_gather_96_rule(Parser *p); +static asdl_seq *_loop0_97_rule(Parser *p); +static asdl_seq *_loop0_98_rule(Parser *p); +static asdl_seq *_gather_99_rule(Parser *p); +static asdl_seq *_loop1_100_rule(Parser *p); +static void *_tmp_101_rule(Parser *p); static asdl_seq *_loop0_102_rule(Parser *p); static asdl_seq *_gather_103_rule(Parser *p); -static void *_tmp_104_rule(Parser *p); -static void *_tmp_105_rule(Parser *p); -static asdl_seq *_loop0_106_rule(Parser *p); -static asdl_seq *_gather_107_rule(Parser *p); -static void *_tmp_108_rule(Parser *p); -static void *_tmp_109_rule(Parser *p); +static asdl_seq *_loop0_104_rule(Parser *p); +static asdl_seq *_gather_105_rule(Parser *p); +static void *_tmp_106_rule(Parser *p); +static void *_tmp_107_rule(Parser *p); +static asdl_seq *_loop0_108_rule(Parser *p); +static asdl_seq *_gather_109_rule(Parser *p); static void *_tmp_110_rule(Parser *p); static void *_tmp_111_rule(Parser *p); static void *_tmp_112_rule(Parser *p); -static asdl_seq *_loop1_113_rule(Parser *p); +static void *_tmp_113_rule(Parser *p); static void *_tmp_114_rule(Parser *p); -static void *_tmp_115_rule(Parser *p); +static asdl_seq *_loop1_115_rule(Parser *p); static void *_tmp_116_rule(Parser *p); static void *_tmp_117_rule(Parser *p); static void *_tmp_118_rule(Parser *p); -static asdl_seq *_loop0_119_rule(Parser *p); -static asdl_seq *_loop0_120_rule(Parser *p); -static void *_tmp_121_rule(Parser *p); -static void *_tmp_122_rule(Parser *p); +static void *_tmp_119_rule(Parser *p); +static void *_tmp_120_rule(Parser *p); +static asdl_seq *_loop0_121_rule(Parser *p); +static asdl_seq *_loop0_122_rule(Parser *p); static void *_tmp_123_rule(Parser *p); static void *_tmp_124_rule(Parser *p); static void *_tmp_125_rule(Parser *p); @@ -934,22 +947,22 @@ static void *_tmp_126_rule(Parser *p); static void *_tmp_127_rule(Parser *p); static void *_tmp_128_rule(Parser *p); static void *_tmp_129_rule(Parser *p); -static asdl_seq *_loop0_130_rule(Parser *p); -static asdl_seq *_gather_131_rule(Parser *p); -static void *_tmp_132_rule(Parser *p); +static void *_tmp_130_rule(Parser *p); +static asdl_seq *_loop0_131_rule(Parser *p); +static asdl_seq *_gather_132_rule(Parser *p); static void *_tmp_133_rule(Parser *p); static void *_tmp_134_rule(Parser *p); static void *_tmp_135_rule(Parser *p); -static asdl_seq *_loop0_136_rule(Parser *p); -static asdl_seq *_gather_137_rule(Parser *p); -static void *_tmp_138_rule(Parser *p); -static asdl_seq *_loop0_139_rule(Parser *p); -static asdl_seq *_gather_140_rule(Parser *p); -static asdl_seq *_loop0_141_rule(Parser *p); -static asdl_seq *_gather_142_rule(Parser *p); -static void *_tmp_143_rule(Parser *p); -static asdl_seq *_loop0_144_rule(Parser *p); -static void *_tmp_145_rule(Parser *p); +static void *_tmp_136_rule(Parser *p); +static asdl_seq *_loop0_137_rule(Parser *p); +static asdl_seq *_gather_138_rule(Parser *p); +static void *_tmp_139_rule(Parser *p); +static asdl_seq *_loop0_140_rule(Parser *p); +static asdl_seq *_gather_141_rule(Parser *p); +static asdl_seq *_loop0_142_rule(Parser *p); +static asdl_seq *_gather_143_rule(Parser *p); +static void *_tmp_144_rule(Parser *p); +static asdl_seq *_loop0_145_rule(Parser *p); static void *_tmp_146_rule(Parser *p); static void *_tmp_147_rule(Parser *p); static void *_tmp_148_rule(Parser *p); @@ -976,12 +989,15 @@ static void *_tmp_168_rule(Parser *p); static void *_tmp_169_rule(Parser *p); static void *_tmp_170_rule(Parser *p); static void *_tmp_171_rule(Parser *p); -static asdl_seq *_loop0_172_rule(Parser *p); +static void *_tmp_172_rule(Parser *p); static void *_tmp_173_rule(Parser *p); -static void *_tmp_174_rule(Parser *p); +static asdl_seq *_loop0_174_rule(Parser *p); static void *_tmp_175_rule(Parser *p); static void *_tmp_176_rule(Parser *p); static void *_tmp_177_rule(Parser *p); +static void *_tmp_178_rule(Parser *p); +static void *_tmp_179_rule(Parser *p); +static void *_tmp_180_rule(Parser *p); // file: statements? $ @@ -1709,7 +1725,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt")); stmt_ty raise_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 628) // token='raise' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 632) // token='raise' && (raise_stmt_var = raise_stmt_rule(p)) // raise_stmt ) @@ -1751,7 +1767,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt")); stmt_ty del_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 630) // token='del' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 634) // token='del' && (del_stmt_var = del_stmt_rule(p)) // del_stmt ) @@ -1793,7 +1809,7 @@ simple_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt")); stmt_ty assert_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 634) // token='assert' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 638) // token='assert' && (assert_stmt_var = assert_stmt_rule(p)) // assert_stmt ) @@ -1947,7 +1963,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt")); stmt_ty if_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 691) // token='if' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 695) // token='if' && (if_stmt_var = if_stmt_rule(p)) // if_stmt ) @@ -2031,7 +2047,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt")); stmt_ty try_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 665) // token='try' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 669) // token='try' && (try_stmt_var = try_stmt_rule(p)) // try_stmt ) @@ -2052,7 +2068,7 @@ compound_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt")); stmt_ty while_stmt_var; if ( - _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 698) // token='while' + _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 702) // token='while' && (while_stmt_var = while_stmt_rule(p)) // while_stmt ) @@ -2815,11 +2831,11 @@ raise_stmt_rule(Parser *p) expr_ty a; expr_ty b; if ( - (_keyword = _PyPegen_expect_token(p, 628)) // token='raise' + (_keyword = _PyPegen_expect_token(p, 632)) // token='raise' && (a = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 642)) // token='from' + (_keyword_1 = _PyPegen_expect_token(p, 646)) // token='from' && (b = expression_rule(p)) // expression ) @@ -2874,7 +2890,7 @@ raise_stmt_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 628)) // token='raise' + (_keyword = _PyPegen_expect_token(p, 632)) // token='raise' && (a = expression_rule(p)) // expression ) @@ -2909,7 +2925,7 @@ raise_stmt_rule(Parser *p) D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 628)) // token='raise' + (_keyword = _PyPegen_expect_token(p, 632)) // token='raise' ) { D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise'")); @@ -3282,7 +3298,7 @@ del_stmt_rule(Parser *p) Token * _keyword; asdl_expr_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 630)) // token='del' + (_keyword = _PyPegen_expect_token(p, 634)) // token='del' && (a = del_targets_rule(p)) // del_targets && @@ -3448,7 +3464,7 @@ assert_stmt_rule(Parser *p) expr_ty a; void *b; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='assert' + (_keyword = _PyPegen_expect_token(p, 638)) // token='assert' && (a = expression_rule(p)) // expression && @@ -3590,7 +3606,7 @@ import_name_rule(Parser *p) Token * _keyword; asdl_alias_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 643)) // token='import' + (_keyword = _PyPegen_expect_token(p, 647)) // token='import' && (a = dotted_as_names_rule(p)) // dotted_as_names ) @@ -3659,13 +3675,13 @@ import_from_rule(Parser *p) expr_ty b; asdl_alias_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 642)) // token='from' + (_keyword = _PyPegen_expect_token(p, 646)) // token='from' && (a = _loop0_17_rule(p)) // (('.' | '...'))* && (b = dotted_name_rule(p)) // dotted_name && - (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='import' + (_keyword_1 = _PyPegen_expect_token(p, 647)) // token='import' && (c = import_from_targets_rule(p)) // import_from_targets ) @@ -3703,11 +3719,11 @@ import_from_rule(Parser *p) asdl_seq * a; asdl_alias_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 642)) // token='from' + (_keyword = _PyPegen_expect_token(p, 646)) // token='from' && (a = _loop1_18_rule(p)) // (('.' | '...'))+ && - (_keyword_1 = _PyPegen_expect_token(p, 643)) // token='import' + (_keyword_1 = _PyPegen_expect_token(p, 647)) // token='import' && (b = import_from_targets_rule(p)) // import_from_targets ) @@ -4494,7 +4510,7 @@ class_def_raw_rule(Parser *p) asdl_stmt_seq* c; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 710)) // token='class' + (_keyword = _PyPegen_expect_token(p, 714)) // token='class' && (a = _PyPegen_name_token(p)) // NAME && @@ -4661,7 +4677,7 @@ function_def_raw_rule(Parser *p) void *t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 708)) // token='def' + (_keyword = _PyPegen_expect_token(p, 712)) // token='def' && (n = _PyPegen_name_token(p)) // NAME && @@ -4722,9 +4738,9 @@ function_def_raw_rule(Parser *p) void *t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='async' + (_keyword = _PyPegen_expect_token(p, 711)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 708)) // token='def' + (_keyword_1 = _PyPegen_expect_token(p, 712)) // token='def' && (n = _PyPegen_name_token(p)) // NAME && @@ -6062,7 +6078,7 @@ if_stmt_rule(Parser *p) asdl_stmt_seq* b; stmt_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (a = named_expression_rule(p)) // named_expression && @@ -6107,7 +6123,7 @@ if_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (a = named_expression_rule(p)) // named_expression && @@ -6202,7 +6218,7 @@ elif_stmt_rule(Parser *p) asdl_stmt_seq* b; stmt_ty c; if ( - (_keyword = _PyPegen_expect_token(p, 696)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 700)) // token='elif' && (a = named_expression_rule(p)) // named_expression && @@ -6247,7 +6263,7 @@ elif_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 696)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 700)) // token='elif' && (a = named_expression_rule(p)) // named_expression && @@ -6328,7 +6344,7 @@ else_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 695)) // token='else' + (_keyword = _PyPegen_expect_token(p, 699)) // token='else' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -6407,7 +6423,7 @@ while_stmt_rule(Parser *p) asdl_stmt_seq* b; void *c; if ( - (_keyword = _PyPegen_expect_token(p, 698)) // token='while' + (_keyword = _PyPegen_expect_token(p, 702)) // token='while' && (a = named_expression_rule(p)) // named_expression && @@ -6507,11 +6523,11 @@ for_stmt_rule(Parser *p) expr_ty t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 703)) // token='for' + (_keyword = _PyPegen_expect_token(p, 707)) // token='for' && (t = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 704)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 708)) // token='in' && (_cut_var = 1) && @@ -6569,13 +6585,13 @@ for_stmt_rule(Parser *p) expr_ty t; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='async' + (_keyword = _PyPegen_expect_token(p, 711)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 703)) // token='for' + (_keyword_1 = _PyPegen_expect_token(p, 707)) // token='for' && (t = star_targets_rule(p)) // star_targets && - (_keyword_2 = _PyPegen_expect_token(p, 704)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 708)) // token='in' && (_cut_var = 1) && @@ -6704,7 +6720,7 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='with' + (_keyword = _PyPegen_expect_token(p, 660)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -6755,7 +6771,7 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='with' + (_keyword = _PyPegen_expect_token(p, 660)) // token='with' && (a = (asdl_withitem_seq*)_gather_34_rule(p)) // ','.with_item+ && @@ -6804,9 +6820,9 @@ with_stmt_rule(Parser *p) asdl_withitem_seq* a; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='async' + (_keyword = _PyPegen_expect_token(p, 711)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 656)) // token='with' + (_keyword_1 = _PyPegen_expect_token(p, 660)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && @@ -6856,9 +6872,9 @@ with_stmt_rule(Parser *p) asdl_stmt_seq* b; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='async' + (_keyword = _PyPegen_expect_token(p, 711)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 656)) // token='with' + (_keyword_1 = _PyPegen_expect_token(p, 660)) // token='with' && (a = (asdl_withitem_seq*)_gather_34_rule(p)) // ','.with_item+ && @@ -6944,7 +6960,7 @@ with_item_rule(Parser *p) if ( (e = expression_rule(p)) // expression && - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && (t = star_target_rule(p)) // star_target && @@ -7069,7 +7085,7 @@ try_stmt_rule(Parser *p) asdl_stmt_seq* b; asdl_stmt_seq* f; if ( - (_keyword = _PyPegen_expect_token(p, 665)) // token='try' + (_keyword = _PyPegen_expect_token(p, 669)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -7113,7 +7129,7 @@ try_stmt_rule(Parser *p) asdl_excepthandler_seq* ex; void *f; if ( - (_keyword = _PyPegen_expect_token(p, 665)) // token='try' + (_keyword = _PyPegen_expect_token(p, 669)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -7161,7 +7177,7 @@ try_stmt_rule(Parser *p) asdl_excepthandler_seq* ex; void *f; if ( - (_keyword = _PyPegen_expect_token(p, 665)) // token='try' + (_keyword = _PyPegen_expect_token(p, 669)) // token='try' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -7260,7 +7276,7 @@ except_block_rule(Parser *p) asdl_stmt_seq* b; expr_ty e; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (e = expression_rule(p)) // expression && @@ -7304,11 +7320,11 @@ except_block_rule(Parser *p) expr_ty e; expr_ty t; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (e = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 693)) // token='as' && (t = _PyPegen_name_token(p)) // NAME && @@ -7350,7 +7366,7 @@ except_block_rule(Parser *p) asdl_stmt_seq* b; expr_ty e; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (e = expressions_rule(p)) // expressions && @@ -7391,7 +7407,7 @@ except_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -7503,7 +7519,7 @@ except_star_block_rule(Parser *p) asdl_stmt_seq* b; expr_ty e; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -7550,13 +7566,13 @@ except_star_block_rule(Parser *p) expr_ty e; expr_ty t; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && (e = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 693)) // token='as' && (t = _PyPegen_name_token(p)) // NAME && @@ -7599,7 +7615,7 @@ except_star_block_rule(Parser *p) asdl_stmt_seq* b; expr_ty e; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -7699,7 +7715,7 @@ finally_block_rule(Parser *p) Token * _literal; asdl_stmt_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 682)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 686)) // token='finally' && (_literal = _PyPegen_expect_forced_token(p, 11, ":")) // forced_token=':' && @@ -8007,7 +8023,7 @@ guard_rule(Parser *p) Token * _keyword; expr_ty guard; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (guard = named_expression_rule(p)) // named_expression ) @@ -8202,7 +8218,7 @@ as_pattern_rule(Parser *p) if ( (pattern = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && (target = pattern_capture_target_rule(p)) // pattern_capture_target ) @@ -8636,7 +8652,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 624)) // token='None' + (_keyword = _PyPegen_expect_token(p, 628)) // token='None' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); @@ -8669,7 +8685,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 623)) // token='True' + (_keyword = _PyPegen_expect_token(p, 627)) // token='True' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); @@ -8702,7 +8718,7 @@ literal_pattern_rule(Parser *p) D(fprintf(stderr, "%*c> literal_pattern[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 625)) // token='False' + (_keyword = _PyPegen_expect_token(p, 629)) // token='False' ) { D(fprintf(stderr, "%*c+ literal_pattern[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); @@ -8830,7 +8846,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 624)) // token='None' + (_keyword = _PyPegen_expect_token(p, 628)) // token='None' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); @@ -8863,7 +8879,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 623)) // token='True' + (_keyword = _PyPegen_expect_token(p, 627)) // token='True' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); @@ -8896,7 +8912,7 @@ literal_expr_rule(Parser *p) D(fprintf(stderr, "%*c> literal_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 625)) // token='False' + (_keyword = _PyPegen_expect_token(p, 629)) // token='False' ) { D(fprintf(stderr, "%*c+ literal_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); @@ -11437,9 +11453,10 @@ expressions_rule(Parser *p) } // expression: +// | invalid_if_expression // | invalid_expression // | invalid_legacy_expression -// | disjunction 'if' disjunction 'else' expression +// | if_expression // | disjunction // | lambdef static expr_ty @@ -11458,15 +11475,25 @@ 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; + if (p->call_invalid_rules) { // invalid_if_expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_if_expression")); + void *invalid_if_expression_var; + if ( + (invalid_if_expression_var = invalid_if_expression_rule(p)) // invalid_if_expression + ) + { + D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_if_expression")); + _res = invalid_if_expression_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_if_expression")); } - int _start_lineno = p->tokens[_mark]->lineno; - 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 if (p->call_invalid_rules) { // invalid_expression if (p->error_indicator) { p->level--; @@ -11505,50 +11532,24 @@ 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")); } - { // disjunction 'if' disjunction 'else' expression + { // if_expression if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); - Token * _keyword; - Token * _keyword_1; - expr_ty a; - expr_ty b; - expr_ty c; + D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "if_expression")); + expr_ty if_expression_var; if ( - (a = disjunction_rule(p)) // disjunction - && - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' - && - (b = disjunction_rule(p)) // disjunction - && - (_keyword_1 = _PyPegen_expect_token(p, 695)) // token='else' - && - (c = expression_rule(p)) // expression + (if_expression_var = if_expression_rule(p)) // if_expression ) { - D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); - Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); - if (_token == NULL) { - p->level--; - return NULL; - } - int _end_lineno = _token->end_lineno; - UNUSED(_end_lineno); // Only used by EXTRA macro - int _end_col_offset = _token->end_col_offset; - UNUSED(_end_col_offset); // Only used by EXTRA macro - _res = _PyAST_IfExp ( b , a , c , EXTRA ); - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - p->level--; - return NULL; - } + D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "if_expression")); + _res = if_expression_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "if_expression")); } { // disjunction if (p->error_indicator) { @@ -11595,6 +11596,79 @@ expression_rule(Parser *p) return _res; } +// if_expression: disjunction 'if' disjunction 'else' expression +static expr_ty +if_expression_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + 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 _start_lineno = p->tokens[_mark]->lineno; + 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 + { // disjunction 'if' disjunction 'else' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> if_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); + Token * _keyword; + Token * _keyword_1; + expr_ty a; + expr_ty b; + expr_ty c; + if ( + (a = disjunction_rule(p)) // disjunction + && + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' + && + (b = disjunction_rule(p)) // disjunction + && + (_keyword_1 = _PyPegen_expect_token(p, 699)) // token='else' + && + (c = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ if_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_IfExp ( b , a , c , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s if_expression[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // yield_expr: 'yield' 'from' expression | 'yield' star_expressions? static expr_ty yield_expr_rule(Parser *p) @@ -11629,7 +11703,7 @@ yield_expr_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 588)) // token='yield' && - (_keyword_1 = _PyPegen_expect_token(p, 642)) // token='from' + (_keyword_1 = _PyPegen_expect_token(p, 646)) // token='from' && (a = expression_rule(p)) // expression ) @@ -11959,6 +12033,53 @@ star_named_expressions_rule(Parser *p) return _res; } +// star_named_expressions_sequence: ','.star_named_expression_sequence+ ','? +static asdl_expr_seq* +star_named_expressions_sequence_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_expr_seq* _res = NULL; + int _mark = p->mark; + { // ','.star_named_expression_sequence+ ','? + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> star_named_expressions_sequence[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_named_expression_sequence+ ','?")); + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + asdl_expr_seq* a; + if ( + (a = (asdl_expr_seq*)_gather_60_rule(p)) // ','.star_named_expression_sequence+ + && + (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? + ) + { + D(fprintf(stderr, "%*c+ star_named_expressions_sequence[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_named_expression_sequence+ ','?")); + _res = a; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s star_named_expressions_sequence[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_named_expression_sequence+ ','?")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // star_named_expression: '*' bitwise_or | named_expression static expr_ty star_named_expression_rule(Parser *p) @@ -12042,6 +12163,65 @@ star_named_expression_rule(Parser *p) return _res; } +// star_named_expression_sequence: +// | invalid_starred_expression_unpacking_sequence +// | star_named_expression +static expr_ty +star_named_expression_sequence_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + expr_ty _res = NULL; + int _mark = p->mark; + if (p->call_invalid_rules) { // invalid_starred_expression_unpacking_sequence + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> star_named_expression_sequence[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_starred_expression_unpacking_sequence")); + void *invalid_starred_expression_unpacking_sequence_var; + if ( + (invalid_starred_expression_unpacking_sequence_var = invalid_starred_expression_unpacking_sequence_rule(p)) // invalid_starred_expression_unpacking_sequence + ) + { + D(fprintf(stderr, "%*c+ star_named_expression_sequence[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_starred_expression_unpacking_sequence")); + _res = invalid_starred_expression_unpacking_sequence_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s star_named_expression_sequence[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_starred_expression_unpacking_sequence")); + } + { // star_named_expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> star_named_expression_sequence[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression")); + expr_ty star_named_expression_var; + if ( + (star_named_expression_var = star_named_expression_rule(p)) // star_named_expression + ) + { + D(fprintf(stderr, "%*c+ star_named_expression_sequence[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression")); + _res = star_named_expression_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s star_named_expression_sequence[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // assignment_expression: NAME ':=' ~ expression static expr_ty assignment_expression_rule(Parser *p) @@ -12231,7 +12411,7 @@ disjunction_rule(Parser *p) if ( (a = conjunction_rule(p)) // conjunction && - (b = _loop1_59_rule(p)) // (('or' conjunction))+ + (b = _loop1_61_rule(p)) // (('or' conjunction))+ ) { D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+")); @@ -12319,7 +12499,7 @@ conjunction_rule(Parser *p) if ( (a = inversion_rule(p)) // inversion && - (b = _loop1_60_rule(p)) // (('and' inversion))+ + (b = _loop1_62_rule(p)) // (('and' inversion))+ ) { D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+")); @@ -12405,7 +12585,7 @@ inversion_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 712)) // token='not' + (_keyword = _PyPegen_expect_token(p, 716)) // token='not' && (a = inversion_rule(p)) // inversion ) @@ -12491,7 +12671,7 @@ comparison_rule(Parser *p) if ( (a = bitwise_or_rule(p)) // bitwise_or && - (b = _loop1_61_rule(p)) // compare_op_bitwise_or_pair+ + (b = _loop1_63_rule(p)) // compare_op_bitwise_or_pair+ ) { D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); @@ -12825,10 +13005,10 @@ noteq_bitwise_or_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or")); - void *_tmp_62_var; + void *_tmp_64_var; expr_ty a; if ( - (_tmp_62_var = _tmp_62_rule(p)) // '!=' + (_tmp_64_var = _tmp_64_rule(p)) // '!=' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -13059,9 +13239,9 @@ notin_bitwise_or_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 712)) // token='not' + (_keyword = _PyPegen_expect_token(p, 716)) // token='not' && - (_keyword_1 = _PyPegen_expect_token(p, 704)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 708)) // token='in' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -13107,7 +13287,7 @@ in_bitwise_or_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 704)) // token='in' + (_keyword = _PyPegen_expect_token(p, 708)) // token='in' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -13156,7 +13336,7 @@ isnot_bitwise_or_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 597)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 712)) // token='not' + (_keyword_1 = _PyPegen_expect_token(p, 716)) // token='not' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -14876,7 +15056,7 @@ slices_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_64_rule(p)) // ','.(slice | starred_expression)+ + (a = (asdl_expr_seq*)_gather_66_rule(p)) // ','.(slice | starred_expression)+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -14948,7 +15128,7 @@ slice_rule(Parser *p) && (b = expression_rule(p), !p->error_indicator) // expression? && - (c = _tmp_65_rule(p), !p->error_indicator) // [':' expression?] + (c = _tmp_67_rule(p), !p->error_indicator) // [':' expression?] ) { D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]")); @@ -15010,9 +15190,9 @@ slice_rule(Parser *p) // | 'None' // | &(STRING | FSTRING_START | TSTRING_START) strings // | NUMBER -// | &'(' (tuple | group | genexp) -// | &'[' (list | listcomp) -// | &'{' (dict | set | dictcomp | setcomp) +// | &'(' (genexp | tuple | group) +// | &'[' (listcomp | list) +// | &'{' (dictcomp | setcomp | dict | set) // | '...' static expr_ty atom_rule(Parser *p) @@ -15062,7 +15242,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 623)) // token='True' + (_keyword = _PyPegen_expect_token(p, 627)) // token='True' ) { D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); @@ -15095,7 +15275,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 625)) // token='False' + (_keyword = _PyPegen_expect_token(p, 629)) // token='False' ) { D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); @@ -15128,7 +15308,7 @@ atom_rule(Parser *p) D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 624)) // token='None' + (_keyword = _PyPegen_expect_token(p, 628)) // token='None' ) { D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); @@ -15193,68 +15373,68 @@ 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")); } - { // &'(' (tuple | group | genexp) + { // &'(' (genexp | tuple | group) if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)")); - void *_tmp_66_var; + D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (genexp | tuple | group)")); + void *_tmp_68_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='(' && - (_tmp_66_var = _tmp_66_rule(p)) // tuple | group | genexp + (_tmp_68_var = _tmp_68_rule(p)) // genexp | tuple | group ) { - D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)")); - _res = _tmp_66_var; + D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (genexp | tuple | group)")); + _res = _tmp_68_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (tuple | group | genexp)")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (genexp | tuple | group)")); } - { // &'[' (list | listcomp) + { // &'[' (listcomp | list) if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)")); - void *_tmp_67_var; + D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (listcomp | list)")); + void *_tmp_69_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='[' && - (_tmp_67_var = _tmp_67_rule(p)) // list | listcomp + (_tmp_69_var = _tmp_69_rule(p)) // listcomp | list ) { - D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)")); - _res = _tmp_67_var; + D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (listcomp | list)")); + _res = _tmp_69_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (list | listcomp)")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (listcomp | list)")); } - { // &'{' (dict | set | dictcomp | setcomp) + { // &'{' (dictcomp | setcomp | dict | set) if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); - void *_tmp_68_var; + D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dictcomp | setcomp | dict | set)")); + void *_tmp_70_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{' && - (_tmp_68_var = _tmp_68_rule(p)) // dict | set | dictcomp | setcomp + (_tmp_70_var = _tmp_70_rule(p)) // dictcomp | setcomp | dict | set ) { - D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); - _res = _tmp_68_var; + D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dictcomp | setcomp | dict | set)")); + _res = _tmp_70_var; goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dictcomp | setcomp | dict | set)")); } { // '...' if (p->error_indicator) { @@ -15320,7 +15500,7 @@ group_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_69_rule(p)) // yield_expr | named_expression + (a = _tmp_71_rule(p)) // yield_expr | named_expression && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -15521,9 +15701,9 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default && - (b = (asdl_arg_seq*)_loop0_70_rule(p)) // lambda_param_no_default* + (b = (asdl_arg_seq*)_loop0_72_rule(p)) // lambda_param_no_default* && - (c = _loop0_71_rule(p)) // lambda_param_with_default* + (c = _loop0_73_rule(p)) // lambda_param_with_default* && (d = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -15553,7 +15733,7 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default && - (b = _loop0_71_rule(p)) // lambda_param_with_default* + (b = _loop0_73_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -15581,9 +15761,9 @@ lambda_parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = (asdl_arg_seq*)_loop1_72_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_74_rule(p)) // lambda_param_no_default+ && - (b = _loop0_71_rule(p)) // lambda_param_with_default* + (b = _loop0_73_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -15610,7 +15790,7 @@ lambda_parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_73_rule(p)) // lambda_param_with_default+ + (a = _loop1_75_rule(p)) // lambda_param_with_default+ && (b = lambda_star_etc_rule(p), !p->error_indicator) // lambda_star_etc? ) @@ -15683,7 +15863,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal_1; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_72_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_74_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -15712,7 +15892,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal; asdl_arg_seq* a; if ( - (a = (asdl_arg_seq*)_loop1_72_rule(p)) // lambda_param_no_default+ + (a = (asdl_arg_seq*)_loop1_74_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -15764,9 +15944,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_70_rule(p)) // lambda_param_no_default* + (a = _loop0_72_rule(p)) // lambda_param_no_default* && - (b = _loop1_73_rule(p)) // lambda_param_with_default+ + (b = _loop1_75_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -15796,9 +15976,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_70_rule(p)) // lambda_param_no_default* + (a = _loop0_72_rule(p)) // lambda_param_no_default* && - (b = _loop1_73_rule(p)) // lambda_param_with_default+ + (b = _loop1_75_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -15875,7 +16055,7 @@ lambda_star_etc_rule(Parser *p) && (a = lambda_param_no_default_rule(p)) // lambda_param_no_default && - (b = _loop0_74_rule(p)) // lambda_param_maybe_default* + (b = _loop0_76_rule(p)) // lambda_param_maybe_default* && (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? ) @@ -15908,7 +16088,7 @@ lambda_star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_75_rule(p)) // lambda_param_maybe_default+ + (b = _loop1_77_rule(p)) // lambda_param_maybe_default+ && (c = lambda_kwds_rule(p), !p->error_indicator) // lambda_kwds? ) @@ -16548,7 +16728,7 @@ fstring_full_format_spec_rule(Parser *p) if ( (colon = _PyPegen_expect_token(p, 11)) // token=':' && - (spec = _loop0_76_rule(p)) // fstring_format_spec* + (spec = _loop0_78_rule(p)) // fstring_format_spec* ) { D(fprintf(stderr, "%*c+ fstring_full_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' fstring_format_spec*")); @@ -16666,7 +16846,7 @@ fstring_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, FSTRING_START)) // token='FSTRING_START' && - (b = _loop0_77_rule(p)) // fstring_middle* + (b = _loop0_79_rule(p)) // fstring_middle* && (c = _PyPegen_expect_token(p, FSTRING_END)) // token='FSTRING_END' ) @@ -16882,7 +17062,7 @@ tstring_full_format_spec_rule(Parser *p) if ( (colon = _PyPegen_expect_token(p, 11)) // token=':' && - (spec = _loop0_78_rule(p)) // tstring_format_spec* + (spec = _loop0_80_rule(p)) // tstring_format_spec* ) { D(fprintf(stderr, "%*c+ tstring_full_format_spec[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' tstring_format_spec*")); @@ -17101,7 +17281,7 @@ tstring_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, TSTRING_START)) // token='TSTRING_START' && - (b = _loop0_79_rule(p)) // tstring_middle* + (b = _loop0_81_rule(p)) // tstring_middle* && (c = _PyPegen_expect_token(p, TSTRING_END)) // token='TSTRING_END' ) @@ -17222,7 +17402,7 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_80_rule(p)) // ((fstring | string))+ + (a = (asdl_expr_seq*)_loop1_82_rule(p)) // ((fstring | string))+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((fstring | string))+")); @@ -17255,7 +17435,7 @@ strings_rule(Parser *p) D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_loop1_81_rule(p)) // tstring+ + (a = (asdl_expr_seq*)_loop1_83_rule(p)) // tstring+ ) { D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring+")); @@ -17287,7 +17467,7 @@ strings_rule(Parser *p) return _res; } -// list: '[' star_named_expressions? ']' +// list: '[' star_named_expressions_sequence? ']' static expr_ty list_rule(Parser *p) { @@ -17309,24 +17489,24 @@ list_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 - { // '[' star_named_expressions? ']' + { // '[' star_named_expressions_sequence? ']' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'")); + D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions_sequence? ']'")); Token * _literal; Token * _literal_1; void *a; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' && - (a = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? + (a = star_named_expressions_sequence_rule(p), !p->error_indicator) // star_named_expressions_sequence? && (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' ) { - D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'")); + D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions_sequence? ']'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -17346,7 +17526,7 @@ list_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s list[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expressions? ']'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expressions_sequence? ']'")); } _res = NULL; done: @@ -17354,7 +17534,7 @@ list_rule(Parser *p) return _res; } -// tuple: '(' [star_named_expression ',' star_named_expressions?] ')' +// tuple: '(' [star_named_expression_sequence ',' star_named_expressions_sequence?] ')' static expr_ty tuple_rule(Parser *p) { @@ -17376,24 +17556,24 @@ tuple_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 - { // '(' [star_named_expression ',' star_named_expressions?] ')' + { // '(' [star_named_expression_sequence ',' star_named_expressions_sequence?] ')' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); + D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression_sequence ',' star_named_expressions_sequence?] ')'")); Token * _literal; Token * _literal_1; void *a; if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_82_rule(p), !p->error_indicator) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_84_rule(p), !p->error_indicator) // [star_named_expression_sequence ',' star_named_expressions_sequence?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); + D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression_sequence ',' star_named_expressions_sequence?] ')'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -17413,7 +17593,7 @@ tuple_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s tuple[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' [star_named_expression_sequence ',' star_named_expressions_sequence?] ')'")); } _res = NULL; done: @@ -17421,7 +17601,7 @@ tuple_rule(Parser *p) return _res; } -// set: '{' star_named_expressions '}' +// set: '{' star_named_expressions_sequence '}' static expr_ty set_rule(Parser *p) { @@ -17443,24 +17623,24 @@ set_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 - { // '{' star_named_expressions '}' + { // '{' star_named_expressions_sequence '}' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'")); + D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions_sequence '}'")); Token * _literal; Token * _literal_1; asdl_expr_seq* a; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (a = star_named_expressions_rule(p)) // star_named_expressions + (a = star_named_expressions_sequence_rule(p)) // star_named_expressions_sequence && (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'")); + D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions_sequence '}'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -17480,7 +17660,7 @@ set_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s set[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expressions '}'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expressions_sequence '}'")); } _res = NULL; done: @@ -17603,7 +17783,7 @@ double_starred_kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_84_rule(p)) // ','.double_starred_kvpair+ + (a = _gather_86_rule(p)) // ','.double_starred_kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -17762,7 +17942,7 @@ for_if_clauses_rule(Parser *p) D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause+")); asdl_comprehension_seq* a; if ( - (a = (asdl_comprehension_seq*)_loop1_85_rule(p)) // for_if_clause+ + (a = (asdl_comprehension_seq*)_loop1_87_rule(p)) // for_if_clause+ ) { D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "for_if_clause+")); @@ -17815,19 +17995,19 @@ for_if_clause_rule(Parser *p) expr_ty b; asdl_expr_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='async' + (_keyword = _PyPegen_expect_token(p, 711)) // token='async' && - (_keyword_1 = _PyPegen_expect_token(p, 703)) // token='for' + (_keyword_1 = _PyPegen_expect_token(p, 707)) // token='for' && (a = star_targets_rule(p)) // star_targets && - (_keyword_2 = _PyPegen_expect_token(p, 704)) // token='in' + (_keyword_2 = _PyPegen_expect_token(p, 708)) // token='in' && (_cut_var = 1) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_86_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_88_rule(p)) // (('if' disjunction))* ) { D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); @@ -17860,17 +18040,17 @@ for_if_clause_rule(Parser *p) expr_ty b; asdl_expr_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 703)) // token='for' + (_keyword = _PyPegen_expect_token(p, 707)) // token='for' && (a = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 704)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 708)) // token='in' && (_cut_var = 1) && (b = disjunction_rule(p)) // disjunction && - (c = (asdl_expr_seq*)_loop0_86_rule(p)) // (('if' disjunction))* + (c = (asdl_expr_seq*)_loop0_88_rule(p)) // (('if' disjunction))* ) { D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); @@ -17934,7 +18114,7 @@ for_if_clause_rule(Parser *p) return _res; } -// listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension +// listcomp: '[' star_named_expression for_if_clauses ']' | invalid_comprehension static expr_ty listcomp_rule(Parser *p) { @@ -17956,12 +18136,12 @@ listcomp_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 - { // '[' named_expression for_if_clauses ']' + { // '[' star_named_expression for_if_clauses ']' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' named_expression for_if_clauses ']'")); + D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_expression for_if_clauses ']'")); Token * _literal; Token * _literal_1; expr_ty a; @@ -17969,14 +18149,14 @@ listcomp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' && - (a = named_expression_rule(p)) // named_expression + (a = star_named_expression_rule(p)) // star_named_expression && (b = for_if_clauses_rule(p)) // for_if_clauses && (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' ) { - D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' named_expression for_if_clauses ']'")); + D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expression for_if_clauses ']'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -17996,7 +18176,7 @@ listcomp_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' named_expression for_if_clauses ']'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expression for_if_clauses ']'")); } if (p->call_invalid_rules) { // invalid_comprehension if (p->error_indicator) { @@ -18023,7 +18203,7 @@ listcomp_rule(Parser *p) return _res; } -// setcomp: '{' named_expression for_if_clauses '}' | invalid_comprehension +// setcomp: '{' star_named_expression for_if_clauses '}' | invalid_comprehension static expr_ty setcomp_rule(Parser *p) { @@ -18045,12 +18225,12 @@ setcomp_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 - { // '{' named_expression for_if_clauses '}' + { // '{' star_named_expression for_if_clauses '}' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' named_expression for_if_clauses '}'")); + D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expression for_if_clauses '}'")); Token * _literal; Token * _literal_1; expr_ty a; @@ -18058,14 +18238,14 @@ setcomp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (a = named_expression_rule(p)) // named_expression + (a = star_named_expression_rule(p)) // star_named_expression && (b = for_if_clauses_rule(p)) // for_if_clauses && (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' named_expression for_if_clauses '}'")); + D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expression for_if_clauses '}'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -18085,7 +18265,7 @@ setcomp_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' named_expression for_if_clauses '}'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expression for_if_clauses '}'")); } if (p->call_invalid_rules) { // invalid_comprehension if (p->error_indicator) { @@ -18113,7 +18293,7 @@ setcomp_rule(Parser *p) } // genexp: -// | '(' (assignment_expression | expression !':=') for_if_clauses ')' +// | '(' (assignment_expression | expression !':=' | starred_expression) for_if_clauses ')' // | invalid_comprehension static expr_ty genexp_rule(Parser *p) @@ -18136,12 +18316,12 @@ genexp_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 - { // '(' (assignment_expression | expression !':=') for_if_clauses ')' + { // '(' (assignment_expression | expression !':=' | starred_expression) for_if_clauses ')' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'")); + D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=' | starred_expression) for_if_clauses ')'")); Token * _literal; Token * _literal_1; void *a; @@ -18149,14 +18329,14 @@ genexp_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_87_rule(p)) // assignment_expression | expression !':=' + (a = _tmp_89_rule(p)) // assignment_expression | expression !':=' | starred_expression && (b = for_if_clauses_rule(p)) // for_if_clauses && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'")); + D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (assignment_expression | expression !':=' | starred_expression) for_if_clauses ')'")); Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); if (_token == NULL) { p->level--; @@ -18176,7 +18356,7 @@ genexp_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (assignment_expression | expression !':=') for_if_clauses ')'")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (assignment_expression | expression !':=' | starred_expression) for_if_clauses ')'")); } if (p->call_invalid_rules) { // invalid_comprehension if (p->error_indicator) { @@ -18203,7 +18383,7 @@ genexp_rule(Parser *p) return _res; } -// dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension +// dictcomp: '{' kvpair for_if_clauses '}' | '{' '**' expression for_if_clauses '}' static expr_ty dictcomp_rule(Parser *p) { @@ -18267,24 +18447,50 @@ dictcomp_rule(Parser *p) D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' kvpair for_if_clauses '}'")); } - if (p->call_invalid_rules) { // invalid_dict_comprehension + { // '{' '**' expression for_if_clauses '}' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension")); - void *invalid_dict_comprehension_var; + D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '**' expression for_if_clauses '}'")); + Token * _literal; + Token * _literal_1; + Token * _literal_2; + expr_ty a; + asdl_comprehension_seq* b; if ( - (invalid_dict_comprehension_var = invalid_dict_comprehension_rule(p)) // invalid_dict_comprehension + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + && + (_literal_1 = _PyPegen_expect_token(p, 35)) // token='**' + && + (a = expression_rule(p)) // expression + && + (b = for_if_clauses_rule(p)) // for_if_clauses + && + (_literal_2 = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension")); - _res = invalid_dict_comprehension_var; + D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '**' expression for_if_clauses '}'")); + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + p->level--; + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _PyAST_DictComp ( a , NULL , b , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } goto done; } p->mark = _mark; D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_dict_comprehension")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '**' expression for_if_clauses '}'")); } _res = NULL; done: @@ -18398,9 +18604,9 @@ args_rule(Parser *p) asdl_expr_seq* a; void *b; if ( - (a = (asdl_expr_seq*)_gather_89_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (a = (asdl_expr_seq*)_gather_91_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ && - (b = _tmp_90_rule(p), !p->error_indicator) // [',' kwargs] + (b = _tmp_92_rule(p), !p->error_indicator) // [',' kwargs] ) { D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]")); @@ -18490,11 +18696,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_92_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_94_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_94_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_96_rule(p)) // ','.kwarg_or_double_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+")); @@ -18516,13 +18722,13 @@ kwargs_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+")); - asdl_seq * _gather_92_var; + asdl_seq * _gather_94_var; if ( - (_gather_92_var = _gather_92_rule(p)) // ','.kwarg_or_starred+ + (_gather_94_var = _gather_94_rule(p)) // ','.kwarg_or_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+")); - _res = _gather_92_var; + _res = _gather_94_var; goto done; } p->mark = _mark; @@ -18535,13 +18741,13 @@ kwargs_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+")); - asdl_seq * _gather_94_var; + asdl_seq * _gather_96_var; if ( - (_gather_94_var = _gather_94_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_96_var = _gather_96_rule(p)) // ','.kwarg_or_double_starred+ ) { D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+")); - _res = _gather_94_var; + _res = _gather_96_var; goto done; } p->mark = _mark; @@ -18952,7 +19158,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_95_rule(p)) // ((',' star_target))* + (b = _loop0_97_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19008,7 +19214,7 @@ star_targets_list_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_97_rule(p)) // ','.star_target+ + (a = (asdl_expr_seq*)_gather_99_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19058,7 +19264,7 @@ star_targets_tuple_seq_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop1_98_rule(p)) // ((',' star_target))+ + (b = _loop1_100_rule(p)) // ((',' star_target))+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -19146,7 +19352,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_99_rule(p)) // !'*' star_target + (a = _tmp_101_rule(p)) // !'*' star_target ) { D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); @@ -20069,7 +20275,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_101_rule(p)) // ','.del_target+ + (a = (asdl_expr_seq*)_gather_103_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) @@ -20427,7 +20633,7 @@ type_expressions_rule(Parser *p) expr_ty b; expr_ty c; if ( - (a = _gather_103_rule(p)) // ','.expression+ + (a = _gather_105_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -20466,7 +20672,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_103_rule(p)) // ','.expression+ + (a = _gather_105_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -20499,7 +20705,7 @@ type_expressions_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _gather_103_rule(p)) // ','.expression+ + (a = _gather_105_rule(p)) // ','.expression+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && @@ -20619,7 +20825,7 @@ type_expressions_rule(Parser *p) D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+")); asdl_expr_seq* a; if ( - (a = (asdl_expr_seq*)_gather_103_rule(p)) // ','.expression+ + (a = (asdl_expr_seq*)_gather_105_rule(p)) // ','.expression+ ) { D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+")); @@ -20670,7 +20876,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, _tmp_104_rule, p) + _PyPegen_lookahead(1, _tmp_106_rule, p) ) { D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); @@ -20756,15 +20962,15 @@ invalid_arguments_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+")); - asdl_seq * _gather_107_var; - void *_tmp_105_var; + asdl_seq * _gather_109_var; + void *_tmp_107_var; Token * a; if ( - (_tmp_105_var = _tmp_105_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs + (_tmp_107_var = _tmp_107_rule(p)) // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs && (a = _PyPegen_expect_token(p, 12)) // token=',' && - (_gather_107_var = _gather_107_rule(p)) // ','.(starred_expression !'=')+ + (_gather_109_var = _gather_109_rule(p)) // ','.(starred_expression !'=')+ ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+")); @@ -20798,7 +21004,7 @@ invalid_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_108_rule(p), !p->error_indicator) // [args | expression for_if_clauses] + (_opt_var = _tmp_110_rule(p), !p->error_indicator) // [args | expression for_if_clauses] ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]")); @@ -20858,13 +21064,13 @@ invalid_arguments_rule(Parser *p) expr_ty a; Token * b; if ( - (_opt_var = _tmp_109_rule(p), !p->error_indicator) // [(args ',')] + (_opt_var = _tmp_111_rule(p), !p->error_indicator) // [(args ',')] && (a = _PyPegen_name_token(p)) // NAME && (b = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_110_rule, p) + _PyPegen_lookahead(1, _tmp_112_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')")); @@ -21002,7 +21208,7 @@ invalid_kwarg_rule(Parser *p) Token* a; Token * b; if ( - (a = (Token*)_tmp_111_rule(p)) // 'True' | 'False' | 'None' + (a = (Token*)_tmp_113_rule(p)) // 'True' | 'False' | 'None' && (b = _PyPegen_expect_token(p, 22)) // token='=' ) @@ -21062,7 +21268,7 @@ invalid_kwarg_rule(Parser *p) expr_ty a; Token * b; if ( - _PyPegen_lookahead(0, _tmp_112_rule, p) + _PyPegen_lookahead(0, _tmp_114_rule, p) && (a = expression_rule(p)) // expression && @@ -21165,11 +21371,11 @@ expression_without_invalid_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 695)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 699)) // token='else' && (c = expression_rule(p)) // expression ) @@ -21410,7 +21616,7 @@ invalid_expression_rule(Parser *p) if ( (string_var = _PyPegen_string_token(p)) // STRING && - (a = _loop1_113_rule(p)) // ((!STRING expression_without_invalid))+ + (a = _loop1_115_rule(p)) // ((!STRING expression_without_invalid))+ && (string_var_1 = _PyPegen_string_token(p)) // STRING ) @@ -21437,7 +21643,7 @@ invalid_expression_rule(Parser *p) expr_ty a; expr_ty b; if ( - _PyPegen_lookahead(0, _tmp_114_rule, p) + _PyPegen_lookahead(0, _tmp_116_rule, p) && (a = disjunction_rule(p)) // disjunction && @@ -21469,11 +21675,11 @@ invalid_expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (b = disjunction_rule(p)) // disjunction && - _PyPegen_lookahead(0, _tmp_115_rule, p) + _PyPegen_lookahead(0, _tmp_117_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')")); @@ -21502,11 +21708,11 @@ invalid_expression_rule(Parser *p) if ( (a = disjunction_rule(p)) // disjunction && - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 695)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 699)) // token='else' && _PyPegen_lookahead_for_expr(0, expression_rule, p) ) @@ -21536,13 +21742,13 @@ invalid_expression_rule(Parser *p) expr_ty b; stmt_ty c; if ( - (a = (stmt_ty)_tmp_116_rule(p)) // pass_stmt | break_stmt | continue_stmt + (a = (stmt_ty)_tmp_118_rule(p)) // pass_stmt | break_stmt | continue_stmt && - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (b = disjunction_rule(p)) // disjunction && - (_keyword_1 = _PyPegen_expect_token(p, 695)) // token='else' + (_keyword_1 = _PyPegen_expect_token(p, 699)) // token='else' && (c = simple_stmt_rule(p)) // simple_stmt ) @@ -21632,6 +21838,99 @@ invalid_expression_rule(Parser *p) return _res; } +// invalid_if_expression: +// | disjunction 'if' disjunction 'else' '*' +// | disjunction 'if' disjunction 'else' '**' +static void * +invalid_if_expression_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // disjunction 'if' disjunction 'else' '*' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_if_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' '*'")); + Token * _keyword; + Token * _keyword_1; + Token * a; + expr_ty b; + expr_ty disjunction_var; + if ( + (disjunction_var = disjunction_rule(p)) // disjunction + && + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' + && + (b = disjunction_rule(p)) // disjunction + && + (_keyword_1 = _PyPegen_expect_token(p, 699)) // token='else' + && + (a = _PyPegen_expect_token(p, 16)) // token='*' + ) + { + D(fprintf(stderr, "%*c+ invalid_if_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' '*'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot unpack only part of a conditional expression" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_if_expression[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' '*'")); + } + { // disjunction 'if' disjunction 'else' '**' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_if_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' '**'")); + Token * _keyword; + Token * _keyword_1; + Token * a; + expr_ty b; + expr_ty disjunction_var; + if ( + (disjunction_var = disjunction_rule(p)) // disjunction + && + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' + && + (b = disjunction_rule(p)) // disjunction + && + (_keyword_1 = _PyPegen_expect_token(p, 699)) // token='else' + && + (a = _PyPegen_expect_token(p, 35)) // token='**' + ) + { + D(fprintf(stderr, "%*c+ invalid_if_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' '**'")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use dict unpacking on only part of a conditional expression" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_if_expression[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' '**'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // invalid_named_expression: // | expression ':=' expression // | NAME '=' bitwise_or !('=' | ':=') @@ -21698,7 +21997,7 @@ invalid_named_expression_rule(Parser *p) && (b = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_117_rule, p) + _PyPegen_lookahead(0, _tmp_119_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')")); @@ -21724,7 +22023,7 @@ invalid_named_expression_rule(Parser *p) Token * b; expr_ty bitwise_or_var; if ( - _PyPegen_lookahead(0, _tmp_118_rule, p) + _PyPegen_lookahead(0, _tmp_120_rule, p) && (a = bitwise_or_rule(p)) // bitwise_or && @@ -21732,7 +22031,7 @@ invalid_named_expression_rule(Parser *p) && (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - _PyPegen_lookahead(0, _tmp_117_rule, p) + _PyPegen_lookahead(0, _tmp_119_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')")); @@ -21812,7 +22111,7 @@ invalid_assignment_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression")); Token * _literal; Token * _literal_1; - asdl_seq * _loop0_119_var; + asdl_seq * _loop0_121_var; expr_ty a; expr_ty expression_var; if ( @@ -21820,7 +22119,7 @@ invalid_assignment_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_119_var = _loop0_119_rule(p)) // star_named_expressions* + (_loop0_121_var = _loop0_121_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -21877,10 +22176,10 @@ invalid_assignment_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='")); Token * _literal; - asdl_seq * _loop0_120_var; + asdl_seq * _loop0_122_var; expr_ty a; if ( - (_loop0_120_var = _loop0_120_rule(p)) // ((star_targets '='))* + (_loop0_122_var = _loop0_122_rule(p)) // ((star_targets '='))* && (a = star_expressions_rule(p)) // star_expressions && @@ -21907,10 +22206,10 @@ invalid_assignment_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='")); Token * _literal; - asdl_seq * _loop0_120_var; + asdl_seq * _loop0_122_var; expr_ty a; if ( - (_loop0_120_var = _loop0_120_rule(p)) // ((star_targets '='))* + (_loop0_122_var = _loop0_122_rule(p)) // ((star_targets '='))* && (a = yield_expr_rule(p)) // yield_expr && @@ -22075,9 +22374,9 @@ invalid_raise_stmt_rule(Parser *p) Token * a; Token * b; if ( - (a = _PyPegen_expect_token(p, 628)) // token='raise' + (a = _PyPegen_expect_token(p, 632)) // token='raise' && - (b = _PyPegen_expect_token(p, 642)) // token='from' + (b = _PyPegen_expect_token(p, 646)) // token='from' ) { D(fprintf(stderr, "%*c+ invalid_raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' 'from'")); @@ -22103,11 +22402,11 @@ invalid_raise_stmt_rule(Parser *p) Token * a; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 628)) // token='raise' + (_keyword = _PyPegen_expect_token(p, 632)) // token='raise' && (expression_var = expression_rule(p)) // expression && - (a = _PyPegen_expect_token(p, 642)) // token='from' + (a = _PyPegen_expect_token(p, 646)) // token='from' ) { D(fprintf(stderr, "%*c+ invalid_raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' expression 'from'")); @@ -22151,7 +22450,7 @@ invalid_del_stmt_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 630)) // token='del' + (_keyword = _PyPegen_expect_token(p, 634)) // token='del' && (a = star_expressions_rule(p)) // star_expressions ) @@ -22203,7 +22502,7 @@ invalid_assert_stmt_rule(Parser *p) expr_ty a; expr_ty b; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='assert' + (_keyword = _PyPegen_expect_token(p, 638)) // token='assert' && (a = expression_rule(p)) // expression && @@ -22238,7 +22537,7 @@ invalid_assert_stmt_rule(Parser *p) expr_ty b; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='assert' + (_keyword = _PyPegen_expect_token(p, 638)) // token='assert' && (expression_var = expression_rule(p)) // expression && @@ -22275,7 +22574,7 @@ invalid_assert_stmt_rule(Parser *p) expr_ty a; expr_ty b; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='assert' + (_keyword = _PyPegen_expect_token(p, 638)) // token='assert' && (a = expression_rule(p)) // expression && @@ -22310,7 +22609,7 @@ invalid_assert_stmt_rule(Parser *p) expr_ty b; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 634)) // token='assert' + (_keyword = _PyPegen_expect_token(p, 638)) // token='assert' && (expression_var = expression_rule(p)) // expression && @@ -22388,7 +22687,8 @@ invalid_block_rule(Parser *p) } // invalid_comprehension: -// | ('[' | '(' | '{') starred_expression for_if_clauses +// | '[' '**' expression for_if_clauses +// | '(' '**' expression for_if_clauses // | ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses // | ('[' | '{') star_named_expression ',' for_if_clauses static void * @@ -22403,25 +22703,28 @@ invalid_comprehension_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // ('[' | '(' | '{') starred_expression for_if_clauses + { // '[' '**' expression for_if_clauses if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); - void *_tmp_121_var; - expr_ty a; + D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' '**' expression for_if_clauses")); + Token * _literal; + Token * a; + expr_ty b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_121_var = _tmp_121_rule(p)) // '[' | '(' | '{' + (_literal = _PyPegen_expect_token(p, 9)) // token='[' && - (a = starred_expression_rule(p)) // starred_expression + (a = _PyPegen_expect_token(p, 35)) // token='**' + && + (b = expression_rule(p)) // expression && (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable unpacking cannot be used in comprehension" ); + D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' '**' expression for_if_clauses")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot use dict unpacking in list comprehension" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -22431,33 +22734,30 @@ invalid_comprehension_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' '**' expression for_if_clauses")); } - { // ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses + { // '(' '**' expression for_if_clauses if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); + D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' '**' expression for_if_clauses")); Token * _literal; - void *_tmp_122_var; - expr_ty a; - asdl_expr_seq* b; + Token * a; + expr_ty b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_122_var = _tmp_122_rule(p)) // '[' | '{' - && - (a = star_named_expression_rule(p)) // star_named_expression + (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_literal = _PyPegen_expect_token(p, 12)) // token=',' + (a = _PyPegen_expect_token(p, 35)) // token='**' && - (b = star_named_expressions_rule(p)) // star_named_expressions + (b = expression_rule(p)) // expression && (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); - _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , PyPegen_last_item ( b , expr_ty ) , "did you forget parentheses around the comprehension target?" ); + D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' '**' expression for_if_clauses")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot use dict unpacking in generator expression" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -22467,30 +22767,33 @@ invalid_comprehension_rule(Parser *p) } p->mark = _mark; 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")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' '**' expression for_if_clauses")); } - { // ('[' | '{') star_named_expression ',' for_if_clauses + { // ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); - void *_tmp_122_var; + D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); + Token * _literal; + void *_tmp_123_var; expr_ty a; - Token * b; + asdl_expr_seq* b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_tmp_122_var = _tmp_122_rule(p)) // '[' | '{' + (_tmp_123_var = _tmp_123_rule(p)) // '[' | '{' && (a = star_named_expression_rule(p)) // star_named_expression && - (b = _PyPegen_expect_token(p, 12)) // token=',' + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (b = star_named_expressions_rule(p)) // star_named_expressions && (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); - _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "did you forget parentheses around the comprehension target?" ); + D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , PyPegen_last_item ( b , expr_ty ) , "did you forget parentheses around the comprehension target?" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -22500,52 +22803,30 @@ invalid_comprehension_rule(Parser *p) } p->mark = _mark; D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// invalid_dict_comprehension: '{' '**' bitwise_or for_if_clauses '}' -static void * -invalid_dict_comprehension_rule(Parser *p) -{ - if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { - _Pypegen_stack_overflow(p); - } - if (p->error_indicator) { - p->level--; - return NULL; + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses")); } - void * _res = NULL; - int _mark = p->mark; - { // '{' '**' bitwise_or for_if_clauses '}' + { // ('[' | '{') star_named_expression ',' for_if_clauses if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_dict_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); - Token * _literal; - Token * _literal_1; - Token * a; - expr_ty bitwise_or_var; + D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); + void *_tmp_123_var; + expr_ty a; + Token * b; asdl_comprehension_seq* for_if_clauses_var; if ( - (_literal = _PyPegen_expect_token(p, 25)) // token='{' + (_tmp_123_var = _tmp_123_rule(p)) // '[' | '{' && - (a = _PyPegen_expect_token(p, 35)) // token='**' + (a = star_named_expression_rule(p)) // star_named_expression && - (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or + (b = _PyPegen_expect_token(p, 12)) // token=',' && (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses - && - (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ invalid_dict_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "dict unpacking cannot be used in dict comprehension" ); + D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "did you forget parentheses around the comprehension target?" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -22554,8 +22835,8 @@ invalid_dict_comprehension_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_dict_comprehension[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); + D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' for_if_clauses")); } _res = NULL; done: @@ -22616,10 +22897,10 @@ invalid_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'")); asdl_seq * _loop0_31_var; - void *_tmp_123_var; + void *_tmp_124_var; Token * a; if ( - (_tmp_123_var = _tmp_123_rule(p)) // slash_no_default | slash_with_default + (_tmp_124_var = _tmp_124_rule(p)) // slash_no_default | slash_with_default && (_loop0_31_var = _loop0_31_rule(p)) // param_maybe_default* && @@ -22721,16 +23002,16 @@ invalid_parameters_rule(Parser *p) asdl_seq * _loop0_31_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_124_var; + void *_tmp_125_var; Token * a; if ( - (_opt_var = _tmp_123_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] + (_opt_var = _tmp_124_rule(p), !p->error_indicator) // [(slash_no_default | slash_with_default)] && (_loop0_31_var = _loop0_31_rule(p)) // param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_124_var = _tmp_124_rule(p)) // ',' | param_no_default + (_tmp_125_var = _tmp_125_rule(p)) // ',' | param_no_default && (_loop0_31_var_1 = _loop0_31_rule(p)) // param_maybe_default* && @@ -22809,7 +23090,7 @@ invalid_default_rule(Parser *p) if ( (a = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(1, _tmp_125_rule, p) + _PyPegen_lookahead(1, _tmp_126_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' &(')' | ',')")); @@ -22854,12 +23135,12 @@ invalid_star_etc_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); - void *_tmp_126_var; + void *_tmp_127_var; Token * a; if ( (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_126_var = _tmp_126_rule(p)) // ')' | ',' (')' | '**') + (_tmp_127_var = _tmp_127_rule(p)) // ')' | ',' (')' | '**') ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); @@ -22943,19 +23224,19 @@ invalid_star_etc_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); Token * _literal; asdl_seq * _loop0_31_var; - void *_tmp_127_var; - void *_tmp_127_var_1; + void *_tmp_128_var; + void *_tmp_128_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_127_var = _tmp_127_rule(p)) // param_no_default | ',' + (_tmp_128_var = _tmp_128_rule(p)) // param_no_default | ',' && (_loop0_31_var = _loop0_31_rule(p)) // param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_127_var_1 = _tmp_127_rule(p)) // param_no_default | ',' + (_tmp_128_var_1 = _tmp_128_rule(p)) // param_no_default | ',' ) { D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')")); @@ -23070,7 +23351,7 @@ invalid_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_128_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_129_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param ',' ('*' | '**' | '/')")); @@ -23206,13 +23487,13 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'")); - asdl_seq * _loop0_74_var; - void *_tmp_129_var; + asdl_seq * _loop0_76_var; + void *_tmp_130_var; Token * a; if ( - (_tmp_129_var = _tmp_129_rule(p)) // lambda_slash_no_default | lambda_slash_with_default + (_tmp_130_var = _tmp_130_rule(p)) // lambda_slash_no_default | lambda_slash_with_default && - (_loop0_74_var = _loop0_74_rule(p)) // lambda_param_maybe_default* + (_loop0_76_var = _loop0_76_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -23236,7 +23517,7 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default")); - asdl_seq * _loop0_70_var; + asdl_seq * _loop0_72_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings arg_ty a; @@ -23244,7 +23525,7 @@ invalid_lambda_parameters_rule(Parser *p) if ( (_opt_var = lambda_slash_no_default_rule(p), !p->error_indicator) // lambda_slash_no_default? && - (_loop0_70_var = _loop0_70_rule(p)) // lambda_param_no_default* + (_loop0_72_var = _loop0_72_rule(p)) // lambda_param_no_default* && (invalid_lambda_parameters_helper_var = invalid_lambda_parameters_helper_rule(p)) // invalid_lambda_parameters_helper && @@ -23270,18 +23551,18 @@ invalid_lambda_parameters_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'")); - asdl_seq * _gather_131_var; - asdl_seq * _loop0_70_var; + asdl_seq * _gather_132_var; + asdl_seq * _loop0_72_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * b; if ( - (_loop0_70_var = _loop0_70_rule(p)) // lambda_param_no_default* + (_loop0_72_var = _loop0_72_rule(p)) // lambda_param_no_default* && (a = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_131_var = _gather_131_rule(p)) // ','.lambda_param+ + (_gather_132_var = _gather_132_rule(p)) // ','.lambda_param+ && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -23308,22 +23589,22 @@ invalid_lambda_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "[(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'")); Token * _literal; - asdl_seq * _loop0_74_var; - asdl_seq * _loop0_74_var_1; + asdl_seq * _loop0_76_var; + asdl_seq * _loop0_76_var_1; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_132_var; + void *_tmp_133_var; Token * a; if ( - (_opt_var = _tmp_129_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] + (_opt_var = _tmp_130_rule(p), !p->error_indicator) // [(lambda_slash_no_default | lambda_slash_with_default)] && - (_loop0_74_var = _loop0_74_rule(p)) // lambda_param_maybe_default* + (_loop0_76_var = _loop0_76_rule(p)) // lambda_param_maybe_default* && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_132_var = _tmp_132_rule(p)) // ',' | lambda_param_no_default + (_tmp_133_var = _tmp_133_rule(p)) // ',' | lambda_param_no_default && - (_loop0_74_var_1 = _loop0_74_rule(p)) // lambda_param_maybe_default* + (_loop0_76_var_1 = _loop0_76_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 17)) // token='/' ) @@ -23348,10 +23629,10 @@ invalid_lambda_parameters_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default+ '/' '*'")); Token * _literal; - asdl_seq * _loop1_75_var; + asdl_seq * _loop1_77_var; Token * a; if ( - (_loop1_75_var = _loop1_75_rule(p)) // lambda_param_maybe_default+ + (_loop1_77_var = _loop1_77_rule(p)) // lambda_param_maybe_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -23422,13 +23703,13 @@ invalid_lambda_parameters_helper_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_lambda_parameters_helper[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+")); - asdl_seq * _loop1_73_var; + asdl_seq * _loop1_75_var; if ( - (_loop1_73_var = _loop1_73_rule(p)) // lambda_param_with_default+ + (_loop1_75_var = _loop1_75_rule(p)) // lambda_param_with_default+ ) { D(fprintf(stderr, "%*c+ invalid_lambda_parameters_helper[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+")); - _res = _loop1_73_var; + _res = _loop1_75_var; goto done; } p->mark = _mark; @@ -23464,11 +23745,11 @@ invalid_lambda_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); Token * _literal; - void *_tmp_133_var; + void *_tmp_134_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_133_var = _tmp_133_rule(p)) // ':' | ',' (':' | '**') + (_tmp_134_var = _tmp_134_rule(p)) // ':' | ',' (':' | '**') ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); @@ -23521,20 +23802,20 @@ invalid_lambda_star_etc_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); Token * _literal; - asdl_seq * _loop0_74_var; - void *_tmp_134_var; - void *_tmp_134_var_1; + asdl_seq * _loop0_76_var; + void *_tmp_135_var; + void *_tmp_135_var_1; Token * a; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_134_var = _tmp_134_rule(p)) // lambda_param_no_default | ',' + (_tmp_135_var = _tmp_135_rule(p)) // lambda_param_no_default | ',' && - (_loop0_74_var = _loop0_74_rule(p)) // lambda_param_maybe_default* + (_loop0_76_var = _loop0_76_rule(p)) // lambda_param_maybe_default* && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_134_var_1 = _tmp_134_rule(p)) // lambda_param_no_default | ',' + (_tmp_135_var_1 = _tmp_135_rule(p)) // lambda_param_no_default | ',' ) { D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')")); @@ -23652,7 +23933,7 @@ invalid_lambda_kwds_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (a = (Token*)_tmp_128_rule(p)) // '*' | '**' | '/' + (a = (Token*)_tmp_129_rule(p)) // '*' | '**' | '/' ) { D(fprintf(stderr, "%*c+ invalid_lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param ',' ('*' | '**' | '/')")); @@ -23754,7 +24035,7 @@ invalid_with_item_rule(Parser *p) if ( (expression_var = expression_rule(p)) // expression && - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && (a = expression_rule(p)) // expression && @@ -23802,15 +24083,15 @@ invalid_for_if_clause_rule(Parser *p) Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings - void *_tmp_135_var; + void *_tmp_136_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 703)) // token='for' + (_keyword = _PyPegen_expect_token(p, 707)) // token='for' && - (_tmp_135_var = _tmp_135_rule(p)) // bitwise_or ((',' bitwise_or))* ','? + (_tmp_136_var = _tmp_136_rule(p)) // bitwise_or ((',' bitwise_or))* ','? && - _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 704) // token='in' + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 708) // token='in' ) { D(fprintf(stderr, "%*c+ invalid_for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'? 'for' (bitwise_or ((',' bitwise_or))* ','?) !'in'")); @@ -23856,9 +24137,9 @@ invalid_for_target_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings expr_ty a; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 703)) // token='for' + (_keyword = _PyPegen_expect_token(p, 707)) // token='for' && (a = star_expressions_rule(p)) // star_expressions ) @@ -23983,16 +24264,16 @@ invalid_import_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_import[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' ','.dotted_name+ 'from' dotted_name")); - asdl_seq * _gather_137_var; + asdl_seq * _gather_138_var; Token * _keyword; Token * a; expr_ty dotted_name_var; if ( - (a = _PyPegen_expect_token(p, 643)) // token='import' + (a = _PyPegen_expect_token(p, 647)) // token='import' && - (_gather_137_var = _gather_137_rule(p)) // ','.dotted_name+ + (_gather_138_var = _gather_138_rule(p)) // ','.dotted_name+ && - (_keyword = _PyPegen_expect_token(p, 642)) // token='from' + (_keyword = _PyPegen_expect_token(p, 646)) // token='from' && (dotted_name_var = dotted_name_rule(p)) // dotted_name ) @@ -24019,7 +24300,7 @@ invalid_import_rule(Parser *p) Token * _keyword; Token * token; if ( - (_keyword = _PyPegen_expect_token(p, 643)) // token='import' + (_keyword = _PyPegen_expect_token(p, 647)) // token='import' && (token = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -24068,9 +24349,9 @@ invalid_dotted_as_name_rule(Parser *p) if ( (dotted_name_var = dotted_name_rule(p)) // dotted_name && - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && - _PyPegen_lookahead(0, _tmp_138_rule, p) + _PyPegen_lookahead(0, _tmp_139_rule, p) && (a = expression_rule(p)) // expression ) @@ -24119,9 +24400,9 @@ invalid_import_from_as_name_rule(Parser *p) if ( (name_var = _PyPegen_name_token(p)) // NAME && - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && - _PyPegen_lookahead(0, _tmp_138_rule, p) + _PyPegen_lookahead(0, _tmp_139_rule, p) && (a = expression_rule(p)) // expression ) @@ -24239,17 +24520,17 @@ invalid_with_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ NEWLINE")); - asdl_seq * _gather_140_var; + asdl_seq * _gather_141_var; Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 656)) // token='with' + (_keyword = _PyPegen_expect_token(p, 660)) // token='with' && - (_gather_140_var = _gather_140_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_141_var = _gather_141_rule(p)) // ','.(expression ['as' star_target])+ && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -24273,7 +24554,7 @@ invalid_with_stmt_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE")); - asdl_seq * _gather_142_var; + asdl_seq * _gather_143_var; Token * _keyword; Token * _literal; Token * _literal_1; @@ -24283,13 +24564,13 @@ invalid_with_stmt_rule(Parser *p) UNUSED(_opt_var_1); // Silence compiler warnings Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 656)) // token='with' + (_keyword = _PyPegen_expect_token(p, 660)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_142_var = _gather_142_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_143_var = _gather_143_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -24338,18 +24619,18 @@ invalid_with_stmt_indent_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT")); - asdl_seq * _gather_140_var; + asdl_seq * _gather_141_var; Token * _literal; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 656)) // token='with' + (a = _PyPegen_expect_token(p, 660)) // token='with' && - (_gather_140_var = _gather_140_rule(p)) // ','.(expression ['as' star_target])+ + (_gather_141_var = _gather_141_rule(p)) // ','.(expression ['as' star_target])+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -24377,7 +24658,7 @@ invalid_with_stmt_indent_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_with_stmt_indent[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT")); - asdl_seq * _gather_142_var; + asdl_seq * _gather_143_var; Token * _literal; Token * _literal_1; Token * _literal_2; @@ -24388,13 +24669,13 @@ invalid_with_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 656)) // token='with' + (a = _PyPegen_expect_token(p, 660)) // token='with' && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (_gather_142_var = _gather_142_rule(p)) // ','.(expressions ['as' star_target])+ + (_gather_143_var = _gather_143_rule(p)) // ','.(expressions ['as' star_target])+ && (_opt_var_1 = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? && @@ -24453,7 +24734,7 @@ invalid_try_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 665)) // token='try' + (a = _PyPegen_expect_token(p, 669)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -24485,13 +24766,13 @@ invalid_try_stmt_rule(Parser *p) Token * _literal; asdl_stmt_seq* block_var; if ( - (_keyword = _PyPegen_expect_token(p, 665)) // token='try' + (_keyword = _PyPegen_expect_token(p, 669)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && (block_var = block_rule(p)) // block && - _PyPegen_lookahead(0, _tmp_143_rule, p) + _PyPegen_lookahead(0, _tmp_144_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block !('except' | 'finally')")); @@ -24516,7 +24797,7 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_144_var; + asdl_seq * _loop0_145_var; asdl_seq * _loop1_36_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -24524,15 +24805,15 @@ invalid_try_stmt_rule(Parser *p) Token * b; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 665)) // token='try' + (_keyword = _PyPegen_expect_token(p, 669)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_144_var = _loop0_144_rule(p)) // block* + (_loop0_145_var = _loop0_145_rule(p)) // block* && (_loop1_36_var = _loop1_36_rule(p)) // except_block+ && - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && (b = _PyPegen_expect_token(p, 16)) // token='*' && @@ -24565,23 +24846,23 @@ invalid_try_stmt_rule(Parser *p) Token * _keyword; Token * _literal; Token * _literal_1; - asdl_seq * _loop0_144_var; + asdl_seq * _loop0_145_var; asdl_seq * _loop1_37_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings Token * a; if ( - (_keyword = _PyPegen_expect_token(p, 665)) // token='try' + (_keyword = _PyPegen_expect_token(p, 669)) // token='try' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_144_var = _loop0_144_rule(p)) // block* + (_loop0_145_var = _loop0_145_rule(p)) // block* && (_loop1_37_var = _loop1_37_rule(p)) // except_star_block+ && - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && - (_opt_var = _tmp_145_rule(p), !p->error_indicator) // [expression ['as' NAME]] + (_opt_var = _tmp_146_rule(p), !p->error_indicator) // [expression ['as' NAME]] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -24636,7 +24917,7 @@ invalid_except_stmt_rule(Parser *p) expr_ty expressions_var; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (a = expression_rule(p)) // expression && @@ -24644,7 +24925,7 @@ invalid_except_stmt_rule(Parser *p) && (expressions_var = expressions_rule(p)) // expressions && - (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 693)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -24676,7 +24957,7 @@ invalid_except_stmt_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && (expression_var = expression_rule(p)) // expression && @@ -24707,7 +24988,7 @@ invalid_except_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) @@ -24738,11 +25019,11 @@ invalid_except_stmt_rule(Parser *p) asdl_stmt_seq* block_var; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (expression_var = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 693)) // token='as' && (a = expression_rule(p)) // expression && @@ -24802,7 +25083,7 @@ invalid_except_star_stmt_rule(Parser *p) expr_ty expressions_var; expr_ty name_var; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -24812,7 +25093,7 @@ invalid_except_star_stmt_rule(Parser *p) && (expressions_var = expressions_rule(p)) // expressions && - (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 693)) // token='as' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -24845,7 +25126,7 @@ invalid_except_star_stmt_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -24876,14 +25157,14 @@ invalid_except_star_stmt_rule(Parser *p) } D(fprintf(stderr, "%*c> invalid_except_star_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); Token * _literal; - void *_tmp_146_var; + void *_tmp_147_var; Token * a; if ( - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_146_var = _tmp_146_rule(p)) // NEWLINE | ':' + (_tmp_147_var = _tmp_147_rule(p)) // NEWLINE | ':' ) { D(fprintf(stderr, "%*c+ invalid_except_star_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' '*' (NEWLINE | ':')")); @@ -24913,13 +25194,13 @@ invalid_except_star_stmt_rule(Parser *p) asdl_stmt_seq* block_var; expr_ty expression_var; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && (expression_var = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword_1 = _PyPegen_expect_token(p, 693)) // token='as' && (a = expression_rule(p)) // expression && @@ -24970,7 +25251,7 @@ invalid_finally_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 682)) // token='finally' + (a = _PyPegen_expect_token(p, 686)) // token='finally' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25026,7 +25307,7 @@ invalid_except_stmt_indent_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && (expression_var = expression_rule(p)) // expression && @@ -25062,7 +25343,7 @@ invalid_except_stmt_indent_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25118,7 +25399,7 @@ invalid_except_star_stmt_indent_rule(Parser *p) expr_ty expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 686)) // token='except' + (a = _PyPegen_expect_token(p, 690)) // token='except' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -25395,7 +25676,7 @@ invalid_as_pattern_rule(Parser *p) if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && (a = _PyPegen_expect_soft_keyword(p, "_")) // soft_keyword='"_"' ) @@ -25425,7 +25706,7 @@ invalid_as_pattern_rule(Parser *p) if ( (or_pattern_var = or_pattern_rule(p)) // or_pattern && - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && (a = expression_rule(p)) // expression ) @@ -25530,7 +25811,7 @@ invalid_mapping_pattern_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' && - (_opt_var = _tmp_147_rule(p), !p->error_indicator) // [(items_pattern ',')] + (_opt_var = _tmp_148_rule(p), !p->error_indicator) // [(items_pattern ',')] && (rest = double_star_pattern_rule(p)) // double_star_pattern && @@ -25588,7 +25869,7 @@ invalid_class_argument_pattern_rule(Parser *p) asdl_pattern_seq* a; asdl_seq* keyword_patterns_var; if ( - (_opt_var = _tmp_148_rule(p), !p->error_indicator) // [positional_patterns ','] + (_opt_var = _tmp_149_rule(p), !p->error_indicator) // [positional_patterns ','] && (keyword_patterns_var = keyword_patterns_rule(p)) // keyword_patterns && @@ -25641,7 +25922,7 @@ invalid_if_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -25672,7 +25953,7 @@ invalid_if_stmt_rule(Parser *p) expr_ty a_1; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 691)) // token='if' + (a = _PyPegen_expect_token(p, 695)) // token='if' && (a_1 = named_expression_rule(p)) // named_expression && @@ -25727,7 +26008,7 @@ invalid_elif_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 696)) // token='elif' + (_keyword = _PyPegen_expect_token(p, 700)) // token='elif' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -25758,7 +26039,7 @@ invalid_elif_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 696)) // token='elif' + (a = _PyPegen_expect_token(p, 700)) // token='elif' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -25811,7 +26092,7 @@ invalid_else_stmt_rule(Parser *p) Token * a; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 695)) // token='else' + (a = _PyPegen_expect_token(p, 699)) // token='else' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -25844,13 +26125,13 @@ invalid_else_stmt_rule(Parser *p) Token * _literal; asdl_stmt_seq* block_var; if ( - (_keyword = _PyPegen_expect_token(p, 695)) // token='else' + (_keyword = _PyPegen_expect_token(p, 699)) // token='else' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && (block_var = block_rule(p)) // block && - (_keyword_1 = _PyPegen_expect_token(p, 696)) // token='elif' + (_keyword_1 = _PyPegen_expect_token(p, 700)) // token='elif' ) { D(fprintf(stderr, "%*c+ invalid_else_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' ':' block 'elif'")); @@ -25897,7 +26178,7 @@ invalid_while_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 698)) // token='while' + (_keyword = _PyPegen_expect_token(p, 702)) // token='while' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -25928,7 +26209,7 @@ invalid_while_stmt_rule(Parser *p) expr_ty named_expression_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 698)) // token='while' + (a = _PyPegen_expect_token(p, 702)) // token='while' && (named_expression_var = named_expression_rule(p)) // named_expression && @@ -25987,13 +26268,13 @@ invalid_for_stmt_rule(Parser *p) expr_ty star_expressions_var; expr_ty star_targets_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 703)) // token='for' + (_keyword = _PyPegen_expect_token(p, 707)) // token='for' && (star_targets_var = star_targets_rule(p)) // star_targets && - (_keyword_1 = _PyPegen_expect_token(p, 704)) // token='in' + (_keyword_1 = _PyPegen_expect_token(p, 708)) // token='in' && (star_expressions_var = star_expressions_rule(p)) // star_expressions && @@ -26028,13 +26309,13 @@ invalid_for_stmt_rule(Parser *p) expr_ty star_expressions_var; expr_ty star_targets_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 703)) // token='for' + (a = _PyPegen_expect_token(p, 707)) // token='for' && (star_targets_var = star_targets_rule(p)) // star_targets && - (_keyword = _PyPegen_expect_token(p, 704)) // token='in' + (_keyword = _PyPegen_expect_token(p, 708)) // token='in' && (star_expressions_var = star_expressions_rule(p)) // star_expressions && @@ -26100,9 +26381,9 @@ invalid_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (a = _PyPegen_expect_token(p, 708)) // token='def' + (a = _PyPegen_expect_token(p, 712)) // token='def' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -26159,9 +26440,9 @@ invalid_def_raw_rule(Parser *p) asdl_stmt_seq* block_var; expr_ty name_var; if ( - (_opt_var = _PyPegen_expect_token(p, 707), !p->error_indicator) // 'async'? + (_opt_var = _PyPegen_expect_token(p, 711), !p->error_indicator) // 'async'? && - (_keyword = _PyPegen_expect_token(p, 708)) // token='def' + (_keyword = _PyPegen_expect_token(p, 712)) // token='def' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -26225,7 +26506,7 @@ invalid_class_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (_keyword = _PyPegen_expect_token(p, 710)) // token='class' + (_keyword = _PyPegen_expect_token(p, 714)) // token='class' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -26264,7 +26545,7 @@ invalid_class_def_raw_rule(Parser *p) expr_ty name_var; Token * newline_var; if ( - (a = _PyPegen_expect_token(p, 710)) // token='class' + (a = _PyPegen_expect_token(p, 714)) // token='class' && (name_var = _PyPegen_name_token(p)) // NAME && @@ -26299,8 +26580,8 @@ invalid_class_def_raw_rule(Parser *p) } // invalid_double_starred_kvpairs: -// | ','.double_starred_kvpair+ ',' invalid_kvpair -// | expression ':' '*' bitwise_or +// | invalid_kvpair_unpacking ','? +// | ','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking) // | expression ':' &('}' | ',') static void * invalid_double_starred_kvpairs_rule(Parser *p) @@ -26314,40 +26595,209 @@ invalid_double_starred_kvpairs_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // ','.double_starred_kvpair+ ',' invalid_kvpair + { // invalid_kvpair_unpacking ','? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); - asdl_seq * _gather_84_var; + D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kvpair_unpacking ','?")); + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + void *invalid_kvpair_unpacking_var; + if ( + (invalid_kvpair_unpacking_var = invalid_kvpair_unpacking_rule(p)) // invalid_kvpair_unpacking + && + (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? + ) + { + D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kvpair_unpacking ','?")); + _res = _PyPegen_dummy_name(p, invalid_kvpair_unpacking_var, _opt_var); + goto done; + } + p->mark = _mark; + 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 ','?")); + } + { // ','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking) + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking)")); + asdl_seq * _gather_86_var; Token * _literal; - void *invalid_kvpair_var; + void *_tmp_150_var; if ( - (_gather_84_var = _gather_84_rule(p)) // ','.double_starred_kvpair+ + (_gather_86_var = _gather_86_rule(p)) // ','.double_starred_kvpair+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (invalid_kvpair_var = invalid_kvpair_rule(p)) // invalid_kvpair + (_tmp_150_var = _tmp_150_rule(p)) // invalid_kvpair | invalid_kvpair_unpacking ) { - D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' invalid_kvpair")); - _res = _PyPegen_dummy_name(p, _gather_84_var, _literal, invalid_kvpair_var); + D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking)")); + _res = _PyPegen_dummy_name(p, _gather_86_var, _literal, _tmp_150_var); + goto done; + } + p->mark = _mark; + 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)")); + } + { // expression ':' &('}' | ',') + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); + Token * a; + expr_ty expression_var; + if ( + (expression_var = expression_rule(p)) // expression + && + (a = _PyPegen_expect_token(p, 11)) // token=':' + && + _PyPegen_lookahead(1, _tmp_151_rule, p) + ) + { + D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } goto done; } p->mark = _mark; 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")); + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// invalid_kvpair_unpacking: +// | '**' if_expression +// | '*' bitwise_or ':' expression +// | '**' bitwise_or ':' expression +// | expression ':' '*' bitwise_or +// | expression ':' '**' bitwise_or +static void * +invalid_kvpair_unpacking_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '**' if_expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_kvpair_unpacking[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' if_expression")); + Token * a; + expr_ty b; + if ( + (a = _PyPegen_expect_token(p, 35)) // token='**' + && + (b = if_expression_rule(p)) // if_expression + ) + { + D(fprintf(stderr, "%*c+ invalid_kvpair_unpacking[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' if_expression")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid double starred expression. Did you forget to wrap the conditional expression in parentheses?" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' if_expression")); + } + { // '*' bitwise_or ':' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_kvpair_unpacking[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or ':' expression")); + Token * _literal; + Token * a; + expr_ty b; + expr_ty expression_var; + if ( + (a = _PyPegen_expect_token(p, 16)) // token='*' + && + (b = bitwise_or_rule(p)) // bitwise_or + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (expression_var = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ invalid_kvpair_unpacking[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or ':' expression")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot use a starred expression in a dictionary key" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + 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")); + } + { // '**' bitwise_or ':' expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_kvpair_unpacking[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or ':' expression")); + Token * _literal; + Token * a; + expr_ty b; + expr_ty expression_var; + if ( + (a = _PyPegen_expect_token(p, 35)) // token='**' + && + (b = bitwise_or_rule(p)) // bitwise_or + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (expression_var = expression_rule(p)) // expression + ) + { + D(fprintf(stderr, "%*c+ invalid_kvpair_unpacking[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or ':' expression")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot use dict unpacking in a dictionary key" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + 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")); } { // expression ':' '*' bitwise_or if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or")); + D(fprintf(stderr, "%*c> invalid_kvpair_unpacking[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or")); Token * _literal; Token * a; - expr_ty bitwise_or_var; + expr_ty b; expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -26356,11 +26806,11 @@ invalid_double_starred_kvpairs_rule(Parser *p) && (a = _PyPegen_expect_token(p, 16)) // token='*' && - (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or + (b = bitwise_or_rule(p)) // bitwise_or ) { - D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or")); - _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" ); + D(fprintf(stderr, "%*c+ invalid_kvpair_unpacking[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' '*' bitwise_or")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot use a starred expression in a dictionary value" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -26369,27 +26819,31 @@ invalid_double_starred_kvpairs_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', + 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")); } - { // expression ':' &('}' | ',') + { // expression ':' '**' bitwise_or if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> invalid_double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); + D(fprintf(stderr, "%*c> invalid_kvpair_unpacking[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' '**' bitwise_or")); + Token * _literal; Token * a; + expr_ty b; expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression && - (a = _PyPegen_expect_token(p, 11)) // token=':' + (_literal = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_149_rule, p) + (a = _PyPegen_expect_token(p, 35)) // token='**' + && + (b = bitwise_or_rule(p)) // bitwise_or ) { - D(fprintf(stderr, "%*c+ invalid_double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" ); + D(fprintf(stderr, "%*c+ invalid_kvpair_unpacking[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' '**' bitwise_or")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot use dict unpacking in a dictionary value" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; p->level--; @@ -26398,8 +26852,8 @@ invalid_double_starred_kvpairs_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' &('}' | ',')")); + 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")); } _res = NULL; done: @@ -26410,6 +26864,7 @@ invalid_double_starred_kvpairs_rule(Parser *p) // invalid_kvpair: // | expression !(':') // | expression ':' '*' bitwise_or +// | expression ':' '**' bitwise_or // | expression ':' &('}' | ',') static void * invalid_kvpair_rule(Parser *p) @@ -26482,6 +26937,39 @@ invalid_kvpair_rule(Parser *p) D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or")); } + { // expression ':' '**' bitwise_or + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' '**' bitwise_or")); + Token * _literal; + Token * a; + expr_ty bitwise_or_var; + expr_ty expression_var; + if ( + (expression_var = expression_rule(p)) // expression + && + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + && + (a = _PyPegen_expect_token(p, 35)) // token='**' + && + (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or + ) + { + D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' '**' bitwise_or")); + _res = RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use dict unpacking in a dictionary value" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_kvpair[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '**' bitwise_or")); + } { // expression ':' &('}' | ',') if (p->error_indicator) { p->level--; @@ -26495,7 +26983,7 @@ invalid_kvpair_rule(Parser *p) && (a = _PyPegen_expect_token(p, 11)) // token=':' && - _PyPegen_lookahead(1, _tmp_149_rule, p) + _PyPegen_lookahead(1, _tmp_151_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' &('}' | ',')")); @@ -26517,7 +27005,7 @@ invalid_kvpair_rule(Parser *p) return _res; } -// invalid_starred_expression_unpacking: '*' expression '=' expression +// invalid_starred_expression_unpacking: '*' if_expression | '*' expression '=' expression static void * invalid_starred_expression_unpacking_rule(Parser *p) { @@ -26530,6 +27018,33 @@ invalid_starred_expression_unpacking_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + { // '*' if_expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_starred_expression_unpacking[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' if_expression")); + Token * a; + expr_ty b; + if ( + (a = _PyPegen_expect_token(p, 16)) // token='*' + && + (b = if_expression_rule(p)) // if_expression + ) + { + D(fprintf(stderr, "%*c+ invalid_starred_expression_unpacking[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' if_expression")); + _res = RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid starred expression. Did you forget to wrap the conditional expression in parentheses?" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_starred_expression_unpacking[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' if_expression")); + } { // '*' expression '=' expression if (p->error_indicator) { p->level--; @@ -26569,6 +27084,73 @@ invalid_starred_expression_unpacking_rule(Parser *p) return _res; } +// invalid_starred_expression_unpacking_sequence: +// | '**' bitwise_or +// | invalid_starred_expression_unpacking +static void * +invalid_starred_expression_unpacking_sequence_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '**' bitwise_or + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_starred_expression_unpacking_sequence[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or")); + Token * a; + expr_ty bitwise_or_var; + if ( + (a = _PyPegen_expect_token(p, 35)) // token='**' + && + (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or + ) + { + D(fprintf(stderr, "%*c+ invalid_starred_expression_unpacking_sequence[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or")); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use dict unpacking here" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + p->level--; + return NULL; + } + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_starred_expression_unpacking_sequence[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or")); + } + if (p->call_invalid_rules) { // invalid_starred_expression_unpacking + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> invalid_starred_expression_unpacking_sequence[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_starred_expression_unpacking")); + void *invalid_starred_expression_unpacking_var; + if ( + (invalid_starred_expression_unpacking_var = invalid_starred_expression_unpacking_rule(p)) // invalid_starred_expression_unpacking + ) + { + D(fprintf(stderr, "%*c+ invalid_starred_expression_unpacking_sequence[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_starred_expression_unpacking")); + _res = invalid_starred_expression_unpacking_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s invalid_starred_expression_unpacking_sequence[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_starred_expression_unpacking")); + } + _res = NULL; + done: + p->level--; + return _res; +} + // invalid_starred_expression: '*' static void * invalid_starred_expression_rule(Parser *p) @@ -26783,7 +27365,7 @@ invalid_fstring_replacement_field_rule(Parser *p) && (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs && - _PyPegen_lookahead(0, _tmp_150_rule, p) + _PyPegen_lookahead(0, _tmp_152_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); @@ -26815,7 +27397,7 @@ invalid_fstring_replacement_field_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, _tmp_151_rule, p) + _PyPegen_lookahead(0, _tmp_153_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); @@ -26879,9 +27461,9 @@ invalid_fstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_152_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, _tmp_153_rule, p) + _PyPegen_lookahead(0, _tmp_155_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_fstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); @@ -26905,7 +27487,7 @@ invalid_fstring_replacement_field_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_fstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); Token * _literal; Token * _literal_1; - asdl_seq * _loop0_76_var; + asdl_seq * _loop0_78_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; @@ -26918,11 +27500,11 @@ invalid_fstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_152_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_76_var = _loop0_76_rule(p)) // fstring_format_spec* + (_loop0_78_var = _loop0_78_rule(p)) // fstring_format_spec* && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -26959,7 +27541,7 @@ invalid_fstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_152_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -27006,7 +27588,7 @@ invalid_fstring_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, _tmp_153_rule, p) + _PyPegen_lookahead(1, _tmp_155_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_fstring_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); @@ -27225,7 +27807,7 @@ invalid_tstring_replacement_field_rule(Parser *p) && (annotated_rhs_var = annotated_rhs_rule(p)) // annotated_rhs && - _PyPegen_lookahead(0, _tmp_150_rule, p) + _PyPegen_lookahead(0, _tmp_152_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs !('=' | '!' | ':' | '}')")); @@ -27257,7 +27839,7 @@ invalid_tstring_replacement_field_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 22)) // token='=' && - _PyPegen_lookahead(0, _tmp_151_rule, p) + _PyPegen_lookahead(0, _tmp_153_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '=' !('!' | ':' | '}')")); @@ -27321,9 +27903,9 @@ invalid_tstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_152_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] && - _PyPegen_lookahead(0, _tmp_153_rule, p) + _PyPegen_lookahead(0, _tmp_155_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_tstring_replacement_field[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] !(':' | '}')")); @@ -27347,7 +27929,7 @@ invalid_tstring_replacement_field_rule(Parser *p) D(fprintf(stderr, "%*c> invalid_tstring_replacement_field[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}'")); Token * _literal; Token * _literal_1; - asdl_seq * _loop0_76_var; + asdl_seq * _loop0_78_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings void *_opt_var_1; @@ -27360,11 +27942,11 @@ invalid_tstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_152_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' && - (_loop0_76_var = _loop0_76_rule(p)) // fstring_format_spec* + (_loop0_78_var = _loop0_78_rule(p)) // fstring_format_spec* && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -27401,7 +27983,7 @@ invalid_tstring_replacement_field_rule(Parser *p) && (_opt_var = _PyPegen_expect_token(p, 22), !p->error_indicator) // '='? && - (_opt_var_1 = _tmp_152_rule(p), !p->error_indicator) // ['!' NAME] + (_opt_var_1 = _tmp_154_rule(p), !p->error_indicator) // ['!' NAME] && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 26) // token='}' ) @@ -27448,7 +28030,7 @@ invalid_tstring_conversion_character_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' && - _PyPegen_lookahead(1, _tmp_153_rule, p) + _PyPegen_lookahead(1, _tmp_155_rule, p) ) { D(fprintf(stderr, "%*c+ invalid_tstring_conversion_character[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' &(':' | '}')")); @@ -27520,7 +28102,7 @@ invalid_string_tstring_concat_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _loop1_80_rule(p)) // ((fstring | string))+ + (a = _loop1_82_rule(p)) // ((fstring | string))+ && (b = (expr_ty)tstring_rule(p)) // tstring ) @@ -27547,9 +28129,9 @@ invalid_string_tstring_concat_rule(Parser *p) asdl_seq * a; expr_ty b; if ( - (a = _loop1_81_rule(p)) // tstring+ + (a = _loop1_83_rule(p)) // tstring+ && - (b = (expr_ty)_tmp_154_rule(p)) // fstring | string + (b = (expr_ty)_tmp_156_rule(p)) // fstring | string ) { D(fprintf(stderr, "%*c+ invalid_string_tstring_concat[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tstring+ (fstring | string)")); @@ -27590,16 +28172,16 @@ invalid_arithmetic_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_arithmetic[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum ('+' | '-' | '*' | '/' | '%' | '//' | '@') 'not' inversion")); - void *_tmp_155_var; + void *_tmp_157_var; Token * a; expr_ty b; expr_ty sum_var; if ( (sum_var = sum_rule(p)) // sum && - (_tmp_155_var = _tmp_155_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' + (_tmp_157_var = _tmp_157_rule(p)) // '+' | '-' | '*' | '/' | '%' | '//' | '@' && - (a = _PyPegen_expect_token(p, 712)) // token='not' + (a = _PyPegen_expect_token(p, 716)) // token='not' && (b = inversion_rule(p)) // inversion ) @@ -27642,13 +28224,13 @@ invalid_factor_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> invalid_factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('+' | '-' | '~') 'not' factor")); - void *_tmp_156_var; + void *_tmp_158_var; Token * a; expr_ty b; if ( - (_tmp_156_var = _tmp_156_rule(p)) // '+' | '-' | '~' + (_tmp_158_var = _tmp_158_rule(p)) // '+' | '-' | '~' && - (a = _PyPegen_expect_token(p, 712)) // token='not' + (a = _PyPegen_expect_token(p, 716)) // token='not' && (b = factor_rule(p)) // factor ) @@ -27995,7 +28577,7 @@ _tmp_5_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 643)) // token='import' + (_keyword = _PyPegen_expect_token(p, 647)) // token='import' ) { D(fprintf(stderr, "%*c+ _tmp_5[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'")); @@ -28014,7 +28596,7 @@ _tmp_5_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 642)) // token='from' + (_keyword = _PyPegen_expect_token(p, 646)) // token='from' ) { D(fprintf(stderr, "%*c+ _tmp_5[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'")); @@ -28052,7 +28634,7 @@ _tmp_6_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 708)) // token='def' + (_keyword = _PyPegen_expect_token(p, 712)) // token='def' ) { D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'")); @@ -28090,7 +28672,7 @@ _tmp_6_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='async' + (_keyword = _PyPegen_expect_token(p, 711)) // token='async' ) { D(fprintf(stderr, "%*c+ _tmp_6[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'")); @@ -28128,7 +28710,7 @@ _tmp_7_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 710)) // token='class' + (_keyword = _PyPegen_expect_token(p, 714)) // token='class' ) { D(fprintf(stderr, "%*c+ _tmp_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'")); @@ -28185,7 +28767,7 @@ _tmp_8_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 656)) // token='with' + (_keyword = _PyPegen_expect_token(p, 660)) // token='with' ) { D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'")); @@ -28204,7 +28786,7 @@ _tmp_8_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='async' + (_keyword = _PyPegen_expect_token(p, 711)) // token='async' ) { D(fprintf(stderr, "%*c+ _tmp_8[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'")); @@ -28242,7 +28824,7 @@ _tmp_9_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 703)) // token='for' + (_keyword = _PyPegen_expect_token(p, 707)) // token='for' ) { D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'")); @@ -28261,7 +28843,7 @@ _tmp_9_rule(Parser *p) D(fprintf(stderr, "%*c> _tmp_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'async'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 707)) // token='async' + (_keyword = _PyPegen_expect_token(p, 711)) // token='async' ) { D(fprintf(stderr, "%*c+ _tmp_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'async'")); @@ -28420,12 +29002,12 @@ _loop1_12_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); - void *_tmp_157_var; + void *_tmp_159_var; while ( - (_tmp_157_var = _tmp_157_rule(p)) // star_targets '=' + (_tmp_159_var = _tmp_159_rule(p)) // star_targets '=' ) { - _res = _tmp_157_var; + _res = _tmp_159_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -28712,12 +29294,12 @@ _loop0_17_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop0_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_158_var; + void *_tmp_160_var; while ( - (_tmp_158_var = _tmp_158_rule(p)) // '.' | '...' + (_tmp_160_var = _tmp_160_rule(p)) // '.' | '...' ) { - _res = _tmp_158_var; + _res = _tmp_160_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -28779,12 +29361,12 @@ _loop1_18_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); - void *_tmp_158_var; + void *_tmp_160_var; while ( - (_tmp_158_var = _tmp_158_rule(p)) // '.' | '...' + (_tmp_160_var = _tmp_160_rule(p)) // '.' | '...' ) { - _res = _tmp_158_var; + _res = _tmp_160_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -28962,7 +29544,7 @@ _tmp_21_rule(Parser *p) Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) @@ -29131,12 +29713,12 @@ _loop1_24_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); - void *_tmp_159_var; + void *_tmp_161_var; while ( - (_tmp_159_var = _tmp_159_rule(p)) // '@' named_expression NEWLINE + (_tmp_161_var = _tmp_161_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_159_var; + _res = _tmp_161_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31164,12 +31746,12 @@ _loop1_56_rule(Parser *p) return NULL; } D(fprintf(stderr, "%*c> _loop1_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); - void *_tmp_160_var; + void *_tmp_162_var; while ( - (_tmp_160_var = _tmp_160_rule(p)) // ',' star_expression + (_tmp_162_var = _tmp_162_rule(p)) // ',' star_expression ) { - _res = _tmp_160_var; + _res = _tmp_162_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31325,9 +31907,126 @@ _gather_58_rule(Parser *p) return _res; } -// _loop1_59: ('or' conjunction) +// _loop0_59: ',' star_named_expression_sequence static asdl_seq * -_loop1_59_rule(Parser *p) +_loop0_59_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void *_res = NULL; + int _mark = p->mark; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + Py_ssize_t _children_capacity = 1; + Py_ssize_t _n = 0; + { // ',' star_named_expression_sequence + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _loop0_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_expression_sequence")); + Token * _literal; + expr_ty elem; + while ( + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (elem = star_named_expression_sequence_rule(p)) // star_named_expression_sequence + ) + { + _res = elem; + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + PyMem_Free(_children); + p->level--; + return NULL; + } + if (_n == _children_capacity) { + _children_capacity *= 2; + void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_new_children) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + _children = _new_children; + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _loop0_59[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_named_expression_sequence")); + } + asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); + if (!_seq) { + PyMem_Free(_children); + p->error_indicator = 1; + PyErr_NoMemory(); + p->level--; + return NULL; + } + for (Py_ssize_t i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]); + PyMem_Free(_children); + p->level--; + return _seq; +} + +// _gather_60: star_named_expression_sequence _loop0_59 +static asdl_seq * +_gather_60_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + asdl_seq * _res = NULL; + int _mark = p->mark; + { // star_named_expression_sequence _loop0_59 + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _gather_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression_sequence _loop0_59")); + expr_ty elem; + asdl_seq * seq; + if ( + (elem = star_named_expression_sequence_rule(p)) // star_named_expression_sequence + && + (seq = _loop0_59_rule(p)) // _loop0_59 + ) + { + D(fprintf(stderr, "%*c+ _gather_60[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression_sequence _loop0_59")); + _res = _PyPegen_seq_insert_in_front(p, elem, seq); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _gather_60[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression_sequence _loop0_59")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _loop1_61: ('or' conjunction) +static asdl_seq * +_loop1_61_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31352,13 +32051,13 @@ _loop1_59_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); - void *_tmp_161_var; + D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); + void *_tmp_163_var; while ( - (_tmp_161_var = _tmp_161_rule(p)) // 'or' conjunction + (_tmp_163_var = _tmp_163_rule(p)) // 'or' conjunction ) { - _res = _tmp_161_var; + _res = _tmp_163_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31375,7 +32074,7 @@ _loop1_59_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_59[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('or' conjunction)")); } if (_n == 0 || p->error_indicator) { @@ -31397,9 +32096,9 @@ _loop1_59_rule(Parser *p) return _seq; } -// _loop1_60: ('and' inversion) +// _loop1_62: ('and' inversion) static asdl_seq * -_loop1_60_rule(Parser *p) +_loop1_62_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31424,13 +32123,13 @@ _loop1_60_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); - void *_tmp_162_var; + D(fprintf(stderr, "%*c> _loop1_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); + void *_tmp_164_var; while ( - (_tmp_162_var = _tmp_162_rule(p)) // 'and' inversion + (_tmp_164_var = _tmp_164_rule(p)) // 'and' inversion ) { - _res = _tmp_162_var; + _res = _tmp_164_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -31447,7 +32146,7 @@ _loop1_60_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_60[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_62[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('and' inversion)")); } if (_n == 0 || p->error_indicator) { @@ -31469,9 +32168,9 @@ _loop1_60_rule(Parser *p) return _seq; } -// _loop1_61: compare_op_bitwise_or_pair +// _loop1_63: compare_op_bitwise_or_pair static asdl_seq * -_loop1_61_rule(Parser *p) +_loop1_63_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31496,7 +32195,7 @@ _loop1_61_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair")); + D(fprintf(stderr, "%*c> _loop1_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair")); CmpopExprPair* compare_op_bitwise_or_pair_var; while ( (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p)) // compare_op_bitwise_or_pair @@ -31519,7 +32218,7 @@ _loop1_61_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_63[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compare_op_bitwise_or_pair")); } if (_n == 0 || p->error_indicator) { @@ -31541,9 +32240,9 @@ _loop1_61_rule(Parser *p) return _seq; } -// _tmp_62: '!=' +// _tmp_64: '!=' static void * -_tmp_62_rule(Parser *p) +_tmp_64_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31559,13 +32258,13 @@ _tmp_62_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='")); + D(fprintf(stderr, "%*c> _tmp_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='")); Token * tok; if ( (tok = _PyPegen_expect_token(p, 28)) // token='!=' ) { - D(fprintf(stderr, "%*c+ _tmp_62[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='")); + D(fprintf(stderr, "%*c+ _tmp_64[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='")); _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31575,7 +32274,7 @@ _tmp_62_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_62[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_64[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='")); } _res = NULL; @@ -31584,9 +32283,9 @@ _tmp_62_rule(Parser *p) return _res; } -// _loop0_63: ',' (slice | starred_expression) +// _loop0_65: ',' (slice | starred_expression) static asdl_seq * -_loop0_63_rule(Parser *p) +_loop0_65_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31611,13 +32310,13 @@ _loop0_63_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (slice | starred_expression)")); + D(fprintf(stderr, "%*c> _loop0_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (slice | starred_expression)")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_163_rule(p)) // slice | starred_expression + (elem = _tmp_165_rule(p)) // slice | starred_expression ) { _res = elem; @@ -31643,7 +32342,7 @@ _loop0_63_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_63[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_65[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (slice | starred_expression)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -31660,9 +32359,9 @@ _loop0_63_rule(Parser *p) return _seq; } -// _gather_64: (slice | starred_expression) _loop0_63 +// _gather_66: (slice | starred_expression) _loop0_65 static asdl_seq * -_gather_64_rule(Parser *p) +_gather_66_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31673,27 +32372,27 @@ _gather_64_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (slice | starred_expression) _loop0_63 + { // (slice | starred_expression) _loop0_65 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_63")); + D(fprintf(stderr, "%*c> _gather_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_65")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_163_rule(p)) // slice | starred_expression + (elem = _tmp_165_rule(p)) // slice | starred_expression && - (seq = _loop0_63_rule(p)) // _loop0_63 + (seq = _loop0_65_rule(p)) // _loop0_65 ) { - D(fprintf(stderr, "%*c+ _gather_64[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_63")); + D(fprintf(stderr, "%*c+ _gather_66[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(slice | starred_expression) _loop0_65")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_64[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slice | starred_expression) _loop0_63")); + D(fprintf(stderr, "%*c%s _gather_66[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slice | starred_expression) _loop0_65")); } _res = NULL; done: @@ -31701,9 +32400,9 @@ _gather_64_rule(Parser *p) return _res; } -// _tmp_65: ':' expression? +// _tmp_67: ':' expression? static void * -_tmp_65_rule(Parser *p) +_tmp_67_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31719,7 +32418,7 @@ _tmp_65_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?")); + D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?")); Token * _literal; void *d; if ( @@ -31728,7 +32427,7 @@ _tmp_65_rule(Parser *p) (d = expression_rule(p), !p->error_indicator) // expression? ) { - D(fprintf(stderr, "%*c+ _tmp_65[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?")); + D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?")); _res = d; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -31738,7 +32437,7 @@ _tmp_65_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_65[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?")); } _res = NULL; @@ -31747,9 +32446,9 @@ _tmp_65_rule(Parser *p) return _res; } -// _tmp_66: tuple | group | genexp +// _tmp_68: genexp | tuple | group static void * -_tmp_66_rule(Parser *p) +_tmp_68_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31760,62 +32459,62 @@ _tmp_66_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // tuple + { // genexp if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); - expr_ty tuple_var; + D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); + expr_ty genexp_var; if ( - (tuple_var = tuple_rule(p)) // tuple + (genexp_var = genexp_rule(p)) // genexp ) { - D(fprintf(stderr, "%*c+ _tmp_66[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); - _res = tuple_var; + D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); + _res = genexp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); } - { // group + { // tuple if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group")); - expr_ty group_var; + D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); + expr_ty tuple_var; if ( - (group_var = group_rule(p)) // group + (tuple_var = tuple_rule(p)) // tuple ) { - D(fprintf(stderr, "%*c+ _tmp_66[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group")); - _res = group_var; + D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); + _res = tuple_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group")); + D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); } - { // genexp + { // group if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); - expr_ty genexp_var; + D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group")); + expr_ty group_var; if ( - (genexp_var = genexp_rule(p)) // genexp + (group_var = group_rule(p)) // group ) { - D(fprintf(stderr, "%*c+ _tmp_66[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); - _res = genexp_var; + D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group")); + _res = group_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group")); } _res = NULL; done: @@ -31823,9 +32522,9 @@ _tmp_66_rule(Parser *p) return _res; } -// _tmp_67: list | listcomp +// _tmp_69: listcomp | list static void * -_tmp_67_rule(Parser *p) +_tmp_69_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31836,43 +32535,43 @@ _tmp_67_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // list + { // listcomp if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); - expr_ty list_var; + D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp")); + expr_ty listcomp_var; if ( - (list_var = list_rule(p)) // list + (listcomp_var = listcomp_rule(p)) // listcomp ) { - D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); - _res = list_var; + D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp")); + _res = listcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); + D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp")); } - { // listcomp + { // list if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp")); - expr_ty listcomp_var; + D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); + expr_ty list_var; if ( - (listcomp_var = listcomp_rule(p)) // listcomp + (list_var = list_rule(p)) // list ) { - D(fprintf(stderr, "%*c+ _tmp_67[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp")); - _res = listcomp_var; + D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); + _res = list_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp")); + D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); } _res = NULL; done: @@ -31880,9 +32579,9 @@ _tmp_67_rule(Parser *p) return _res; } -// _tmp_68: dict | set | dictcomp | setcomp +// _tmp_70: dictcomp | setcomp | dict | set static void * -_tmp_68_rule(Parser *p) +_tmp_70_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31893,81 +32592,81 @@ _tmp_68_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // dict + { // dictcomp if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict")); - expr_ty dict_var; + D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp")); + expr_ty dictcomp_var; if ( - (dict_var = dict_rule(p)) // dict + (dictcomp_var = dictcomp_rule(p)) // dictcomp ) { - D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict")); - _res = dict_var; + D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp")); + _res = dictcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict")); + D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp")); } - { // set + { // setcomp if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set")); - expr_ty set_var; + D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp")); + expr_ty setcomp_var; if ( - (set_var = set_rule(p)) // set + (setcomp_var = setcomp_rule(p)) // setcomp ) { - D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set")); - _res = set_var; + D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp")); + _res = setcomp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "set")); + D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp")); } - { // dictcomp + { // dict if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp")); - expr_ty dictcomp_var; + D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict")); + expr_ty dict_var; if ( - (dictcomp_var = dictcomp_rule(p)) // dictcomp + (dict_var = dict_rule(p)) // dict ) { - D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp")); - _res = dictcomp_var; + D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict")); + _res = dict_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp")); + D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict")); } - { // setcomp + { // set if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp")); - expr_ty setcomp_var; + D(fprintf(stderr, "%*c> _tmp_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set")); + expr_ty set_var; if ( - (setcomp_var = setcomp_rule(p)) // setcomp + (set_var = set_rule(p)) // set ) { - D(fprintf(stderr, "%*c+ _tmp_68[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp")); - _res = setcomp_var; + D(fprintf(stderr, "%*c+ _tmp_70[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set")); + _res = set_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp")); + D(fprintf(stderr, "%*c%s _tmp_70[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "set")); } _res = NULL; done: @@ -31975,9 +32674,9 @@ _tmp_68_rule(Parser *p) return _res; } -// _tmp_69: yield_expr | named_expression +// _tmp_71: yield_expr | named_expression static void * -_tmp_69_rule(Parser *p) +_tmp_71_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -31993,18 +32692,18 @@ _tmp_69_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); + D(fprintf(stderr, "%*c> _tmp_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); expr_ty yield_expr_var; if ( (yield_expr_var = yield_expr_rule(p)) // yield_expr ) { - D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); + D(fprintf(stderr, "%*c+ _tmp_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); _res = yield_expr_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_71[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); } { // named_expression @@ -32012,18 +32711,18 @@ _tmp_69_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); + D(fprintf(stderr, "%*c> _tmp_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); expr_ty named_expression_var; if ( (named_expression_var = named_expression_rule(p)) // named_expression ) { - D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); + D(fprintf(stderr, "%*c+ _tmp_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); _res = named_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_71[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); } _res = NULL; @@ -32032,9 +32731,9 @@ _tmp_69_rule(Parser *p) return _res; } -// _loop0_70: lambda_param_no_default +// _loop0_72: lambda_param_no_default static asdl_seq * -_loop0_70_rule(Parser *p) +_loop0_72_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32059,7 +32758,7 @@ _loop0_70_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -32082,7 +32781,7 @@ _loop0_70_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_70[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_72[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32099,9 +32798,9 @@ _loop0_70_rule(Parser *p) return _seq; } -// _loop0_71: lambda_param_with_default +// _loop0_73: lambda_param_with_default static asdl_seq * -_loop0_71_rule(Parser *p) +_loop0_73_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32126,7 +32825,7 @@ _loop0_71_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop0_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -32149,7 +32848,7 @@ _loop0_71_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_71[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_73[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32166,9 +32865,9 @@ _loop0_71_rule(Parser *p) return _seq; } -// _loop1_72: lambda_param_no_default +// _loop1_74: lambda_param_no_default static asdl_seq * -_loop1_72_rule(Parser *p) +_loop1_74_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32193,7 +32892,7 @@ _loop1_72_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _loop1_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; while ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default @@ -32216,7 +32915,7 @@ _loop1_72_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_72[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_74[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } if (_n == 0 || p->error_indicator) { @@ -32238,9 +32937,9 @@ _loop1_72_rule(Parser *p) return _seq; } -// _loop1_73: lambda_param_with_default +// _loop1_75: lambda_param_with_default static asdl_seq * -_loop1_73_rule(Parser *p) +_loop1_75_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32265,7 +32964,7 @@ _loop1_73_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); + D(fprintf(stderr, "%*c> _loop1_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); NameDefaultPair* lambda_param_with_default_var; while ( (lambda_param_with_default_var = lambda_param_with_default_rule(p)) // lambda_param_with_default @@ -32288,7 +32987,7 @@ _loop1_73_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_73[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_75[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); } if (_n == 0 || p->error_indicator) { @@ -32310,9 +33009,9 @@ _loop1_73_rule(Parser *p) return _seq; } -// _loop0_74: lambda_param_maybe_default +// _loop0_76: lambda_param_maybe_default static asdl_seq * -_loop0_74_rule(Parser *p) +_loop0_76_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32337,7 +33036,7 @@ _loop0_74_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop0_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -32360,7 +33059,7 @@ _loop0_74_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_74[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_76[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32377,9 +33076,9 @@ _loop0_74_rule(Parser *p) return _seq; } -// _loop1_75: lambda_param_maybe_default +// _loop1_77: lambda_param_maybe_default static asdl_seq * -_loop1_75_rule(Parser *p) +_loop1_77_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32404,7 +33103,7 @@ _loop1_75_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); + D(fprintf(stderr, "%*c> _loop1_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); NameDefaultPair* lambda_param_maybe_default_var; while ( (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p)) // lambda_param_maybe_default @@ -32427,7 +33126,7 @@ _loop1_75_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_75[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_77[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); } if (_n == 0 || p->error_indicator) { @@ -32449,9 +33148,9 @@ _loop1_75_rule(Parser *p) return _seq; } -// _loop0_76: fstring_format_spec +// _loop0_78: fstring_format_spec static asdl_seq * -_loop0_76_rule(Parser *p) +_loop0_78_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32476,7 +33175,7 @@ _loop0_76_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec")); expr_ty fstring_format_spec_var; while ( (fstring_format_spec_var = fstring_format_spec_rule(p)) // fstring_format_spec @@ -32499,7 +33198,7 @@ _loop0_76_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_76[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_78[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_format_spec")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32516,9 +33215,9 @@ _loop0_76_rule(Parser *p) return _seq; } -// _loop0_77: fstring_middle +// _loop0_79: fstring_middle static asdl_seq * -_loop0_77_rule(Parser *p) +_loop0_79_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32543,7 +33242,7 @@ _loop0_77_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_middle")); + D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_middle")); expr_ty fstring_middle_var; while ( (fstring_middle_var = fstring_middle_rule(p)) // fstring_middle @@ -32566,7 +33265,7 @@ _loop0_77_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_77[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_79[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_middle")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32583,9 +33282,9 @@ _loop0_77_rule(Parser *p) return _seq; } -// _loop0_78: tstring_format_spec +// _loop0_80: tstring_format_spec static asdl_seq * -_loop0_78_rule(Parser *p) +_loop0_80_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32610,7 +33309,7 @@ _loop0_78_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_format_spec")); + D(fprintf(stderr, "%*c> _loop0_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_format_spec")); expr_ty tstring_format_spec_var; while ( (tstring_format_spec_var = tstring_format_spec_rule(p)) // tstring_format_spec @@ -32633,7 +33332,7 @@ _loop0_78_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_78[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_80[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_format_spec")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32650,9 +33349,9 @@ _loop0_78_rule(Parser *p) return _seq; } -// _loop0_79: tstring_middle +// _loop0_81: tstring_middle static asdl_seq * -_loop0_79_rule(Parser *p) +_loop0_81_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32677,7 +33376,7 @@ _loop0_79_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_middle")); + D(fprintf(stderr, "%*c> _loop0_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_middle")); expr_ty tstring_middle_var; while ( (tstring_middle_var = tstring_middle_rule(p)) // tstring_middle @@ -32700,7 +33399,7 @@ _loop0_79_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_79[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_81[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_middle")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32717,9 +33416,9 @@ _loop0_79_rule(Parser *p) return _seq; } -// _loop1_80: (fstring | string) +// _loop1_82: (fstring | string) static asdl_seq * -_loop1_80_rule(Parser *p) +_loop1_82_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32744,13 +33443,13 @@ _loop1_80_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); - void *_tmp_154_var; + D(fprintf(stderr, "%*c> _loop1_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)")); + void *_tmp_156_var; while ( - (_tmp_154_var = _tmp_154_rule(p)) // fstring | string + (_tmp_156_var = _tmp_156_rule(p)) // fstring | string ) { - _res = _tmp_154_var; + _res = _tmp_156_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -32767,7 +33466,7 @@ _loop1_80_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_82[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(fstring | string)")); } if (_n == 0 || p->error_indicator) { @@ -32789,9 +33488,9 @@ _loop1_80_rule(Parser *p) return _seq; } -// _loop1_81: tstring +// _loop1_83: tstring static asdl_seq * -_loop1_81_rule(Parser *p) +_loop1_83_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32816,7 +33515,7 @@ _loop1_81_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring")); + D(fprintf(stderr, "%*c> _loop1_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring")); expr_ty tstring_var; while ( (tstring_var = tstring_rule(p)) // tstring @@ -32839,7 +33538,7 @@ _loop1_81_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_81[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_83[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring")); } if (_n == 0 || p->error_indicator) { @@ -32861,9 +33560,9 @@ _loop1_81_rule(Parser *p) return _seq; } -// _tmp_82: star_named_expression ',' star_named_expressions? +// _tmp_84: star_named_expression_sequence ',' star_named_expressions_sequence? static void * -_tmp_82_rule(Parser *p) +_tmp_84_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32874,24 +33573,24 @@ _tmp_82_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // star_named_expression ',' star_named_expressions? + { // star_named_expression_sequence ',' star_named_expressions_sequence? if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c> _tmp_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression_sequence ',' star_named_expressions_sequence?")); Token * _literal; expr_ty y; void *z; if ( - (y = star_named_expression_rule(p)) // star_named_expression + (y = star_named_expression_sequence_rule(p)) // star_named_expression_sequence && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (z = star_named_expressions_rule(p), !p->error_indicator) // star_named_expressions? + (z = star_named_expressions_sequence_rule(p), !p->error_indicator) // star_named_expressions_sequence? ) { - D(fprintf(stderr, "%*c+ _tmp_82[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c+ _tmp_84[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression_sequence ',' star_named_expressions_sequence?")); _res = _PyPegen_seq_insert_in_front ( p , y , z ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -32901,8 +33600,8 @@ _tmp_82_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_82[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); + D(fprintf(stderr, "%*c%s _tmp_84[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression_sequence ',' star_named_expressions_sequence?")); } _res = NULL; done: @@ -32910,9 +33609,9 @@ _tmp_82_rule(Parser *p) return _res; } -// _loop0_83: ',' double_starred_kvpair +// _loop0_85: ',' double_starred_kvpair static asdl_seq * -_loop0_83_rule(Parser *p) +_loop0_85_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32937,7 +33636,7 @@ _loop0_83_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); + D(fprintf(stderr, "%*c> _loop0_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); Token * _literal; KeyValuePair* elem; while ( @@ -32969,7 +33668,7 @@ _loop0_83_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_83[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_85[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -32986,9 +33685,9 @@ _loop0_83_rule(Parser *p) return _seq; } -// _gather_84: double_starred_kvpair _loop0_83 +// _gather_86: double_starred_kvpair _loop0_85 static asdl_seq * -_gather_84_rule(Parser *p) +_gather_86_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -32999,27 +33698,27 @@ _gather_84_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // double_starred_kvpair _loop0_83 + { // double_starred_kvpair _loop0_85 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_83")); + D(fprintf(stderr, "%*c> _gather_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_85")); KeyValuePair* elem; asdl_seq * seq; if ( (elem = double_starred_kvpair_rule(p)) // double_starred_kvpair && - (seq = _loop0_83_rule(p)) // _loop0_83 + (seq = _loop0_85_rule(p)) // _loop0_85 ) { - D(fprintf(stderr, "%*c+ _gather_84[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_83")); + D(fprintf(stderr, "%*c+ _gather_86[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_85")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_84[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_83")); + D(fprintf(stderr, "%*c%s _gather_86[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_85")); } _res = NULL; done: @@ -33027,9 +33726,9 @@ _gather_84_rule(Parser *p) return _res; } -// _loop1_85: for_if_clause +// _loop1_87: for_if_clause static asdl_seq * -_loop1_85_rule(Parser *p) +_loop1_87_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33054,7 +33753,7 @@ _loop1_85_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); + 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 ( (for_if_clause_var = for_if_clause_rule(p)) // for_if_clause @@ -33077,7 +33776,7 @@ _loop1_85_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_85[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_87[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause")); } if (_n == 0 || p->error_indicator) { @@ -33099,9 +33798,9 @@ _loop1_85_rule(Parser *p) return _seq; } -// _loop0_86: ('if' disjunction) +// _loop0_88: ('if' disjunction) static asdl_seq * -_loop0_86_rule(Parser *p) +_loop0_88_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33126,13 +33825,13 @@ _loop0_86_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); - void *_tmp_164_var; + D(fprintf(stderr, "%*c> _loop0_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); + void *_tmp_166_var; while ( - (_tmp_164_var = _tmp_164_rule(p)) // 'if' disjunction + (_tmp_166_var = _tmp_166_rule(p)) // 'if' disjunction ) { - _res = _tmp_164_var; + _res = _tmp_166_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -33149,7 +33848,7 @@ _loop0_86_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_86[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_88[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33166,9 +33865,9 @@ _loop0_86_rule(Parser *p) return _seq; } -// _tmp_87: assignment_expression | expression !':=' +// _tmp_89: assignment_expression | expression !':=' | starred_expression static void * -_tmp_87_rule(Parser *p) +_tmp_89_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33184,18 +33883,18 @@ _tmp_87_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); expr_ty assignment_expression_var; if ( (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression ) { - D(fprintf(stderr, "%*c+ _tmp_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); _res = assignment_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_87[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); } { // expression !':=' @@ -33203,7 +33902,7 @@ _tmp_87_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression @@ -33211,23 +33910,42 @@ _tmp_87_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_87[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); + D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); _res = expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_87[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); } + { // starred_expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + expr_ty starred_expression_var; + if ( + (starred_expression_var = starred_expression_rule(p)) // starred_expression + ) + { + D(fprintf(stderr, "%*c+ _tmp_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + _res = starred_expression_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); + } _res = NULL; done: p->level--; return _res; } -// _loop0_88: ',' (starred_expression | (assignment_expression | expression !':=') !'=') +// _loop0_90: ',' (starred_expression | (assignment_expression | expression !':=') !'=') static asdl_seq * -_loop0_88_rule(Parser *p) +_loop0_90_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33252,13 +33970,13 @@ _loop0_88_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); + D(fprintf(stderr, "%*c> _loop0_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_165_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_167_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' ) { _res = elem; @@ -33284,7 +34002,7 @@ _loop0_88_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_88[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_90[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | (assignment_expression | expression !':=') !'=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33301,10 +34019,10 @@ _loop0_88_rule(Parser *p) return _seq; } -// _gather_89: -// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88 +// _gather_91: +// | (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90 static asdl_seq * -_gather_89_rule(Parser *p) +_gather_91_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33315,27 +34033,27 @@ _gather_89_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88 + { // (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88")); + D(fprintf(stderr, "%*c> _gather_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_165_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' + (elem = _tmp_167_rule(p)) // starred_expression | (assignment_expression | expression !':=') !'=' && - (seq = _loop0_88_rule(p)) // _loop0_88 + (seq = _loop0_90_rule(p)) // _loop0_90 ) { - D(fprintf(stderr, "%*c+ _gather_89[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88")); + D(fprintf(stderr, "%*c+ _gather_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_89[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_88")); + D(fprintf(stderr, "%*c%s _gather_91[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | (assignment_expression | expression !':=') !'=') _loop0_90")); } _res = NULL; done: @@ -33343,9 +34061,9 @@ _gather_89_rule(Parser *p) return _res; } -// _tmp_90: ',' kwargs +// _tmp_92: ',' kwargs static void * -_tmp_90_rule(Parser *p) +_tmp_92_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33361,7 +34079,7 @@ _tmp_90_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c> _tmp_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); Token * _literal; asdl_seq* k; if ( @@ -33370,7 +34088,7 @@ _tmp_90_rule(Parser *p) (k = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_90[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); + D(fprintf(stderr, "%*c+ _tmp_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); _res = k; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -33380,7 +34098,7 @@ _tmp_90_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_90[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_92[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs")); } _res = NULL; @@ -33389,9 +34107,9 @@ _tmp_90_rule(Parser *p) return _res; } -// _loop0_91: ',' kwarg_or_starred +// _loop0_93: ',' kwarg_or_starred static asdl_seq * -_loop0_91_rule(Parser *p) +_loop0_93_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33416,7 +34134,7 @@ _loop0_91_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); + D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -33448,7 +34166,7 @@ _loop0_91_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_91[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_93[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33465,9 +34183,9 @@ _loop0_91_rule(Parser *p) return _seq; } -// _gather_92: kwarg_or_starred _loop0_91 +// _gather_94: kwarg_or_starred _loop0_93 static asdl_seq * -_gather_92_rule(Parser *p) +_gather_94_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33478,27 +34196,27 @@ _gather_92_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_91 + { // kwarg_or_starred _loop0_93 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_91")); + D(fprintf(stderr, "%*c> _gather_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_93")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_91_rule(p)) // _loop0_91 + (seq = _loop0_93_rule(p)) // _loop0_93 ) { - D(fprintf(stderr, "%*c+ _gather_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_91")); + D(fprintf(stderr, "%*c+ _gather_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_93")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_92[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_91")); + D(fprintf(stderr, "%*c%s _gather_94[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_93")); } _res = NULL; done: @@ -33506,9 +34224,9 @@ _gather_92_rule(Parser *p) return _res; } -// _loop0_93: ',' kwarg_or_double_starred +// _loop0_95: ',' kwarg_or_double_starred static asdl_seq * -_loop0_93_rule(Parser *p) +_loop0_95_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33533,7 +34251,7 @@ _loop0_93_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); + D(fprintf(stderr, "%*c> _loop0_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); Token * _literal; KeywordOrStarred* elem; while ( @@ -33565,7 +34283,7 @@ _loop0_93_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_93[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_95[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33582,9 +34300,9 @@ _loop0_93_rule(Parser *p) return _seq; } -// _gather_94: kwarg_or_double_starred _loop0_93 +// _gather_96: kwarg_or_double_starred _loop0_95 static asdl_seq * -_gather_94_rule(Parser *p) +_gather_96_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33595,27 +34313,27 @@ _gather_94_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_93 + { // kwarg_or_double_starred _loop0_95 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_93")); + D(fprintf(stderr, "%*c> _gather_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_95")); KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_93_rule(p)) // _loop0_93 + (seq = _loop0_95_rule(p)) // _loop0_95 ) { - D(fprintf(stderr, "%*c+ _gather_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_93")); + D(fprintf(stderr, "%*c+ _gather_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_95")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_94[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_93")); + D(fprintf(stderr, "%*c%s _gather_96[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_95")); } _res = NULL; done: @@ -33623,9 +34341,9 @@ _gather_94_rule(Parser *p) return _res; } -// _loop0_95: (',' star_target) +// _loop0_97: (',' star_target) static asdl_seq * -_loop0_95_rule(Parser *p) +_loop0_97_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33650,13 +34368,13 @@ _loop0_95_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_166_var; + D(fprintf(stderr, "%*c> _loop0_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_168_var; while ( - (_tmp_166_var = _tmp_166_rule(p)) // ',' star_target + (_tmp_168_var = _tmp_168_rule(p)) // ',' star_target ) { - _res = _tmp_166_var; + _res = _tmp_168_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -33673,7 +34391,7 @@ _loop0_95_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_95[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_97[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33690,9 +34408,9 @@ _loop0_95_rule(Parser *p) return _seq; } -// _loop0_96: ',' star_target +// _loop0_98: ',' star_target static asdl_seq * -_loop0_96_rule(Parser *p) +_loop0_98_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33717,7 +34435,7 @@ _loop0_96_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c> _loop0_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty elem; while ( @@ -33749,7 +34467,7 @@ _loop0_96_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_96[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_98[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33766,9 +34484,9 @@ _loop0_96_rule(Parser *p) return _seq; } -// _gather_97: star_target _loop0_96 +// _gather_99: star_target _loop0_98 static asdl_seq * -_gather_97_rule(Parser *p) +_gather_99_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33779,27 +34497,27 @@ _gather_97_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_96 + { // star_target _loop0_98 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_96")); + D(fprintf(stderr, "%*c> _gather_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_98")); expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_96_rule(p)) // _loop0_96 + (seq = _loop0_98_rule(p)) // _loop0_98 ) { - D(fprintf(stderr, "%*c+ _gather_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_96")); + D(fprintf(stderr, "%*c+ _gather_99[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_98")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_97[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_96")); + D(fprintf(stderr, "%*c%s _gather_99[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_98")); } _res = NULL; done: @@ -33807,9 +34525,9 @@ _gather_97_rule(Parser *p) return _res; } -// _loop1_98: (',' star_target) +// _loop1_100: (',' star_target) static asdl_seq * -_loop1_98_rule(Parser *p) +_loop1_100_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33834,13 +34552,13 @@ _loop1_98_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); - void *_tmp_166_var; + D(fprintf(stderr, "%*c> _loop1_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); + void *_tmp_168_var; while ( - (_tmp_166_var = _tmp_166_rule(p)) // ',' star_target + (_tmp_168_var = _tmp_168_rule(p)) // ',' star_target ) { - _res = _tmp_166_var; + _res = _tmp_168_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -33857,7 +34575,7 @@ _loop1_98_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_98[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_100[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); } if (_n == 0 || p->error_indicator) { @@ -33879,9 +34597,9 @@ _loop1_98_rule(Parser *p) return _seq; } -// _tmp_99: !'*' star_target +// _tmp_101: !'*' star_target static void * -_tmp_99_rule(Parser *p) +_tmp_101_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33897,7 +34615,7 @@ _tmp_99_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c> _tmp_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); expr_ty star_target_var; if ( _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*' @@ -33905,12 +34623,12 @@ _tmp_99_rule(Parser *p) (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_99[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); + D(fprintf(stderr, "%*c+ _tmp_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); _res = star_target_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_99[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_101[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); } _res = NULL; @@ -33919,9 +34637,9 @@ _tmp_99_rule(Parser *p) return _res; } -// _loop0_100: ',' del_target +// _loop0_102: ',' del_target static asdl_seq * -_loop0_100_rule(Parser *p) +_loop0_102_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -33946,7 +34664,7 @@ _loop0_100_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); + D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); Token * _literal; expr_ty elem; while ( @@ -33978,7 +34696,7 @@ _loop0_100_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_100[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_102[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' del_target")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -33995,9 +34713,9 @@ _loop0_100_rule(Parser *p) return _seq; } -// _gather_101: del_target _loop0_100 +// _gather_103: del_target _loop0_102 static asdl_seq * -_gather_101_rule(Parser *p) +_gather_103_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34008,27 +34726,27 @@ _gather_101_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_100 + { // del_target _loop0_102 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_100")); + D(fprintf(stderr, "%*c> _gather_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_102")); expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_target && - (seq = _loop0_100_rule(p)) // _loop0_100 + (seq = _loop0_102_rule(p)) // _loop0_102 ) { - D(fprintf(stderr, "%*c+ _gather_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_100")); + D(fprintf(stderr, "%*c+ _gather_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_102")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_101[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_100")); + D(fprintf(stderr, "%*c%s _gather_103[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_102")); } _res = NULL; done: @@ -34036,9 +34754,9 @@ _gather_101_rule(Parser *p) return _res; } -// _loop0_102: ',' expression +// _loop0_104: ',' expression static asdl_seq * -_loop0_102_rule(Parser *p) +_loop0_104_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34063,7 +34781,7 @@ _loop0_102_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); + D(fprintf(stderr, "%*c> _loop0_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); Token * _literal; expr_ty elem; while ( @@ -34095,7 +34813,7 @@ _loop0_102_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_102[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_104[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34112,9 +34830,9 @@ _loop0_102_rule(Parser *p) return _seq; } -// _gather_103: expression _loop0_102 +// _gather_105: expression _loop0_104 static asdl_seq * -_gather_103_rule(Parser *p) +_gather_105_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34125,27 +34843,27 @@ _gather_103_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // expression _loop0_102 + { // expression _loop0_104 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_102")); + D(fprintf(stderr, "%*c> _gather_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_104")); expr_ty elem; asdl_seq * seq; if ( (elem = expression_rule(p)) // expression && - (seq = _loop0_102_rule(p)) // _loop0_102 + (seq = _loop0_104_rule(p)) // _loop0_104 ) { - D(fprintf(stderr, "%*c+ _gather_103[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_102")); + D(fprintf(stderr, "%*c+ _gather_105[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_104")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_103[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_102")); + D(fprintf(stderr, "%*c%s _gather_105[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_104")); } _res = NULL; done: @@ -34153,9 +34871,9 @@ _gather_103_rule(Parser *p) return _res; } -// _tmp_104: NEWLINE INDENT +// _tmp_106: NEWLINE INDENT static void * -_tmp_104_rule(Parser *p) +_tmp_106_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34171,7 +34889,7 @@ _tmp_104_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c> _tmp_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); Token * indent_var; Token * newline_var; if ( @@ -34180,12 +34898,12 @@ _tmp_104_rule(Parser *p) (indent_var = _PyPegen_expect_token(p, INDENT)) // token='INDENT' ) { - D(fprintf(stderr, "%*c+ _tmp_104[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); + D(fprintf(stderr, "%*c+ _tmp_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); _res = _PyPegen_dummy_name(p, newline_var, indent_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_104[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_106[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT")); } _res = NULL; @@ -34194,11 +34912,11 @@ _tmp_104_rule(Parser *p) return _res; } -// _tmp_105: +// _tmp_107: // | (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) // | kwargs static void * -_tmp_105_rule(Parser *p) +_tmp_107_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34214,18 +34932,18 @@ _tmp_105_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - void *_tmp_167_var; + D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + void *_tmp_169_var; if ( - (_tmp_167_var = _tmp_167_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs + (_tmp_169_var = _tmp_169_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_105[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); - _res = _tmp_167_var; + D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); + _res = _tmp_169_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_105[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_107[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)")); } { // kwargs @@ -34233,18 +34951,18 @@ _tmp_105_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c> _tmp_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); asdl_seq* kwargs_var; if ( (kwargs_var = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_105[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); + D(fprintf(stderr, "%*c+ _tmp_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); _res = kwargs_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_105[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_107[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); } _res = NULL; @@ -34253,9 +34971,9 @@ _tmp_105_rule(Parser *p) return _res; } -// _loop0_106: ',' (starred_expression !'=') +// _loop0_108: ',' (starred_expression !'=') static asdl_seq * -_loop0_106_rule(Parser *p) +_loop0_108_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34280,13 +34998,13 @@ _loop0_106_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')")); + D(fprintf(stderr, "%*c> _loop0_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression !'=')")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_168_rule(p)) // starred_expression !'=' + (elem = _tmp_170_rule(p)) // starred_expression !'=' ) { _res = elem; @@ -34312,7 +35030,7 @@ _loop0_106_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_106[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_108[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression !'=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -34329,9 +35047,9 @@ _loop0_106_rule(Parser *p) return _seq; } -// _gather_107: (starred_expression !'=') _loop0_106 +// _gather_109: (starred_expression !'=') _loop0_108 static asdl_seq * -_gather_107_rule(Parser *p) +_gather_109_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34342,27 +35060,27 @@ _gather_107_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (starred_expression !'=') _loop0_106 + { // (starred_expression !'=') _loop0_108 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_106")); + D(fprintf(stderr, "%*c> _gather_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_108")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_168_rule(p)) // starred_expression !'=' + (elem = _tmp_170_rule(p)) // starred_expression !'=' && - (seq = _loop0_106_rule(p)) // _loop0_106 + (seq = _loop0_108_rule(p)) // _loop0_108 ) { - D(fprintf(stderr, "%*c+ _gather_107[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_106")); + D(fprintf(stderr, "%*c+ _gather_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression !'=') _loop0_108")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_107[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_106")); + D(fprintf(stderr, "%*c%s _gather_109[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression !'=') _loop0_108")); } _res = NULL; done: @@ -34370,9 +35088,9 @@ _gather_107_rule(Parser *p) return _res; } -// _tmp_108: args | expression for_if_clauses +// _tmp_110: args | expression for_if_clauses static void * -_tmp_108_rule(Parser *p) +_tmp_110_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34388,18 +35106,18 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); expr_ty args_var; if ( (args_var = args_rule(p)) // args ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); _res = args_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args")); } { // expression for_if_clauses @@ -34407,7 +35125,7 @@ _tmp_108_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); expr_ty expression_var; asdl_comprehension_seq* for_if_clauses_var; if ( @@ -34416,12 +35134,12 @@ _tmp_108_rule(Parser *p) (for_if_clauses_var = for_if_clauses_rule(p)) // for_if_clauses ) { - D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); + D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses")); } _res = NULL; @@ -34430,9 +35148,9 @@ _tmp_108_rule(Parser *p) return _res; } -// _tmp_109: args ',' +// _tmp_111: args ',' static void * -_tmp_109_rule(Parser *p) +_tmp_111_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34448,7 +35166,7 @@ _tmp_109_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','")); Token * _literal; expr_ty args_var; if ( @@ -34457,12 +35175,12 @@ _tmp_109_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','")); + D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','")); _res = _PyPegen_dummy_name(p, args_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','")); } _res = NULL; @@ -34471,9 +35189,9 @@ _tmp_109_rule(Parser *p) return _res; } -// _tmp_110: ',' | ')' +// _tmp_112: ',' | ')' static void * -_tmp_110_rule(Parser *p) +_tmp_112_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34489,18 +35207,18 @@ _tmp_110_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_112[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // ')' @@ -34508,18 +35226,18 @@ _tmp_110_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_110[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_110[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_112[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } _res = NULL; @@ -34528,9 +35246,9 @@ _tmp_110_rule(Parser *p) return _res; } -// _tmp_111: 'True' | 'False' | 'None' +// _tmp_113: 'True' | 'False' | 'None' static void * -_tmp_111_rule(Parser *p) +_tmp_113_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34546,18 +35264,18 @@ _tmp_111_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 623)) // token='True' + (_keyword = _PyPegen_expect_token(p, 627)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } { // 'False' @@ -34565,18 +35283,18 @@ _tmp_111_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 625)) // token='False' + (_keyword = _PyPegen_expect_token(p, 629)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } { // 'None' @@ -34584,18 +35302,18 @@ _tmp_111_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> _tmp_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 624)) // token='None' + (_keyword = _PyPegen_expect_token(p, 628)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_113[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } _res = NULL; @@ -34604,9 +35322,9 @@ _tmp_111_rule(Parser *p) return _res; } -// _tmp_112: NAME '=' +// _tmp_114: NAME '=' static void * -_tmp_112_rule(Parser *p) +_tmp_114_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34622,7 +35340,7 @@ _tmp_112_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); + D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); Token * _literal; expr_ty name_var; if ( @@ -34631,12 +35349,12 @@ _tmp_112_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_112[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); + D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); _res = _PyPegen_dummy_name(p, name_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_112[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_114[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='")); } _res = NULL; @@ -34645,9 +35363,9 @@ _tmp_112_rule(Parser *p) return _res; } -// _loop1_113: (!STRING expression_without_invalid) +// _loop1_115: (!STRING expression_without_invalid) static asdl_seq * -_loop1_113_rule(Parser *p) +_loop1_115_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34672,13 +35390,13 @@ _loop1_113_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop1_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(!STRING expression_without_invalid)")); - void *_tmp_169_var; + D(fprintf(stderr, "%*c> _loop1_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(!STRING expression_without_invalid)")); + void *_tmp_171_var; while ( - (_tmp_169_var = _tmp_169_rule(p)) // !STRING expression_without_invalid + (_tmp_171_var = _tmp_171_rule(p)) // !STRING expression_without_invalid ) { - _res = _tmp_169_var; + _res = _tmp_171_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -34695,7 +35413,7 @@ _loop1_113_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop1_113[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop1_115[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(!STRING expression_without_invalid)")); } if (_n == 0 || p->error_indicator) { @@ -34717,9 +35435,9 @@ _loop1_113_rule(Parser *p) return _seq; } -// _tmp_114: NAME STRING | SOFT_KEYWORD +// _tmp_116: NAME STRING | SOFT_KEYWORD static void * -_tmp_114_rule(Parser *p) +_tmp_116_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34735,7 +35453,7 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME STRING")); expr_ty name_var; expr_ty string_var; if ( @@ -34744,12 +35462,12 @@ _tmp_114_rule(Parser *p) (string_var = _PyPegen_string_token(p)) // STRING ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); + D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME STRING")); _res = _PyPegen_dummy_name(p, name_var, string_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_114[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME STRING")); } { // SOFT_KEYWORD @@ -34757,18 +35475,18 @@ _tmp_114_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); expr_ty soft_keyword_var; if ( (soft_keyword_var = _PyPegen_soft_keyword_token(p)) // SOFT_KEYWORD ) { - D(fprintf(stderr, "%*c+ _tmp_114[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); + D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "SOFT_KEYWORD")); _res = soft_keyword_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_114[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "SOFT_KEYWORD")); } _res = NULL; @@ -34777,9 +35495,9 @@ _tmp_114_rule(Parser *p) return _res; } -// _tmp_115: 'else' | ':' +// _tmp_117: 'else' | ':' static void * -_tmp_115_rule(Parser *p) +_tmp_117_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34795,18 +35513,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 695)) // token='else' + (_keyword = _PyPegen_expect_token(p, 699)) // token='else' ) { - D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'")); } { // ':' @@ -34814,18 +35532,18 @@ _tmp_115_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } _res = NULL; @@ -34834,9 +35552,9 @@ _tmp_115_rule(Parser *p) return _res; } -// _tmp_116: pass_stmt | break_stmt | continue_stmt +// _tmp_118: pass_stmt | break_stmt | continue_stmt static void * -_tmp_116_rule(Parser *p) +_tmp_118_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34852,18 +35570,18 @@ _tmp_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pass_stmt")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "pass_stmt")); stmt_ty pass_stmt_var; if ( (pass_stmt_var = pass_stmt_rule(p)) // pass_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pass_stmt")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "pass_stmt")); _res = pass_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pass_stmt")); } { // break_stmt @@ -34871,18 +35589,18 @@ _tmp_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "break_stmt")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "break_stmt")); stmt_ty break_stmt_var; if ( (break_stmt_var = break_stmt_rule(p)) // break_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "break_stmt")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "break_stmt")); _res = break_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "break_stmt")); } { // continue_stmt @@ -34890,18 +35608,18 @@ _tmp_116_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "continue_stmt")); + D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "continue_stmt")); stmt_ty continue_stmt_var; if ( (continue_stmt_var = continue_stmt_rule(p)) // continue_stmt ) { - D(fprintf(stderr, "%*c+ _tmp_116[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "continue_stmt")); + D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "continue_stmt")); _res = continue_stmt_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "continue_stmt")); } _res = NULL; @@ -34910,9 +35628,9 @@ _tmp_116_rule(Parser *p) return _res; } -// _tmp_117: '=' | ':=' +// _tmp_119: '=' | ':=' static void * -_tmp_117_rule(Parser *p) +_tmp_119_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34928,18 +35646,18 @@ _tmp_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); } { // ':=' @@ -34947,18 +35665,18 @@ _tmp_117_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); + D(fprintf(stderr, "%*c> _tmp_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':='")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 53)) // token=':=' ) { - D(fprintf(stderr, "%*c+ _tmp_117[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); + D(fprintf(stderr, "%*c+ _tmp_119[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':='")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_119[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='")); } _res = NULL; @@ -34967,9 +35685,9 @@ _tmp_117_rule(Parser *p) return _res; } -// _tmp_118: list | tuple | genexp | 'True' | 'None' | 'False' +// _tmp_120: list | tuple | genexp | 'True' | 'None' | 'False' static void * -_tmp_118_rule(Parser *p) +_tmp_120_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -34985,18 +35703,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); expr_ty list_var; if ( (list_var = list_rule(p)) // list ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); _res = list_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); } { // tuple @@ -35004,18 +35722,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); expr_ty tuple_var; if ( (tuple_var = tuple_rule(p)) // tuple ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); _res = tuple_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); } { // genexp @@ -35023,18 +35741,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); expr_ty genexp_var; if ( (genexp_var = genexp_rule(p)) // genexp ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); _res = genexp_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); } { // 'True' @@ -35042,18 +35760,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 623)) // token='True' + (_keyword = _PyPegen_expect_token(p, 627)) // token='True' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); } { // 'None' @@ -35061,18 +35779,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 624)) // token='None' + (_keyword = _PyPegen_expect_token(p, 628)) // token='None' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); } { // 'False' @@ -35080,18 +35798,18 @@ _tmp_118_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c> _tmp_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 625)) // token='False' + (_keyword = _PyPegen_expect_token(p, 629)) // token='False' ) { - D(fprintf(stderr, "%*c+ _tmp_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); + D(fprintf(stderr, "%*c+ _tmp_120[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_120[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); } _res = NULL; @@ -35100,9 +35818,9 @@ _tmp_118_rule(Parser *p) return _res; } -// _loop0_119: star_named_expressions +// _loop0_121: star_named_expressions static asdl_seq * -_loop0_119_rule(Parser *p) +_loop0_121_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35127,7 +35845,7 @@ _loop0_119_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); + D(fprintf(stderr, "%*c> _loop0_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); asdl_expr_seq* star_named_expressions_var; while ( (star_named_expressions_var = star_named_expressions_rule(p)) // star_named_expressions @@ -35150,7 +35868,7 @@ _loop0_119_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_119[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_121[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expressions")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35167,9 +35885,9 @@ _loop0_119_rule(Parser *p) return _seq; } -// _loop0_120: (star_targets '=') +// _loop0_122: (star_targets '=') static asdl_seq * -_loop0_120_rule(Parser *p) +_loop0_122_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35194,13 +35912,13 @@ _loop0_120_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); - void *_tmp_157_var; + D(fprintf(stderr, "%*c> _loop0_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); + void *_tmp_159_var; while ( - (_tmp_157_var = _tmp_157_rule(p)) // star_targets '=' + (_tmp_159_var = _tmp_159_rule(p)) // star_targets '=' ) { - _res = _tmp_157_var; + _res = _tmp_159_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -35217,7 +35935,7 @@ _loop0_120_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_120[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_122[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35234,85 +35952,9 @@ _loop0_120_rule(Parser *p) return _seq; } -// _tmp_121: '[' | '(' | '{' +// _tmp_123: '[' | '{' static void * -_tmp_121_rule(Parser *p) -{ - if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { - _Pypegen_stack_overflow(p); - } - if (p->error_indicator) { - p->level--; - return NULL; - } - void * _res = NULL; - int _mark = p->mark; - { // '[' - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 9)) // token='[' - ) - { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); - _res = _literal; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); - } - { // '(' - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 7)) // token='(' - ) - { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); - _res = _literal; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); - } - { // '{' - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 25)) // token='{' - ) - { - D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); - _res = _literal; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_122: '[' | '{' -static void * -_tmp_122_rule(Parser *p) +_tmp_123_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35328,18 +35970,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); } { // '{' @@ -35347,18 +35989,18 @@ _tmp_122_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 25)) // token='{' ) { - D(fprintf(stderr, "%*c+ _tmp_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); + D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_122[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); } _res = NULL; @@ -35367,9 +36009,9 @@ _tmp_122_rule(Parser *p) return _res; } -// _tmp_123: slash_no_default | slash_with_default +// _tmp_124: slash_no_default | slash_with_default static void * -_tmp_123_rule(Parser *p) +_tmp_124_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35385,18 +36027,18 @@ _tmp_123_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default")); asdl_arg_seq* slash_no_default_var; if ( (slash_no_default_var = slash_no_default_rule(p)) // slash_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default")); _res = slash_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default")); } { // slash_with_default @@ -35404,18 +36046,18 @@ _tmp_123_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); SlashWithDefault* slash_with_default_var; if ( (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default ) { - D(fprintf(stderr, "%*c+ _tmp_123[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); _res = slash_with_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_123[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); } _res = NULL; @@ -35424,9 +36066,9 @@ _tmp_123_rule(Parser *p) return _res; } -// _tmp_124: ',' | param_no_default +// _tmp_125: ',' | param_no_default static void * -_tmp_124_rule(Parser *p) +_tmp_125_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35442,18 +36084,18 @@ _tmp_124_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // param_no_default @@ -35461,18 +36103,18 @@ _tmp_124_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); arg_ty param_no_default_var; if ( (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); _res = param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); } _res = NULL; @@ -35481,9 +36123,9 @@ _tmp_124_rule(Parser *p) return _res; } -// _tmp_125: ')' | ',' +// _tmp_126: ')' | ',' static void * -_tmp_125_rule(Parser *p) +_tmp_126_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35499,18 +36141,18 @@ _tmp_125_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' @@ -35518,18 +36160,18 @@ _tmp_125_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -35538,9 +36180,9 @@ _tmp_125_rule(Parser *p) return _res; } -// _tmp_126: ')' | ',' (')' | '**') +// _tmp_127: ')' | ',' (')' | '**') static void * -_tmp_126_rule(Parser *p) +_tmp_127_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35556,18 +36198,18 @@ _tmp_126_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ',' (')' | '**') @@ -35575,21 +36217,21 @@ _tmp_126_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + D(fprintf(stderr, "%*c> _tmp_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); Token * _literal; - void *_tmp_170_var; + void *_tmp_172_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_170_var = _tmp_170_rule(p)) // ')' | '**' + (_tmp_172_var = _tmp_172_rule(p)) // ')' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_126[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_170_var); + D(fprintf(stderr, "%*c+ _tmp_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_172_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); } _res = NULL; @@ -35598,9 +36240,9 @@ _tmp_126_rule(Parser *p) return _res; } -// _tmp_127: param_no_default | ',' +// _tmp_128: param_no_default | ',' static void * -_tmp_127_rule(Parser *p) +_tmp_128_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35616,18 +36258,18 @@ _tmp_127_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); arg_ty param_no_default_var; if ( (param_no_default_var = param_no_default_rule(p)) // param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default")); _res = param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); } { // ',' @@ -35635,18 +36277,18 @@ _tmp_127_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_127[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_127[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -35655,9 +36297,9 @@ _tmp_127_rule(Parser *p) return _res; } -// _tmp_128: '*' | '**' | '/' +// _tmp_129: '*' | '**' | '/' static void * -_tmp_128_rule(Parser *p) +_tmp_129_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35673,18 +36315,18 @@ _tmp_128_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); } { // '**' @@ -35692,18 +36334,18 @@ _tmp_128_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } { // '/' @@ -35711,18 +36353,18 @@ _tmp_128_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_128[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); } _res = NULL; @@ -35731,9 +36373,9 @@ _tmp_128_rule(Parser *p) return _res; } -// _tmp_129: lambda_slash_no_default | lambda_slash_with_default +// _tmp_130: lambda_slash_no_default | lambda_slash_with_default static void * -_tmp_129_rule(Parser *p) +_tmp_130_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35749,18 +36391,18 @@ _tmp_129_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); asdl_arg_seq* lambda_slash_no_default_var; if ( (lambda_slash_no_default_var = lambda_slash_no_default_rule(p)) // lambda_slash_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); + D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default")); _res = lambda_slash_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default")); } { // lambda_slash_with_default @@ -35768,18 +36410,18 @@ _tmp_129_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); SlashWithDefault* lambda_slash_with_default_var; if ( (lambda_slash_with_default_var = lambda_slash_with_default_rule(p)) // lambda_slash_with_default ) { - D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); + D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); _res = lambda_slash_with_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); } _res = NULL; @@ -35788,9 +36430,9 @@ _tmp_129_rule(Parser *p) return _res; } -// _loop0_130: ',' lambda_param +// _loop0_131: ',' lambda_param static asdl_seq * -_loop0_130_rule(Parser *p) +_loop0_131_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35815,7 +36457,7 @@ _loop0_130_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); + D(fprintf(stderr, "%*c> _loop0_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' lambda_param")); Token * _literal; arg_ty elem; while ( @@ -35847,7 +36489,7 @@ _loop0_130_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_130[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_131[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' lambda_param")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -35864,9 +36506,9 @@ _loop0_130_rule(Parser *p) return _seq; } -// _gather_131: lambda_param _loop0_130 +// _gather_132: lambda_param _loop0_131 static asdl_seq * -_gather_131_rule(Parser *p) +_gather_132_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35877,27 +36519,27 @@ _gather_131_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // lambda_param _loop0_130 + { // lambda_param _loop0_131 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_130")); + D(fprintf(stderr, "%*c> _gather_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_131")); arg_ty elem; asdl_seq * seq; if ( (elem = lambda_param_rule(p)) // lambda_param && - (seq = _loop0_130_rule(p)) // _loop0_130 + (seq = _loop0_131_rule(p)) // _loop0_131 ) { - D(fprintf(stderr, "%*c+ _gather_131[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_130")); + D(fprintf(stderr, "%*c+ _gather_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param _loop0_131")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_131[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_130")); + D(fprintf(stderr, "%*c%s _gather_132[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param _loop0_131")); } _res = NULL; done: @@ -35905,9 +36547,9 @@ _gather_131_rule(Parser *p) return _res; } -// _tmp_132: ',' | lambda_param_no_default +// _tmp_133: ',' | lambda_param_no_default static void * -_tmp_132_rule(Parser *p) +_tmp_133_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35923,18 +36565,18 @@ _tmp_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', + 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 @@ -35942,18 +36584,18 @@ _tmp_132_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; if ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); _res = lambda_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', + 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")); } _res = NULL; @@ -35962,9 +36604,9 @@ _tmp_132_rule(Parser *p) return _res; } -// _tmp_133: ':' | ',' (':' | '**') +// _tmp_134: ':' | ',' (':' | '**') static void * -_tmp_133_rule(Parser *p) +_tmp_134_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -35980,18 +36622,18 @@ _tmp_133_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_133[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // ',' (':' | '**') @@ -35999,21 +36641,21 @@ _tmp_133_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); Token * _literal; - void *_tmp_171_var; + void *_tmp_173_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_171_var = _tmp_171_rule(p)) // ':' | '**' + (_tmp_173_var = _tmp_173_rule(p)) // ':' | '**' ) { - D(fprintf(stderr, "%*c+ _tmp_133[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); - _res = _PyPegen_dummy_name(p, _literal, _tmp_171_var); + D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); + _res = _PyPegen_dummy_name(p, _literal, _tmp_173_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_133[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')")); } _res = NULL; @@ -36022,9 +36664,9 @@ _tmp_133_rule(Parser *p) return _res; } -// _tmp_134: lambda_param_no_default | ',' +// _tmp_135: lambda_param_no_default | ',' static void * -_tmp_134_rule(Parser *p) +_tmp_135_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36040,18 +36682,18 @@ _tmp_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); arg_ty lambda_param_no_default_var; if ( (lambda_param_no_default_var = lambda_param_no_default_rule(p)) // lambda_param_no_default ) { - D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); + D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); _res = lambda_param_no_default_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); } { // ',' @@ -36059,18 +36701,18 @@ _tmp_134_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; @@ -36079,9 +36721,9 @@ _tmp_134_rule(Parser *p) return _res; } -// _tmp_135: bitwise_or ((',' bitwise_or))* ','? +// _tmp_136: bitwise_or ((',' bitwise_or))* ','? static void * -_tmp_135_rule(Parser *p) +_tmp_136_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36097,25 +36739,25 @@ _tmp_135_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - asdl_seq * _loop0_172_var; + D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + asdl_seq * _loop0_174_var; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty bitwise_or_var; if ( (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or && - (_loop0_172_var = _loop0_172_rule(p)) // ((',' bitwise_or))* + (_loop0_174_var = _loop0_174_rule(p)) // ((',' bitwise_or))* && (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? ) { - D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); - _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_172_var, _opt_var); + D(fprintf(stderr, "%*c+ _tmp_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); + _res = _PyPegen_dummy_name(p, bitwise_or_var, _loop0_174_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_136[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or ((',' bitwise_or))* ','?")); } _res = NULL; @@ -36124,9 +36766,9 @@ _tmp_135_rule(Parser *p) return _res; } -// _loop0_136: ',' dotted_name +// _loop0_137: ',' dotted_name static asdl_seq * -_loop0_136_rule(Parser *p) +_loop0_137_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36151,7 +36793,7 @@ _loop0_136_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); + D(fprintf(stderr, "%*c> _loop0_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_name")); Token * _literal; expr_ty elem; while ( @@ -36183,7 +36825,7 @@ _loop0_136_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_136[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_137[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_name")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -36200,9 +36842,9 @@ _loop0_136_rule(Parser *p) return _seq; } -// _gather_137: dotted_name _loop0_136 +// _gather_138: dotted_name _loop0_137 static asdl_seq * -_gather_137_rule(Parser *p) +_gather_138_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36213,27 +36855,27 @@ _gather_137_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_name _loop0_136 + { // dotted_name _loop0_137 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_136")); + D(fprintf(stderr, "%*c> _gather_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_137")); expr_ty elem; asdl_seq * seq; if ( (elem = dotted_name_rule(p)) // dotted_name && - (seq = _loop0_136_rule(p)) // _loop0_136 + (seq = _loop0_137_rule(p)) // _loop0_137 ) { - D(fprintf(stderr, "%*c+ _gather_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_136")); + D(fprintf(stderr, "%*c+ _gather_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name _loop0_137")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_137[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_136")); + D(fprintf(stderr, "%*c%s _gather_138[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name _loop0_137")); } _res = NULL; done: @@ -36241,9 +36883,9 @@ _gather_137_rule(Parser *p) return _res; } -// _tmp_138: NAME (',' | ')' | ';' | NEWLINE) +// _tmp_139: NAME (',' | ')' | ';' | NEWLINE) static void * -_tmp_138_rule(Parser *p) +_tmp_139_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36259,21 +36901,21 @@ _tmp_138_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); - void *_tmp_173_var; + D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); + void *_tmp_175_var; expr_ty name_var; if ( (name_var = _PyPegen_name_token(p)) // NAME && - (_tmp_173_var = _tmp_173_rule(p)) // ',' | ')' | ';' | NEWLINE + (_tmp_175_var = _tmp_175_rule(p)) // ',' | ')' | ';' | NEWLINE ) { - D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); - _res = _PyPegen_dummy_name(p, name_var, _tmp_173_var); + D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); + _res = _PyPegen_dummy_name(p, name_var, _tmp_175_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME (',' | ')' | ';' | NEWLINE)")); } _res = NULL; @@ -36282,9 +36924,9 @@ _tmp_138_rule(Parser *p) return _res; } -// _loop0_139: ',' (expression ['as' star_target]) +// _loop0_140: ',' (expression ['as' star_target]) static asdl_seq * -_loop0_139_rule(Parser *p) +_loop0_140_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36309,13 +36951,13 @@ _loop0_139_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expression ['as' star_target])")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_174_rule(p)) // expression ['as' star_target] + (elem = _tmp_176_rule(p)) // expression ['as' star_target] ) { _res = elem; @@ -36341,7 +36983,7 @@ _loop0_139_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_139[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_140[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expression ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -36358,9 +37000,9 @@ _loop0_139_rule(Parser *p) return _seq; } -// _gather_140: (expression ['as' star_target]) _loop0_139 +// _gather_141: (expression ['as' star_target]) _loop0_140 static asdl_seq * -_gather_140_rule(Parser *p) +_gather_141_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36371,27 +37013,27 @@ _gather_140_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expression ['as' star_target]) _loop0_139 + { // (expression ['as' star_target]) _loop0_140 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_139")); + D(fprintf(stderr, "%*c> _gather_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_140")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_174_rule(p)) // expression ['as' star_target] + (elem = _tmp_176_rule(p)) // expression ['as' star_target] && - (seq = _loop0_139_rule(p)) // _loop0_139 + (seq = _loop0_140_rule(p)) // _loop0_140 ) { - D(fprintf(stderr, "%*c+ _gather_140[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_139")); + D(fprintf(stderr, "%*c+ _gather_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expression ['as' star_target]) _loop0_140")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_140[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_139")); + D(fprintf(stderr, "%*c%s _gather_141[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expression ['as' star_target]) _loop0_140")); } _res = NULL; done: @@ -36399,9 +37041,9 @@ _gather_140_rule(Parser *p) return _res; } -// _loop0_141: ',' (expressions ['as' star_target]) +// _loop0_142: ',' (expressions ['as' star_target]) static asdl_seq * -_loop0_141_rule(Parser *p) +_loop0_142_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36426,13 +37068,13 @@ _loop0_141_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); + D(fprintf(stderr, "%*c> _loop0_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (expressions ['as' star_target])")); Token * _literal; void *elem; while ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (elem = _tmp_175_rule(p)) // expressions ['as' star_target] + (elem = _tmp_177_rule(p)) // expressions ['as' star_target] ) { _res = elem; @@ -36458,7 +37100,7 @@ _loop0_141_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_141[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_142[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (expressions ['as' star_target])")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -36475,9 +37117,9 @@ _loop0_141_rule(Parser *p) return _seq; } -// _gather_142: (expressions ['as' star_target]) _loop0_141 +// _gather_143: (expressions ['as' star_target]) _loop0_142 static asdl_seq * -_gather_142_rule(Parser *p) +_gather_143_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36488,27 +37130,27 @@ _gather_142_rule(Parser *p) } asdl_seq * _res = NULL; int _mark = p->mark; - { // (expressions ['as' star_target]) _loop0_141 + { // (expressions ['as' star_target]) _loop0_142 if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _gather_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_141")); + D(fprintf(stderr, "%*c> _gather_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_142")); void *elem; asdl_seq * seq; if ( - (elem = _tmp_175_rule(p)) // expressions ['as' star_target] + (elem = _tmp_177_rule(p)) // expressions ['as' star_target] && - (seq = _loop0_141_rule(p)) // _loop0_141 + (seq = _loop0_142_rule(p)) // _loop0_142 ) { - D(fprintf(stderr, "%*c+ _gather_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_141")); + D(fprintf(stderr, "%*c+ _gather_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(expressions ['as' star_target]) _loop0_142")); _res = _PyPegen_seq_insert_in_front(p, elem, seq); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _gather_142[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_141")); + D(fprintf(stderr, "%*c%s _gather_143[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(expressions ['as' star_target]) _loop0_142")); } _res = NULL; done: @@ -36516,9 +37158,9 @@ _gather_142_rule(Parser *p) return _res; } -// _tmp_143: 'except' | 'finally' +// _tmp_144: 'except' | 'finally' static void * -_tmp_143_rule(Parser *p) +_tmp_144_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36534,18 +37176,18 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 686)) // token='except' + (_keyword = _PyPegen_expect_token(p, 690)) // token='except' ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'")); } { // 'finally' @@ -36553,18 +37195,18 @@ _tmp_143_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally'")); Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 682)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 686)) // token='finally' ) { - D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); + D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally'")); _res = _keyword; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'")); } _res = NULL; @@ -36573,9 +37215,9 @@ _tmp_143_rule(Parser *p) return _res; } -// _loop0_144: block +// _loop0_145: block static asdl_seq * -_loop0_144_rule(Parser *p) +_loop0_145_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36600,7 +37242,7 @@ _loop0_144_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); + D(fprintf(stderr, "%*c> _loop0_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block")); asdl_stmt_seq* block_var; while ( (block_var = block_rule(p)) // block @@ -36623,7 +37265,7 @@ _loop0_144_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_144[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_145[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "block")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -36640,9 +37282,9 @@ _loop0_144_rule(Parser *p) return _seq; } -// _tmp_145: expression ['as' NAME] +// _tmp_146: expression ['as' NAME] static void * -_tmp_145_rule(Parser *p) +_tmp_146_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36658,7 +37300,7 @@ _tmp_145_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty expression_var; @@ -36668,12 +37310,12 @@ _tmp_145_rule(Parser *p) (_opt_var = _tmp_21_rule(p), !p->error_indicator) // ['as' NAME] ) { - D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); + D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' NAME]")); _res = _PyPegen_dummy_name(p, expression_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' NAME]")); } _res = NULL; @@ -36682,9 +37324,9 @@ _tmp_145_rule(Parser *p) return _res; } -// _tmp_146: NEWLINE | ':' +// _tmp_147: NEWLINE | ':' static void * -_tmp_146_rule(Parser *p) +_tmp_147_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36700,18 +37342,18 @@ _tmp_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); Token * newline_var; if ( (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); _res = newline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } { // ':' @@ -36719,18 +37361,18 @@ _tmp_146_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } _res = NULL; @@ -36739,9 +37381,9 @@ _tmp_146_rule(Parser *p) return _res; } -// _tmp_147: items_pattern ',' +// _tmp_148: items_pattern ',' static void * -_tmp_147_rule(Parser *p) +_tmp_148_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36757,7 +37399,7 @@ _tmp_147_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "items_pattern ','")); + D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "items_pattern ','")); Token * _literal; asdl_seq* items_pattern_var; if ( @@ -36766,12 +37408,12 @@ _tmp_147_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "items_pattern ','")); + D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "items_pattern ','")); _res = _PyPegen_dummy_name(p, items_pattern_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "items_pattern ','")); } _res = NULL; @@ -36780,9 +37422,9 @@ _tmp_147_rule(Parser *p) return _res; } -// _tmp_148: positional_patterns ',' +// _tmp_149: positional_patterns ',' static void * -_tmp_148_rule(Parser *p) +_tmp_149_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36798,7 +37440,7 @@ _tmp_148_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); Token * _literal; asdl_pattern_seq* positional_patterns_var; if ( @@ -36807,12 +37449,12 @@ _tmp_148_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); + D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "positional_patterns ','")); _res = _PyPegen_dummy_name(p, positional_patterns_var, _literal); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "positional_patterns ','")); } _res = NULL; @@ -36821,9 +37463,9 @@ _tmp_148_rule(Parser *p) return _res; } -// _tmp_149: '}' | ',' +// _tmp_150: invalid_kvpair | invalid_kvpair_unpacking static void * -_tmp_149_rule(Parser *p) +_tmp_150_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36834,43 +37476,43 @@ _tmp_149_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // '}' + if (p->call_invalid_rules) { // invalid_kvpair if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); - Token * _literal; + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kvpair")); + void *invalid_kvpair_var; if ( - (_literal = _PyPegen_expect_token(p, 26)) // token='}' + (invalid_kvpair_var = invalid_kvpair_rule(p)) // invalid_kvpair ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); - _res = _literal; + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kvpair")); + _res = invalid_kvpair_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kvpair")); } - { // ',' + if (p->call_invalid_rules) { // invalid_kvpair_unpacking if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); - Token * _literal; + D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kvpair_unpacking")); + void *invalid_kvpair_unpacking_var; if ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' + (invalid_kvpair_unpacking_var = invalid_kvpair_unpacking_rule(p)) // invalid_kvpair_unpacking ) { - D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); - _res = _literal; + D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kvpair_unpacking")); + _res = invalid_kvpair_unpacking_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); + D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kvpair_unpacking")); } _res = NULL; done: @@ -36878,9 +37520,9 @@ _tmp_149_rule(Parser *p) return _res; } -// _tmp_150: '=' | '!' | ':' | '}' +// _tmp_151: '}' | ',' static void * -_tmp_150_rule(Parser *p) +_tmp_151_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36891,81 +37533,43 @@ _tmp_150_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // '=' - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 22)) // token='=' - ) - { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); - _res = _literal; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); - } - { // '!' - if (p->error_indicator) { - p->level--; - return NULL; - } - D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 54)) // token='!' - ) - { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); - _res = _literal; - goto done; - } - p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); - } - { // ':' + { // '}' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( - (_literal = _PyPegen_expect_token(p, 11)) // token=':' + (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } - { // '}' + { // ',' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( - (_literal = _PyPegen_expect_token(p, 26)) // token='}' + (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } _res = NULL; done: @@ -36973,9 +37577,9 @@ _tmp_150_rule(Parser *p) return _res; } -// _tmp_151: '!' | ':' | '}' +// _tmp_152: '=' | '!' | ':' | '}' static void * -_tmp_151_rule(Parser *p) +_tmp_152_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -36986,23 +37590,42 @@ _tmp_151_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; + { // '=' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'='")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 22)) // token='=' + ) + { + D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'='")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='")); + } { // '!' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' ) { - D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } { // ':' @@ -37010,18 +37633,18 @@ _tmp_151_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '}' @@ -37029,18 +37652,18 @@ _tmp_151_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 26)) // token='}' ) { - D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); } _res = NULL; @@ -37049,9 +37672,9 @@ _tmp_151_rule(Parser *p) return _res; } -// _tmp_152: '!' NAME +// _tmp_153: '!' | ':' | '}' static void * -_tmp_152_rule(Parser *p) +_tmp_153_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37062,47 +37685,25 @@ _tmp_152_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // '!' NAME + { // '!' if (p->error_indicator) { p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + D(fprintf(stderr, "%*c> _tmp_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!'")); Token * _literal; - expr_ty name_var; if ( (_literal = _PyPegen_expect_token(p, 54)) // token='!' - && - (name_var = _PyPegen_name_token(p)) // NAME ) { - D(fprintf(stderr, "%*c+ _tmp_152[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME")); - _res = _PyPegen_dummy_name(p, _literal, name_var); + D(fprintf(stderr, "%*c+ _tmp_153[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!'")); + _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_152[%d-%d]: %s failed!\n", p->level, ' ', - p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' NAME")); - } - _res = NULL; - done: - p->level--; - return _res; -} - -// _tmp_153: ':' | '}' -static void * -_tmp_153_rule(Parser *p) -{ - if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { - _Pypegen_stack_overflow(p); - } - if (p->error_indicator) { - p->level--; - return NULL; + D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'")); } - void * _res = NULL; - int _mark = p->mark; { // ':' if (p->error_indicator) { p->level--; @@ -37147,9 +37748,107 @@ _tmp_153_rule(Parser *p) return _res; } -// _tmp_154: fstring | string +// _tmp_154: '!' NAME static void * _tmp_154_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '!' NAME + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + Token * _literal; + expr_ty name_var; + if ( + (_literal = _PyPegen_expect_token(p, 54)) // token='!' + && + (name_var = _PyPegen_name_token(p)) // NAME + ) + { + D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!' NAME")); + _res = _PyPegen_dummy_name(p, _literal, name_var); + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!' NAME")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_155: ':' | '}' +static void * +_tmp_155_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // ':' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + ) + { + D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); + } + { // '}' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'}'")); + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 26)) // token='}' + ) + { + D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'}'")); + _res = _literal; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_156: fstring | string +static void * +_tmp_156_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37165,18 +37864,18 @@ _tmp_154_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring")); + D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring")); expr_ty fstring_var; if ( (fstring_var = fstring_rule(p)) // fstring ) { - D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring")); + D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "fstring")); _res = fstring_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring")); } { // string @@ -37184,18 +37883,18 @@ _tmp_154_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "string")); + D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "string")); expr_ty string_var; if ( (string_var = string_rule(p)) // string ) { - D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "string")); + D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "string")); _res = string_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "string")); } _res = NULL; @@ -37204,9 +37903,9 @@ _tmp_154_rule(Parser *p) return _res; } -// _tmp_155: '+' | '-' | '*' | '/' | '%' | '//' | '@' +// _tmp_157: '+' | '-' | '*' | '/' | '%' | '//' | '@' static void * -_tmp_155_rule(Parser *p) +_tmp_157_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37222,18 +37921,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); } { // '-' @@ -37241,18 +37940,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); } { // '*' @@ -37260,18 +37959,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'")); } { // '/' @@ -37279,18 +37978,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 17)) // token='/' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'")); } { // '%' @@ -37298,18 +37997,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 24)) // token='%' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%'")); } { // '//' @@ -37317,18 +38016,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 47)) // token='//' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//'")); } { // '@' @@ -37336,18 +38035,18 @@ _tmp_155_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); + D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 49)) // token='@' ) { - D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); + D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); } _res = NULL; @@ -37356,9 +38055,9 @@ _tmp_155_rule(Parser *p) return _res; } -// _tmp_156: '+' | '-' | '~' +// _tmp_158: '+' | '-' | '~' static void * -_tmp_156_rule(Parser *p) +_tmp_158_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37374,18 +38073,18 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 14)) // token='+' ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'")); } { // '-' @@ -37393,18 +38092,18 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 15)) // token='-' ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'")); } { // '~' @@ -37412,18 +38111,18 @@ _tmp_156_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_156[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 31)) // token='~' ) { - D(fprintf(stderr, "%*c+ _tmp_156[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); + D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_156[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~'")); } _res = NULL; @@ -37432,9 +38131,9 @@ _tmp_156_rule(Parser *p) return _res; } -// _tmp_157: star_targets '=' +// _tmp_159: star_targets '=' static void * -_tmp_157_rule(Parser *p) +_tmp_159_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37450,7 +38149,7 @@ _tmp_157_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); Token * _literal; expr_ty z; if ( @@ -37459,7 +38158,7 @@ _tmp_157_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_157[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); + D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37469,7 +38168,7 @@ _tmp_157_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_157[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); } _res = NULL; @@ -37478,9 +38177,9 @@ _tmp_157_rule(Parser *p) return _res; } -// _tmp_158: '.' | '...' +// _tmp_160: '.' | '...' static void * -_tmp_158_rule(Parser *p) +_tmp_160_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37496,18 +38195,18 @@ _tmp_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 23)) // token='.' ) { - D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); + D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); } { // '...' @@ -37515,18 +38214,18 @@ _tmp_158_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_158[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); + D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 52)) // token='...' ) { - D(fprintf(stderr, "%*c+ _tmp_158[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); + D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_158[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); } _res = NULL; @@ -37535,9 +38234,9 @@ _tmp_158_rule(Parser *p) return _res; } -// _tmp_159: '@' named_expression NEWLINE +// _tmp_161: '@' named_expression NEWLINE static void * -_tmp_159_rule(Parser *p) +_tmp_161_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37553,7 +38252,7 @@ _tmp_159_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_159[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); Token * _literal; expr_ty f; Token * newline_var; @@ -37565,7 +38264,7 @@ _tmp_159_rule(Parser *p) (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_159[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); _res = f; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37575,7 +38274,7 @@ _tmp_159_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE")); } _res = NULL; @@ -37584,9 +38283,9 @@ _tmp_159_rule(Parser *p) return _res; } -// _tmp_160: ',' star_expression +// _tmp_162: ',' star_expression static void * -_tmp_160_rule(Parser *p) +_tmp_162_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37602,7 +38301,7 @@ _tmp_160_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_160[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); Token * _literal; expr_ty c; if ( @@ -37611,7 +38310,7 @@ _tmp_160_rule(Parser *p) (c = star_expression_rule(p)) // star_expression ) { - D(fprintf(stderr, "%*c+ _tmp_160[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); + D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37621,7 +38320,7 @@ _tmp_160_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_160[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression")); } _res = NULL; @@ -37630,9 +38329,9 @@ _tmp_160_rule(Parser *p) return _res; } -// _tmp_161: 'or' conjunction +// _tmp_163: 'or' conjunction static void * -_tmp_161_rule(Parser *p) +_tmp_163_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37648,7 +38347,7 @@ _tmp_161_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_161[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); Token * _keyword; expr_ty c; if ( @@ -37657,7 +38356,7 @@ _tmp_161_rule(Parser *p) (c = conjunction_rule(p)) // conjunction ) { - D(fprintf(stderr, "%*c+ _tmp_161[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); + D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37667,7 +38366,7 @@ _tmp_161_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_161[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_163[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction")); } _res = NULL; @@ -37676,9 +38375,9 @@ _tmp_161_rule(Parser *p) return _res; } -// _tmp_162: 'and' inversion +// _tmp_164: 'and' inversion static void * -_tmp_162_rule(Parser *p) +_tmp_164_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37694,7 +38393,7 @@ _tmp_162_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_162[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); Token * _keyword; expr_ty c; if ( @@ -37703,7 +38402,7 @@ _tmp_162_rule(Parser *p) (c = inversion_rule(p)) // inversion ) { - D(fprintf(stderr, "%*c+ _tmp_162[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); + D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37713,7 +38412,7 @@ _tmp_162_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_162[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_164[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion")); } _res = NULL; @@ -37722,9 +38421,9 @@ _tmp_162_rule(Parser *p) return _res; } -// _tmp_163: slice | starred_expression +// _tmp_165: slice | starred_expression static void * -_tmp_163_rule(Parser *p) +_tmp_165_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37740,18 +38439,18 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice")); expr_ty slice_var; if ( (slice_var = slice_rule(p)) // slice ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); + D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice")); _res = slice_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_163[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice")); } { // starred_expression @@ -37759,18 +38458,18 @@ _tmp_163_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_163[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression ) { - D(fprintf(stderr, "%*c+ _tmp_163[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_163[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); } _res = NULL; @@ -37779,9 +38478,9 @@ _tmp_163_rule(Parser *p) return _res; } -// _tmp_164: 'if' disjunction +// _tmp_166: 'if' disjunction static void * -_tmp_164_rule(Parser *p) +_tmp_166_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37797,16 +38496,16 @@ _tmp_164_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_164[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 691)) // token='if' + (_keyword = _PyPegen_expect_token(p, 695)) // token='if' && (z = disjunction_rule(p)) // disjunction ) { - D(fprintf(stderr, "%*c+ _tmp_164[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); + D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); _res = z; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37816,7 +38515,7 @@ _tmp_164_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_164[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); } _res = NULL; @@ -37825,9 +38524,9 @@ _tmp_164_rule(Parser *p) return _res; } -// _tmp_165: starred_expression | (assignment_expression | expression !':=') !'=' +// _tmp_167: starred_expression | (assignment_expression | expression !':=') !'=' static void * -_tmp_165_rule(Parser *p) +_tmp_167_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37843,18 +38542,18 @@ _tmp_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression ) { - D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); + D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); } { // (assignment_expression | expression !':=') !'=' @@ -37862,20 +38561,20 @@ _tmp_165_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_165[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - void *_tmp_87_var; + D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + void *_tmp_178_var; if ( - (_tmp_87_var = _tmp_87_rule(p)) // assignment_expression | expression !':=' + (_tmp_178_var = _tmp_178_rule(p)) // assignment_expression | expression !':=' && _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_165[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); - _res = _tmp_87_var; + D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(assignment_expression | expression !':=') !'='")); + _res = _tmp_178_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_165[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='")); } _res = NULL; @@ -37884,9 +38583,9 @@ _tmp_165_rule(Parser *p) return _res; } -// _tmp_166: ',' star_target +// _tmp_168: ',' star_target static void * -_tmp_166_rule(Parser *p) +_tmp_168_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37902,7 +38601,7 @@ _tmp_166_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_166[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); Token * _literal; expr_ty c; if ( @@ -37911,7 +38610,7 @@ _tmp_166_rule(Parser *p) (c = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_166[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); + D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); _res = c; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; @@ -37921,7 +38620,7 @@ _tmp_166_rule(Parser *p) goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_166[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); } _res = NULL; @@ -37930,10 +38629,10 @@ _tmp_166_rule(Parser *p) return _res; } -// _tmp_167: +// _tmp_169: // | ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs static void * -_tmp_167_rule(Parser *p) +_tmp_169_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37949,24 +38648,24 @@ _tmp_167_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_167[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - asdl_seq * _gather_89_var; + D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + asdl_seq * _gather_91_var; Token * _literal; asdl_seq* kwargs_var; if ( - (_gather_89_var = _gather_89_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ + (_gather_91_var = _gather_91_rule(p)) // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && (kwargs_var = kwargs_rule(p)) // kwargs ) { - D(fprintf(stderr, "%*c+ _tmp_167[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); - _res = _PyPegen_dummy_name(p, _gather_89_var, _literal, kwargs_var); + D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); + _res = _PyPegen_dummy_name(p, _gather_91_var, _literal, kwargs_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs")); } _res = NULL; @@ -37975,9 +38674,9 @@ _tmp_167_rule(Parser *p) return _res; } -// _tmp_168: starred_expression !'=' +// _tmp_170: starred_expression !'=' static void * -_tmp_168_rule(Parser *p) +_tmp_170_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -37993,7 +38692,7 @@ _tmp_168_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_168[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); + D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); expr_ty starred_expression_var; if ( (starred_expression_var = starred_expression_rule(p)) // starred_expression @@ -38001,12 +38700,12 @@ _tmp_168_rule(Parser *p) _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22) // token='=' ) { - D(fprintf(stderr, "%*c+ _tmp_168[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); + D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression !'='")); _res = starred_expression_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression !'='")); } _res = NULL; @@ -38015,9 +38714,9 @@ _tmp_168_rule(Parser *p) return _res; } -// _tmp_169: !STRING expression_without_invalid +// _tmp_171: !STRING expression_without_invalid static void * -_tmp_169_rule(Parser *p) +_tmp_171_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38033,7 +38732,7 @@ _tmp_169_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_169[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); + D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); expr_ty expression_without_invalid_var; if ( _PyPegen_lookahead(0, _PyPegen_string_token, p) @@ -38041,12 +38740,12 @@ _tmp_169_rule(Parser *p) (expression_without_invalid_var = expression_without_invalid_rule(p)) // expression_without_invalid ) { - D(fprintf(stderr, "%*c+ _tmp_169[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); + D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!STRING expression_without_invalid")); _res = expression_without_invalid_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!STRING expression_without_invalid")); } _res = NULL; @@ -38055,9 +38754,9 @@ _tmp_169_rule(Parser *p) return _res; } -// _tmp_170: ')' | '**' +// _tmp_172: ')' | '**' static void * -_tmp_170_rule(Parser *p) +_tmp_172_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38073,18 +38772,18 @@ _tmp_170_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_172[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_172[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // '**' @@ -38092,18 +38791,18 @@ _tmp_170_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_170[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_170[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_172[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_170[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_172[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } _res = NULL; @@ -38112,9 +38811,9 @@ _tmp_170_rule(Parser *p) return _res; } -// _tmp_171: ':' | '**' +// _tmp_173: ':' | '**' static void * -_tmp_171_rule(Parser *p) +_tmp_173_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38130,18 +38829,18 @@ _tmp_171_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); + D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); } { // '**' @@ -38149,18 +38848,18 @@ _tmp_171_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_171[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 35)) // token='**' ) { - D(fprintf(stderr, "%*c+ _tmp_171[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); + D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); } _res = NULL; @@ -38169,9 +38868,9 @@ _tmp_171_rule(Parser *p) return _res; } -// _loop0_172: (',' bitwise_or) +// _loop0_174: (',' bitwise_or) static asdl_seq * -_loop0_172_rule(Parser *p) +_loop0_174_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38196,13 +38895,13 @@ _loop0_172_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _loop0_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); - void *_tmp_176_var; + D(fprintf(stderr, "%*c> _loop0_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)")); + void *_tmp_179_var; while ( - (_tmp_176_var = _tmp_176_rule(p)) // ',' bitwise_or + (_tmp_179_var = _tmp_179_rule(p)) // ',' bitwise_or ) { - _res = _tmp_176_var; + _res = _tmp_179_var; if (_n == _children_capacity) { _children_capacity *= 2; void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -38219,7 +38918,7 @@ _loop0_172_rule(Parser *p) _mark = p->mark; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _loop0_172[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _loop0_174[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' bitwise_or)")); } asdl_seq *_seq = (asdl_seq*)_Py_asdl_generic_seq_new(_n, p->arena); @@ -38236,9 +38935,9 @@ _loop0_172_rule(Parser *p) return _seq; } -// _tmp_173: ',' | ')' | ';' | NEWLINE +// _tmp_175: ',' | ')' | ';' | NEWLINE static void * -_tmp_173_rule(Parser *p) +_tmp_175_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38254,18 +38953,18 @@ _tmp_173_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); + D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); } { // ')' @@ -38273,18 +38972,18 @@ _tmp_173_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { - D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); + D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); } { // ';' @@ -38292,18 +38991,18 @@ _tmp_173_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'")); + D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'")); Token * _literal; if ( (_literal = _PyPegen_expect_token(p, 13)) // token=';' ) { - D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'")); + D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'")); _res = _literal; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'")); } { // NEWLINE @@ -38311,18 +39010,18 @@ _tmp_173_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); Token * newline_var; if ( (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' ) { - D(fprintf(stderr, "%*c+ _tmp_173[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); + D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); _res = newline_var; goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_173[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); } _res = NULL; @@ -38331,9 +39030,9 @@ _tmp_173_rule(Parser *p) return _res; } -// _tmp_174: expression ['as' star_target] +// _tmp_176: expression ['as' star_target] static void * -_tmp_174_rule(Parser *p) +_tmp_176_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38349,22 +39048,22 @@ _tmp_174_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty expression_var; if ( (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_177_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_180_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_174[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ['as' star_target]")); _res = _PyPegen_dummy_name(p, expression_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_174[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ['as' star_target]")); } _res = NULL; @@ -38373,9 +39072,9 @@ _tmp_174_rule(Parser *p) return _res; } -// _tmp_175: expressions ['as' star_target] +// _tmp_177: expressions ['as' star_target] static void * -_tmp_175_rule(Parser *p) +_tmp_177_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38391,22 +39090,22 @@ _tmp_175_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_175[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c> _tmp_177[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings expr_ty expressions_var; if ( (expressions_var = expressions_rule(p)) // expressions && - (_opt_var = _tmp_177_rule(p), !p->error_indicator) // ['as' star_target] + (_opt_var = _tmp_180_rule(p), !p->error_indicator) // ['as' star_target] ) { - D(fprintf(stderr, "%*c+ _tmp_175[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); + D(fprintf(stderr, "%*c+ _tmp_177[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions ['as' star_target]")); _res = _PyPegen_dummy_name(p, expressions_var, _opt_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_177[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions ['as' star_target]")); } _res = NULL; @@ -38415,9 +39114,68 @@ _tmp_175_rule(Parser *p) return _res; } -// _tmp_176: ',' bitwise_or +// _tmp_178: assignment_expression | expression !':=' static void * -_tmp_176_rule(Parser *p) +_tmp_178_rule(Parser *p) +{ + if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { + _Pypegen_stack_overflow(p); + } + if (p->error_indicator) { + p->level--; + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // assignment_expression + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + expr_ty assignment_expression_var; + if ( + (assignment_expression_var = assignment_expression_rule(p)) // assignment_expression + ) + { + D(fprintf(stderr, "%*c+ _tmp_178[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment_expression")); + _res = assignment_expression_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_178[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression")); + } + { // expression !':=' + if (p->error_indicator) { + p->level--; + return NULL; + } + D(fprintf(stderr, "%*c> _tmp_178[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); + expr_ty expression_var; + if ( + (expression_var = expression_rule(p)) // expression + && + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53) // token=':=' + ) + { + D(fprintf(stderr, "%*c+ _tmp_178[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); + _res = expression_var; + goto done; + } + p->mark = _mark; + D(fprintf(stderr, "%*c%s _tmp_178[%d-%d]: %s failed!\n", p->level, ' ', + p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); + } + _res = NULL; + done: + p->level--; + return _res; +} + +// _tmp_179: ',' bitwise_or +static void * +_tmp_179_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38433,7 +39191,7 @@ _tmp_176_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_176[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c> _tmp_179[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); Token * _literal; expr_ty bitwise_or_var; if ( @@ -38442,12 +39200,12 @@ _tmp_176_rule(Parser *p) (bitwise_or_var = bitwise_or_rule(p)) // bitwise_or ) { - D(fprintf(stderr, "%*c+ _tmp_176[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); + D(fprintf(stderr, "%*c+ _tmp_179[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' bitwise_or")); _res = _PyPegen_dummy_name(p, _literal, bitwise_or_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_179[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' bitwise_or")); } _res = NULL; @@ -38456,9 +39214,9 @@ _tmp_176_rule(Parser *p) return _res; } -// _tmp_177: 'as' star_target +// _tmp_180: 'as' star_target static void * -_tmp_177_rule(Parser *p) +_tmp_180_rule(Parser *p) { if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) { _Pypegen_stack_overflow(p); @@ -38474,21 +39232,21 @@ _tmp_177_rule(Parser *p) p->level--; return NULL; } - D(fprintf(stderr, "%*c> _tmp_177[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c> _tmp_180[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' star_target")); Token * _keyword; expr_ty star_target_var; if ( - (_keyword = _PyPegen_expect_token(p, 689)) // token='as' + (_keyword = _PyPegen_expect_token(p, 693)) // token='as' && (star_target_var = star_target_rule(p)) // star_target ) { - D(fprintf(stderr, "%*c+ _tmp_177[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); + D(fprintf(stderr, "%*c+ _tmp_180[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' star_target")); _res = _PyPegen_dummy_name(p, _keyword, star_target_var); goto done; } p->mark = _mark; - D(fprintf(stderr, "%*c%s _tmp_177[%d-%d]: %s failed!\n", p->level, ' ', + D(fprintf(stderr, "%*c%s _tmp_180[%d-%d]: %s failed!\n", p->level, ' ', p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' star_target")); } _res = NULL; diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 1cc88dc179e120..577adb825b070d 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -2864,7 +2864,12 @@ add_ast_annotations(struct ast_state *state) } { PyObject *type = state->expr_type; - Py_INCREF(type); + type = _Py_union_type_or(type, Py_None); + cond = type != NULL; + if (!cond) { + Py_DECREF(DictComp_annotations); + return 0; + } cond = PyDict_SetItemString(DictComp_annotations, "value", type) == 0; Py_DECREF(type); if (!cond) { @@ -6392,7 +6397,7 @@ init_types(void *arg) " | Set(expr* elts)\n" " | ListComp(expr elt, comprehension* generators)\n" " | SetComp(expr elt, comprehension* generators)\n" - " | DictComp(expr key, expr value, comprehension* generators)\n" + " | DictComp(expr key, expr? value, comprehension* generators)\n" " | GeneratorExp(expr elt, comprehension* generators)\n" " | Await(expr value)\n" " | Yield(expr? value)\n" @@ -6460,8 +6465,10 @@ init_types(void *arg) if (!state->SetComp_type) return -1; state->DictComp_type = make_type(state, "DictComp", state->expr_type, DictComp_fields, 3, - "DictComp(expr key, expr value, comprehension* generators)"); + "DictComp(expr key, expr? value, comprehension* generators)"); if (!state->DictComp_type) return -1; + if (PyObject_SetAttr(state->DictComp_type, state->value, Py_None) == -1) + return -1; state->GeneratorExp_type = make_type(state, "GeneratorExp", state->expr_type, GeneratorExp_fields, 2, @@ -8007,11 +8014,6 @@ _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq * "field 'key' is required for DictComp"); return NULL; } - if (!value) { - PyErr_SetString(PyExc_ValueError, - "field 'value' is required for DictComp"); - return NULL; - } p = (expr_ty)_PyArena_Malloc(arena, sizeof(*p)); if (!p) return NULL; @@ -14526,9 +14528,9 @@ obj2ast_expr(struct ast_state *state, PyObject* obj, expr_ty* out, PyArena* if (PyObject_GetOptionalAttr(obj, state->value, &tmp) < 0) { return -1; } - if (tmp == NULL) { - PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from DictComp"); - return -1; + if (tmp == NULL || tmp == Py_None) { + Py_CLEAR(tmp); + value = NULL; } else { int res; diff --git a/Python/ast.c b/Python/ast.c index e01dd0de51e596..4cfa2ff559a5f7 100644 --- a/Python/ast.c +++ b/Python/ast.c @@ -305,8 +305,10 @@ validate_expr(expr_ty exp, expr_context_ty ctx) #undef COMP case DictComp_kind: ret = validate_comprehension(exp->v.DictComp.generators) && - validate_expr(exp->v.DictComp.key, Load) && - validate_expr(exp->v.DictComp.value, Load); + validate_expr(exp->v.DictComp.key, Load); + if (ret && exp->v.DictComp.value != NULL){ + ret = validate_expr(exp->v.DictComp.value, Load); + } break; case Yield_kind: ret = !exp->v.Yield.value || validate_expr(exp->v.Yield.value, Load); diff --git a/Python/ast_preprocess.c b/Python/ast_preprocess.c index d45435257cc8ac..54dec3dfe04268 100644 --- a/Python/ast_preprocess.c +++ b/Python/ast_preprocess.c @@ -557,7 +557,9 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTPreprocessState *state) break; case DictComp_kind: CALL(astfold_expr, expr_ty, node_->v.DictComp.key); - CALL(astfold_expr, expr_ty, node_->v.DictComp.value); + if (node_->v.DictComp.value != NULL){ + CALL(astfold_expr, expr_ty, node_->v.DictComp.value); + } CALL_SEQ(astfold_comprehension, comprehension, node_->v.DictComp.generators); break; case GeneratorExp_kind: diff --git a/Python/codegen.c b/Python/codegen.c index 478fbec1cbadd0..5227312b4f75f8 100644 --- a/Python/codegen.c +++ b/Python/codegen.c @@ -4522,28 +4522,63 @@ codegen_sync_comprehension_generator(compiler *c, location loc, /* comprehension specific code */ switch (type) { case COMP_GENEXP: - VISIT(c, expr, elt); - ADDOP_YIELD(c, elt_loc); - ADDOP(c, elt_loc, POP_TOP); + if (elt->kind == Starred_kind) { + NEW_JUMP_TARGET_LABEL(c, unpack_start); + NEW_JUMP_TARGET_LABEL(c, unpack_end); + VISIT(c, expr, elt->v.Starred.value); + ADDOP(c, elt_loc, GET_ITER); + USE_LABEL(c, unpack_start); + ADDOP_JUMP(c, elt_loc, FOR_ITER, unpack_end); + ADDOP_YIELD(c, elt_loc); + ADDOP(c, elt_loc, POP_TOP); + ADDOP_JUMP(c, NO_LOCATION, JUMP, unpack_start); + USE_LABEL(c, unpack_end); + ADDOP(c, NO_LOCATION, END_FOR); + ADDOP(c, NO_LOCATION, POP_ITER); + } + else { + VISIT(c, expr, elt); + ADDOP_YIELD(c, elt_loc); + ADDOP(c, elt_loc, POP_TOP); + } break; case COMP_LISTCOMP: - VISIT(c, expr, elt); - ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); + if (elt->kind == Starred_kind) { + VISIT(c, expr, elt->v.Starred.value); + ADDOP_I(c, elt_loc, LIST_EXTEND, depth + 1); + } + else { + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); + } break; case COMP_SETCOMP: - VISIT(c, expr, elt); - ADDOP_I(c, elt_loc, SET_ADD, depth + 1); + if (elt->kind == Starred_kind) { + VISIT(c, expr, elt->v.Starred.value); + ADDOP_I(c, elt_loc, SET_UPDATE, depth + 1); + } + else { + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, SET_ADD, depth + 1); + } break; case COMP_DICTCOMP: - /* With '{k: v}', k is evaluated before v, so we do - the same. */ - VISIT(c, expr, elt); - VISIT(c, expr, val); - elt_loc = LOCATION(elt->lineno, - val->end_lineno, - elt->col_offset, - val->end_col_offset); - ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); + if (val == NULL) { + /* unpacking (**) case */ + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, DICT_UPDATE, depth+1); + } + else { + /* With '{k: v}', k is evaluated before v, so we do + the same. */ + VISIT(c, expr, elt); + VISIT(c, expr, val); + elt_loc = LOCATION(elt->lineno, + val->end_lineno, + elt->col_offset, + val->end_col_offset); + ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); + } break; default: return ERROR; @@ -4629,28 +4664,63 @@ codegen_async_comprehension_generator(compiler *c, location loc, /* comprehension specific code */ switch (type) { case COMP_GENEXP: - VISIT(c, expr, elt); - ADDOP_YIELD(c, elt_loc); - ADDOP(c, elt_loc, POP_TOP); + if (elt->kind == Starred_kind) { + NEW_JUMP_TARGET_LABEL(c, unpack_start); + NEW_JUMP_TARGET_LABEL(c, unpack_end); + VISIT(c, expr, elt->v.Starred.value); + ADDOP(c, elt_loc, GET_ITER); + USE_LABEL(c, unpack_start); + ADDOP_JUMP(c, elt_loc, FOR_ITER, unpack_end); + ADDOP_YIELD(c, elt_loc); + ADDOP(c, elt_loc, POP_TOP); + ADDOP_JUMP(c, NO_LOCATION, JUMP, unpack_start); + USE_LABEL(c, unpack_end); + ADDOP(c, NO_LOCATION, END_FOR); + ADDOP(c, NO_LOCATION, POP_ITER); + } + else { + VISIT(c, expr, elt); + ADDOP_YIELD(c, elt_loc); + ADDOP(c, elt_loc, POP_TOP); + } break; case COMP_LISTCOMP: - VISIT(c, expr, elt); - ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); + if (elt->kind == Starred_kind) { + VISIT(c, expr, elt->v.Starred.value); + ADDOP_I(c, elt_loc, LIST_EXTEND, depth + 1); + } + else { + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, LIST_APPEND, depth + 1); + } break; case COMP_SETCOMP: - VISIT(c, expr, elt); - ADDOP_I(c, elt_loc, SET_ADD, depth + 1); + if (elt->kind == Starred_kind) { + VISIT(c, expr, elt->v.Starred.value); + ADDOP_I(c, elt_loc, SET_UPDATE, depth + 1); + } + else { + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, SET_ADD, depth + 1); + } break; case COMP_DICTCOMP: - /* With '{k: v}', k is evaluated before v, so we do - the same. */ - VISIT(c, expr, elt); - VISIT(c, expr, val); - elt_loc = LOCATION(elt->lineno, - val->end_lineno, - elt->col_offset, - val->end_col_offset); - ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); + if (val == NULL) { + /* unpacking (**) case */ + VISIT(c, expr, elt); + ADDOP_I(c, elt_loc, DICT_UPDATE, depth+1); + } + else { + /* With '{k: v}', k is evaluated before v, so we do + the same. */ + VISIT(c, expr, elt); + VISIT(c, expr, val); + elt_loc = LOCATION(elt->lineno, + val->end_lineno, + elt->col_offset, + val->end_col_offset); + ADDOP_I(c, elt_loc, MAP_ADD, depth + 1); + } break; default: return ERROR;

1 0

gh-144319: Fix huge page safety in pymalloc arenas (#144331)
by pablogsal Jan. 30, 2026

Jan. 30, 2026

https://github.com/python/cpython/commit/96e4cd698a3000382f1796366e9c963902… commit: 96e4cd698a3000382f1796366e9c963902381382 branch: main author: Pablo Galindo Salgado <Pablogsal(a)gmail.com> committer: pablogsal <Pablogsal(a)gmail.com> date: 2026-01-30T18:18:56Z summary: gh-144319: Fix huge page safety in pymalloc arenas (#144331) The pymalloc huge page support had two problems. First, on architectures where the default huge page size exceeds the arena size (e.g. 32 MiB on PPC, 512 MiB on ARM64 with 64 KB base pages), mmap with MAP_HUGETLB silently allocates a full huge page even when the requested size is smaller. The subsequent munmap with the original arena size then fails with EINVAL, permanently leaking the entire huge page. Second, huge pages were always attempted when compiled in, with no way to disable them at runtime. On Linux, if the huge page pool is exhausted, page faults including copy-on-write faults after fork deliver SIGBUS and kill the process. The arena allocator now queries the system huge page size from /proc/meminfo and skips MAP_HUGETLB when the arena size is not a multiple of it. Huge pages also now require explicit opt-in at runtime via the PYTHON_PYMALLOC_HUGEPAGES environment variable, which is read through PyConfig and respects -E and -I flags. The config field pymalloc_hugepages is propagated to the runtime allocators struct so the low-level arena allocator can check it without calling getenv directly. files: M Doc/using/cmdline.rst M Doc/using/configure.rst M Doc/whatsnew/3.15.rst M Include/cpython/initconfig.h M Include/internal/pycore_runtime_structs.h M Lib/test/test_capi/test_config.py M Lib/test/test_embed.py M Objects/obmalloc.c M Programs/_testembed.c M Python/initconfig.c diff --git a/Doc/using/cmdline.rst b/Doc/using/cmdline.rst index aff165191b76e8..c97058119ae838 100644 --- a/Doc/using/cmdline.rst +++ b/Doc/using/cmdline.rst @@ -1087,6 +1087,27 @@ conflict. It now has no effect if set to an empty string. +.. envvar:: PYTHON_PYMALLOC_HUGEPAGES + + If set to a non-zero integer, enable huge page support for + :ref:`pymalloc <pymalloc>` arenas. Set to ``0`` or unset to disable. + Python must be compiled with :option:`--with-pymalloc-hugepages` for this + variable to have any effect. + + When enabled, arena allocation uses ``MAP_HUGETLB`` (Linux) or + ``MEM_LARGE_PAGES`` (Windows) with automatic fallback to regular pages if + huge pages are not available. + + .. warning:: + + On Linux, if the huge-page pool is exhausted, page faults — including + copy-on-write faults triggered by :func:`os.fork` — deliver ``SIGBUS`` + and kill the process. Only enable this in environments where the + huge-page pool is properly sized and fork-safety is not a concern. + + .. versionadded:: next + + .. envvar:: PYTHONLEGACYWINDOWSFSENCODING If set to a non-empty string, the default :term:`filesystem encoding and diff --git a/Doc/using/configure.rst b/Doc/using/configure.rst index c455272af72715..26322045879cb2 100644 --- a/Doc/using/configure.rst +++ b/Doc/using/configure.rst @@ -790,6 +790,12 @@ also be used to improve performance. 2 MiB and arena allocation uses ``MAP_HUGETLB`` (Linux) or ``MEM_LARGE_PAGES`` (Windows) with automatic fallback to regular pages. + Even when compiled with this option, huge pages are **not** used at runtime + unless the :envvar:`PYTHON_PYMALLOC_HUGEPAGES` environment variable is set + to ``1``. This opt-in is required because huge pages carry risks on Linux: + if the huge-page pool is exhausted, page faults (including copy-on-write + faults after :func:`os.fork`) deliver ``SIGBUS`` and kill the process. + The configure script checks that the platform supports ``MAP_HUGETLB`` and emits a warning if it is not available. diff --git a/Doc/whatsnew/3.15.rst b/Doc/whatsnew/3.15.rst index 68c491f8a8cbb6..637dd0cca24bb9 100644 --- a/Doc/whatsnew/3.15.rst +++ b/Doc/whatsnew/3.15.rst @@ -1482,6 +1482,8 @@ Build changes increases to 2 MiB and allocation uses ``MAP_HUGETLB`` (Linux) or ``MEM_LARGE_PAGES`` (Windows) with automatic fallback to regular pages. On Windows, use ``build.bat --pymalloc-hugepages``. + At runtime, huge pages must be explicitly enabled by setting the + :envvar:`PYTHON_PYMALLOC_HUGEPAGES` environment variable to ``1``. * Annotating anonymous mmap usage is now supported if Linux kernel supports :manpage:`PR_SET_VMA_ANON_NAME <PR_SET_VMA(2const)>` (Linux 5.17 or newer). diff --git a/Include/cpython/initconfig.h b/Include/cpython/initconfig.h index 1c979d91a40850..5606ebeb7c95e0 100644 --- a/Include/cpython/initconfig.h +++ b/Include/cpython/initconfig.h @@ -149,6 +149,7 @@ typedef struct PyConfig { int dump_refs; wchar_t *dump_refs_file; int malloc_stats; + int pymalloc_hugepages; wchar_t *filesystem_encoding; wchar_t *filesystem_errors; wchar_t *pycache_prefix; diff --git a/Include/internal/pycore_runtime_structs.h b/Include/internal/pycore_runtime_structs.h index 92387031ad7465..f48d203dda00fc 100644 --- a/Include/internal/pycore_runtime_structs.h +++ b/Include/internal/pycore_runtime_structs.h @@ -31,6 +31,7 @@ struct _pymem_allocators { debug_alloc_api_t obj; } debug; int is_debug_enabled; + int use_hugepages; PyObjectArenaAllocator obj_arena; }; diff --git a/Lib/test/test_capi/test_config.py b/Lib/test/test_capi/test_config.py index 04a27de8d84994..b04d0923926ded 100644 --- a/Lib/test/test_capi/test_config.py +++ b/Lib/test/test_capi/test_config.py @@ -63,6 +63,7 @@ def test_config_get(self): ("interactive", bool, None), ("isolated", bool, None), ("malloc_stats", bool, None), + ("pymalloc_hugepages", bool, None), ("module_search_paths", list[str], "path"), ("optimization_level", int, None), ("orig_argv", list[str], "orig_argv"), diff --git a/Lib/test/test_embed.py b/Lib/test/test_embed.py index b536794122787d..29b1249b10dfc8 100644 --- a/Lib/test/test_embed.py +++ b/Lib/test/test_embed.py @@ -642,6 +642,7 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase): 'dump_refs': False, 'dump_refs_file': None, 'malloc_stats': False, + 'pymalloc_hugepages': False, 'filesystem_encoding': GET_DEFAULT_CONFIG, 'filesystem_errors': GET_DEFAULT_CONFIG, @@ -1044,6 +1045,7 @@ def test_init_from_config(self): 'code_debug_ranges': False, 'show_ref_count': True, 'malloc_stats': True, + 'pymalloc_hugepages': True, 'stdio_encoding': 'iso8859-1', 'stdio_errors': 'replace', @@ -1109,6 +1111,7 @@ def test_init_compat_env(self): 'import_time': 1, 'code_debug_ranges': False, 'malloc_stats': True, + 'pymalloc_hugepages': True, 'inspect': True, 'optimization_level': 2, 'pythonpath_env': '/my/path', @@ -1145,6 +1148,7 @@ def test_init_python_env(self): 'import_time': 1, 'code_debug_ranges': False, 'malloc_stats': True, + 'pymalloc_hugepages': True, 'inspect': True, 'optimization_level': 2, 'pythonpath_env': '/my/path', diff --git a/Objects/obmalloc.c b/Objects/obmalloc.c index 71dc4bf0d0461c..ce2e39790bd76c 100644 --- a/Objects/obmalloc.c +++ b/Objects/obmalloc.c @@ -13,6 +13,7 @@ #include <stdlib.h> // malloc() #include <stdbool.h> +#include <stdio.h> // fopen(), fgets(), sscanf() #ifdef WITH_MIMALLOC // Forward declarations of functions used in our mimalloc modifications static void _PyMem_mi_page_clear_qsbr(mi_page_t *page); @@ -492,16 +493,57 @@ _PyMem_DefaultRawWcsdup(const wchar_t *str) # endif #endif +/* Return the system's default huge page size in bytes, or 0 if it + * cannot be determined. The result is cached after the first call. + * + * This is Linux-only (/proc/meminfo). On other systems that define + * MAP_HUGETLB the caller should skip huge pages gracefully. */ +#if defined(PYMALLOC_USE_HUGEPAGES) && defined(ARENAS_USE_MMAP) && defined(MAP_HUGETLB) +static size_t +_pymalloc_system_hugepage_size(void) +{ + static size_t hp_size = 0; + static int initialized = 0; + + if (initialized) { + return hp_size; + } + +#ifdef __linux__ + FILE *f = fopen("/proc/meminfo", "r"); + if (f != NULL) { + char line[256]; + while (fgets(line, sizeof(line), f)) { + unsigned long size_kb; + if (sscanf(line, "Hugepagesize: %lu kB", &size_kb) == 1) { + hp_size = (size_t)size_kb * 1024; + break; + } + } + fclose(f); + } +#endif + + initialized = 1; + return hp_size; +} +#endif + void * _PyMem_ArenaAlloc(void *Py_UNUSED(ctx), size_t size) { #ifdef MS_WINDOWS # ifdef PYMALLOC_USE_HUGEPAGES - void *ptr = VirtualAlloc(NULL, size, - MEM_COMMIT | MEM_RESERVE | MEM_LARGE_PAGES, - PAGE_READWRITE); - if (ptr != NULL) - return ptr; + if (_PyRuntime.allocators.use_hugepages) { + SIZE_T lp_size = GetLargePageMinimum(); + if (lp_size > 0 && size % lp_size == 0) { + void *ptr = VirtualAlloc(NULL, size, + MEM_COMMIT | MEM_RESERVE | MEM_LARGE_PAGES, + PAGE_READWRITE); + if (ptr != NULL) + return ptr; + } + } /* Fall back to regular pages */ # endif return VirtualAlloc(NULL, size, @@ -510,12 +552,23 @@ _PyMem_ArenaAlloc(void *Py_UNUSED(ctx), size_t size) void *ptr; # ifdef PYMALLOC_USE_HUGEPAGES # ifdef MAP_HUGETLB - ptr = mmap(NULL, size, PROT_READ|PROT_WRITE, - MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB, -1, 0); - if (ptr != MAP_FAILED) { - assert(ptr != NULL); - (void)_PyAnnotateMemoryMap(ptr, size, "cpython:pymalloc:hugepage"); - return ptr; + if (_PyRuntime.allocators.use_hugepages) { + size_t hp_size = _pymalloc_system_hugepage_size(); + /* Only use huge pages if the arena size is a multiple of the + * system's default huge page size. When the arena is smaller + * than the huge page, mmap still succeeds but silently + * allocates an entire huge page; the subsequent munmap with + * the smaller arena size then fails with EINVAL, leaking + * all of that memory. */ + if (hp_size > 0 && size % hp_size == 0) { + ptr = mmap(NULL, size, PROT_READ|PROT_WRITE, + MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB, -1, 0); + if (ptr != MAP_FAILED) { + assert(ptr != NULL); + (void)_PyAnnotateMemoryMap(ptr, size, "cpython:pymalloc:hugepage"); + return ptr; + } + } } /* Fall back to regular pages */ # endif diff --git a/Programs/_testembed.c b/Programs/_testembed.c index c5e764e426b5f1..38f546b976cac3 100644 --- a/Programs/_testembed.c +++ b/Programs/_testembed.c @@ -639,6 +639,7 @@ static int test_init_from_config(void) putenv("PYTHONMALLOCSTATS=0"); config.malloc_stats = 1; + config.pymalloc_hugepages = 1; putenv("PYTHONPYCACHEPREFIX=env_pycache_prefix"); config_set_string(&config, &config.pycache_prefix, L"conf_pycache_prefix"); @@ -795,6 +796,7 @@ static void set_most_env_vars(void) putenv("PYTHONPROFILEIMPORTTIME=1"); putenv("PYTHONNODEBUGRANGES=1"); putenv("PYTHONMALLOCSTATS=1"); + putenv("PYTHON_PYMALLOC_HUGEPAGES=1"); putenv("PYTHONUTF8=1"); putenv("PYTHONVERBOSE=1"); putenv("PYTHONINSPECT=1"); diff --git a/Python/initconfig.c b/Python/initconfig.c index 9cdc10c4e78071..46fd8929041f45 100644 --- a/Python/initconfig.c +++ b/Python/initconfig.c @@ -160,6 +160,7 @@ static const PyConfigSpec PYCONFIG_SPEC[] = { SPEC(legacy_windows_stdio, BOOL, READ_ONLY, NO_SYS), #endif SPEC(malloc_stats, BOOL, READ_ONLY, NO_SYS), + SPEC(pymalloc_hugepages, BOOL, READ_ONLY, NO_SYS), SPEC(orig_argv, WSTR_LIST, READ_ONLY, SYS_ATTR("orig_argv")), SPEC(parse_argv, BOOL, READ_ONLY, NO_SYS), SPEC(pathconfig_warnings, BOOL, READ_ONLY, NO_SYS), @@ -900,6 +901,7 @@ config_check_consistency(const PyConfig *config) assert(config->show_ref_count >= 0); assert(config->dump_refs >= 0); assert(config->malloc_stats >= 0); + assert(config->pymalloc_hugepages >= 0); assert(config->site_import >= 0); assert(config->bytes_warning >= 0); assert(config->warn_default_encoding >= 0); @@ -1879,6 +1881,18 @@ config_read_env_vars(PyConfig *config) if (config_get_env(config, "PYTHONMALLOCSTATS")) { config->malloc_stats = 1; } + { + const char *env = _Py_GetEnv(use_env, "PYTHON_PYMALLOC_HUGEPAGES"); + if (env) { + int value; + if (_Py_str_to_int(env, &value) < 0 || value < 0) { + /* PYTHON_PYMALLOC_HUGEPAGES=text or negative + behaves as PYTHON_PYMALLOC_HUGEPAGES=1 */ + value = 1; + } + config->pymalloc_hugepages = (value > 0); + } + } if (config->dump_refs_file == NULL) { status = CONFIG_GET_ENV_DUP(config, &config->dump_refs_file, @@ -2812,6 +2826,10 @@ _PyConfig_Write(const PyConfig *config, _PyRuntimeState *runtime) return _PyStatus_NO_MEMORY(); } +#ifdef PYMALLOC_USE_HUGEPAGES + runtime->allocators.use_hugepages = config->pymalloc_hugepages; +#endif + return _PyStatus_OK(); }

1 0

gh-120321: Make gi_yieldfrom thread-safe in free-threading build (#144292)
by colesbury Jan. 30, 2026

Jan. 30, 2026

https://github.com/python/cpython/commit/a01694dacd8e8bbbd019e8b87dbc7bc717… commit: a01694dacd8e8bbbd019e8b87dbc7bc7173cb7f1 branch: main author: Sam Gross <colesbury(a)gmail.com> committer: colesbury <colesbury(a)gmail.com> date: 2026-01-30T12:20:27-05:00 summary: gh-120321: Make gi_yieldfrom thread-safe in free-threading build (#144292) Add a FRAME_SUSPENDED_YIELD_FROM_LOCKED state that acts as a brief lock, preventing other threads from transitioning the frame state while gen_getyieldfrom reads the yield-from object off the stack. files: A Misc/NEWS.d/next/Core_and_Builtins/2026-01-27-17-49-43.gh-issue-120321.Vo7c9T.rst M Include/internal/pycore_frame.h M Include/internal/pycore_lock.h M Lib/test/support/threading_helper.py M Lib/test/test_free_threading/test_generators.py M Objects/genobject.c M Python/ceval.c M Python/ceval_macros.h M Python/lock.c diff --git a/Include/internal/pycore_frame.h b/Include/internal/pycore_frame.h index 8c410e9e208340..50908f2cb7a1d2 100644 --- a/Include/internal/pycore_frame.h +++ b/Include/internal/pycore_frame.h @@ -44,15 +44,16 @@ extern PyFrameObject* _PyFrame_New_NoTrack(PyCodeObject *code); /* other API */ typedef enum _framestate { - FRAME_CREATED = -3, - FRAME_SUSPENDED = -2, - FRAME_SUSPENDED_YIELD_FROM = -1, + FRAME_CREATED = -4, + FRAME_SUSPENDED = -3, + FRAME_SUSPENDED_YIELD_FROM = -2, + FRAME_SUSPENDED_YIELD_FROM_LOCKED = -1, FRAME_EXECUTING = 0, FRAME_COMPLETED = 1, FRAME_CLEARED = 4 } PyFrameState; -#define FRAME_STATE_SUSPENDED(S) ((S) == FRAME_SUSPENDED || (S) == FRAME_SUSPENDED_YIELD_FROM) +#define FRAME_STATE_SUSPENDED(S) ((S) >= FRAME_SUSPENDED && (S) <= FRAME_SUSPENDED_YIELD_FROM_LOCKED) #define FRAME_STATE_FINISHED(S) ((S) >= FRAME_COMPLETED) #ifdef __cplusplus diff --git a/Include/internal/pycore_lock.h b/Include/internal/pycore_lock.h index c4e007e744ce0f..e31d8b4e5c68c9 100644 --- a/Include/internal/pycore_lock.h +++ b/Include/internal/pycore_lock.h @@ -70,6 +70,9 @@ PyMutex_LockFlags(PyMutex *m, _PyLockFlags flags) // error messages) otherwise returns 0. extern int _PyMutex_TryUnlock(PyMutex *m); +// Yield the processor to other threads (e.g., sched_yield). +extern void _Py_yield(void); + // PyEvent is a one-time event notification typedef struct { diff --git a/Lib/test/support/threading_helper.py b/Lib/test/support/threading_helper.py index 3e04c344a0d66f..cf87233f0e2e93 100644 --- a/Lib/test/support/threading_helper.py +++ b/Lib/test/support/threading_helper.py @@ -250,21 +250,32 @@ def requires_working_threading(*, module=False): return unittest.skipUnless(can_start_thread, msg) -def run_concurrently(worker_func, nthreads, args=(), kwargs={}): +def run_concurrently(worker_func, nthreads=None, args=(), kwargs={}): """ - Run the worker function concurrently in multiple threads. + Run the worker function(s) concurrently in multiple threads. + + If `worker_func` is a single callable, it is used for all threads. + If it is a list of callables, each callable is used for one thread. """ + from collections.abc import Iterable + + if nthreads is None: + nthreads = len(worker_func) + if not isinstance(worker_func, Iterable): + worker_func = [worker_func] * nthreads + assert len(worker_func) == nthreads + barrier = threading.Barrier(nthreads) - def wrapper_func(*args, **kwargs): + def wrapper_func(func, *args, **kwargs): # Wait for all threads to reach this point before proceeding. barrier.wait() - worker_func(*args, **kwargs) + func(*args, **kwargs) with catch_threading_exception() as cm: workers = [ - threading.Thread(target=wrapper_func, args=args, kwargs=kwargs) - for _ in range(nthreads) + threading.Thread(target=wrapper_func, args=(func, *args), kwargs=kwargs) + for func in worker_func ] with start_threads(workers): pass diff --git a/Lib/test/test_free_threading/test_generators.py b/Lib/test/test_free_threading/test_generators.py index 11f59301bcd51d..2b41e28896f5a8 100644 --- a/Lib/test/test_free_threading/test_generators.py +++ b/Lib/test/test_free_threading/test_generators.py @@ -1,4 +1,6 @@ import concurrent.futures +import itertools +import threading import unittest from threading import Barrier from unittest import TestCase @@ -120,3 +122,38 @@ def drive_generator(g): g = gen() threading_helper.run_concurrently(drive_generator, self.NUM_THREADS, args=(g,)) + + def test_concurrent_gi_yieldfrom(self): + def gen_yield_from(): + yield from itertools.count() + + g = gen_yield_from() + next(g) # Put in FRAME_SUSPENDED_YIELD_FROM state + + def read_yieldfrom(gen): + for _ in range(10000): + self.assertIsNotNone(gen.gi_yieldfrom) + + threading_helper.run_concurrently(read_yieldfrom, self.NUM_THREADS, args=(g,)) + + def test_gi_yieldfrom_close_race(self): + def gen_yield_from(): + yield from itertools.count() + + g = gen_yield_from() + next(g) + + done = threading.Event() + + def reader(): + while not done.is_set(): + g.gi_yieldfrom + + def closer(): + try: + g.close() + except ValueError: + pass + done.set() + + threading_helper.run_concurrently([reader, closer]) diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-01-27-17-49-43.gh-issue-120321.Vo7c9T.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-01-27-17-49-43.gh-issue-120321.Vo7c9T.rst new file mode 100644 index 00000000000000..052ed07c123bcf --- /dev/null +++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-01-27-17-49-43.gh-issue-120321.Vo7c9T.rst @@ -0,0 +1,2 @@ +Made ``gi_yieldfrom`` thread-safe in the free-threading build +by using a lightweight lock on the frame state. diff --git a/Objects/genobject.c b/Objects/genobject.c index fcdb9017a35f5b..5ff4618255c852 100644 --- a/Objects/genobject.c +++ b/Objects/genobject.c @@ -10,6 +10,7 @@ #include "pycore_gc.h" // _PyGC_CLEAR_FINALIZED() #include "pycore_genobject.h" // _PyGen_SetStopIterationValue() #include "pycore_interpframe.h" // _PyFrame_GetCode() +#include "pycore_lock.h" // _Py_yield() #include "pycore_modsupport.h" // _PyArg_CheckPositional() #include "pycore_object.h" // _PyObject_GC_UNTRACK() #include "pycore_opcode_utils.h" // RESUME_AFTER_YIELD_FROM @@ -37,8 +38,20 @@ static PyObject* async_gen_athrow_new(PyAsyncGenObject *, PyObject *); _Py_CAST(PyAsyncGenObject*, (op)) #ifdef Py_GIL_DISABLED +static bool +gen_try_set_frame_state(PyGenObject *gen, int8_t *expected, int8_t state) +{ + if (*expected == FRAME_SUSPENDED_YIELD_FROM_LOCKED) { + // Wait for the in-progress gi_yieldfrom read to complete + _Py_yield(); + *expected = _Py_atomic_load_int8_relaxed(&gen->gi_frame_state); + return false; + } + return _Py_atomic_compare_exchange_int8(&gen->gi_frame_state, expected, state); +} + # define _Py_GEN_TRY_SET_FRAME_STATE(gen, expected, state) \ - _Py_atomic_compare_exchange_int8(&(gen)->gi_frame_state, &expected, (state)) + gen_try_set_frame_state((gen), &(expected), (state)) #else # define _Py_GEN_TRY_SET_FRAME_STATE(gen, expected, state) \ ((gen)->gi_frame_state = (state), true) @@ -470,9 +483,7 @@ gen_close(PyObject *self, PyObject *args) return NULL; } - assert(frame_state == FRAME_SUSPENDED_YIELD_FROM || - frame_state == FRAME_SUSPENDED); - + assert(FRAME_STATE_SUSPENDED(frame_state)); } while (!_Py_GEN_TRY_SET_FRAME_STATE(gen, frame_state, FRAME_EXECUTING)); int err = 0; @@ -876,12 +887,26 @@ static PyObject * gen_getyieldfrom(PyObject *self, void *Py_UNUSED(ignored)) { PyGenObject *gen = _PyGen_CAST(self); - int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(gen->gi_frame_state); +#ifdef Py_GIL_DISABLED + int8_t frame_state = _Py_atomic_load_int8_relaxed(&gen->gi_frame_state); + do { + if (frame_state != FRAME_SUSPENDED_YIELD_FROM && + frame_state != FRAME_SUSPENDED_YIELD_FROM_LOCKED) + { + Py_RETURN_NONE; + } + } while (!_Py_GEN_TRY_SET_FRAME_STATE(gen, frame_state, FRAME_SUSPENDED_YIELD_FROM_LOCKED)); + + PyObject *result = PyStackRef_AsPyObjectNew(_PyFrame_StackPeek(&gen->gi_iframe)); + _Py_atomic_store_int8_release(&gen->gi_frame_state, FRAME_SUSPENDED_YIELD_FROM); + return result; +#else + int8_t frame_state = gen->gi_frame_state; if (frame_state != FRAME_SUSPENDED_YIELD_FROM) { Py_RETURN_NONE; } - // TODO: still not thread-safe with free threading return PyStackRef_AsPyObjectNew(_PyFrame_StackPeek(&gen->gi_iframe)); +#endif } diff --git a/Python/ceval.c b/Python/ceval.c index 04ae7b4d86f9d0..c59f20bbf1e803 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -3391,7 +3391,9 @@ _PyEval_GetAwaitable(PyObject *iterable, int oparg) else if (PyCoro_CheckExact(iter)) { PyCoroObject *coro = (PyCoroObject *)iter; int8_t frame_state = FT_ATOMIC_LOAD_INT8_RELAXED(coro->cr_frame_state); - if (frame_state == FRAME_SUSPENDED_YIELD_FROM) { + if (frame_state == FRAME_SUSPENDED_YIELD_FROM || + frame_state == FRAME_SUSPENDED_YIELD_FROM_LOCKED) + { /* `iter` is a coroutine object that is being awaited. */ Py_CLEAR(iter); _PyErr_SetString(PyThreadState_GET(), PyExc_RuntimeError, diff --git a/Python/ceval_macros.h b/Python/ceval_macros.h index 1cbeb18d02c082..b127812b4bf703 100644 --- a/Python/ceval_macros.h +++ b/Python/ceval_macros.h @@ -522,19 +522,22 @@ gen_try_set_executing(PyGenObject *gen) #ifdef Py_GIL_DISABLED if (!_PyObject_IsUniquelyReferenced((PyObject *)gen)) { int8_t frame_state = _Py_atomic_load_int8_relaxed(&gen->gi_frame_state); - while (frame_state < FRAME_EXECUTING) { + while (frame_state < FRAME_SUSPENDED_YIELD_FROM_LOCKED) { if (_Py_atomic_compare_exchange_int8(&gen->gi_frame_state, &frame_state, FRAME_EXECUTING)) { return true; } } + // NB: We return false for FRAME_SUSPENDED_YIELD_FROM_LOCKED as well. + // That case is rare enough that we can just handle it in the deopt. return false; } #endif // Use faster non-atomic modifications in the GIL-enabled build and when // the object is uniquely referenced in the free-threaded build. if (gen->gi_frame_state < FRAME_EXECUTING) { + assert(gen->gi_frame_state != FRAME_SUSPENDED_YIELD_FROM_LOCKED); gen->gi_frame_state = FRAME_EXECUTING; return true; } diff --git a/Python/lock.c b/Python/lock.c index 12b5ebc89aeec7..ad97bfd93c8495 100644 --- a/Python/lock.c +++ b/Python/lock.c @@ -40,7 +40,7 @@ struct mutex_entry { int handed_off; }; -static void +void _Py_yield(void) { #ifdef MS_WINDOWS

1 0

[3.14] gh-144295: Fix data race in dict method lookup and global load (gh-144312) (#144346)
by colesbury Jan. 30, 2026

Jan. 30, 2026

https://github.com/python/cpython/commit/06f9c8ca1cb9abe92507108a299a65ee86… commit: 06f9c8ca1cb9abe92507108a299a65ee868d07e3 branch: 3.14 author: Sam Gross <colesbury(a)gmail.com> committer: colesbury <colesbury(a)gmail.com> date: 2026-01-30T12:15:47-05:00 summary: [3.14] gh-144295: Fix data race in dict method lookup and global load (gh-144312) (#144346) In `_Py_dict_lookup_threadsafe_stackref`, call `ensure_shared_on_read()` to prevent a race between the lookup and concurrent dict resizes, which may free the PyDictKeysObject (i.e., it ensures that the resize uses QSBR). (cherry picked from commit e666a01ef42939f77f4c22ca47a610df5ef8b7ab) files: M Lib/test/test_free_threading/test_dict.py M Objects/dictobject.c diff --git a/Lib/test/test_free_threading/test_dict.py b/Lib/test/test_free_threading/test_dict.py index 5d5d4e226caa40..1ffd924e9f477a 100644 --- a/Lib/test/test_free_threading/test_dict.py +++ b/Lib/test/test_free_threading/test_dict.py @@ -245,5 +245,27 @@ def reader(): with threading_helper.start_threads([t1, t2]): pass + def test_racing_dict_update_and_method_lookup(self): + # gh-144295: test race between dict modifications and method lookups. + # Uses BytesIO because the race requires a type without Py_TPFLAGS_INLINE_VALUES + # for the _PyDict_GetMethodStackRef code path. + import io + obj = io.BytesIO() + + def writer(): + for _ in range(10000): + obj.x = 1 + del obj.x + + def reader(): + for _ in range(10000): + obj.getvalue() + + t1 = Thread(target=writer) + t2 = Thread(target=reader) + + with threading_helper.start_threads([t1, t2]): + pass + if __name__ == "__main__": unittest.main() diff --git a/Objects/dictobject.c b/Objects/dictobject.c index e7d5088ded7b4c..c2223af950064c 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -1587,7 +1587,9 @@ _Py_dict_lookup_threadsafe(PyDictObject *mp, PyObject *key, Py_hash_t hash, PyOb Py_ssize_t _Py_dict_lookup_threadsafe_stackref(PyDictObject *mp, PyObject *key, Py_hash_t hash, _PyStackRef *value_addr) { - PyDictKeysObject *dk = _Py_atomic_load_ptr(&mp->ma_keys); + ensure_shared_on_read(mp); + + PyDictKeysObject *dk = _Py_atomic_load_ptr_acquire(&mp->ma_keys); if (dk->dk_kind == DICT_KEYS_UNICODE && PyUnicode_CheckExact(key)) { Py_ssize_t ix = unicodekeys_lookup_unicode_threadsafe(dk, key, hash); if (ix == DKIX_EMPTY) {

1 0

gh-144280: Add missing predicate symbol to case-switch (GH-144298)
by Fidget-Spinner Jan. 30, 2026

Jan. 30, 2026

https://github.com/python/cpython/commit/a7048327ed7c6bb83c8c41d50f6d8c5470… commit: a7048327ed7c6bb83c8c41d50f6d8c5470b6ad71 branch: main author: reiden <65756407+reidenong(a)users.noreply.github.com> committer: Fidget-Spinner <kenjin4096(a)gmail.com> date: 2026-01-30T16:43:27Z summary: gh-144280: Add missing predicate symbol to case-switch (GH-144298) files: A Misc/NEWS.d/next/Core_and_Builtins/2026-01-30-15-54-50.gh-issue-144280.kgiP5R.rst M Python/optimizer_symbols.c diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-01-30-15-54-50.gh-issue-144280.kgiP5R.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-01-30-15-54-50.gh-issue-144280.kgiP5R.rst new file mode 100644 index 00000000000000..d6a4203189063a --- /dev/null +++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-01-30-15-54-50.gh-issue-144280.kgiP5R.rst @@ -0,0 +1 @@ +Fix a bug in JIT where the predicate symbol had no truthiness diff --git a/Python/optimizer_symbols.c b/Python/optimizer_symbols.c index ff94807c6db1c5..d79c273a099e8f 100644 --- a/Python/optimizer_symbols.c +++ b/Python/optimizer_symbols.c @@ -113,6 +113,9 @@ _PyUOpSymPrint(JitOptRef ref) case JIT_SYM_COMPACT_INT: printf("<compact_int at %p>", (void *)sym); break; + case JIT_SYM_PREDICATE_TAG: + printf("<predicate at %p>", (void *)sym); + break; case JIT_SYM_DESCR_TAG: { PyTypeObject *descr_type = _PyType_LookupByVersion(sym->descr.type_version); if (descr_type) { @@ -692,6 +695,7 @@ _Py_uop_sym_truthiness(JitOptContext *ctx, JitOptRef ref) case JIT_SYM_NON_NULL_TAG: case JIT_SYM_UNKNOWN_TAG: case JIT_SYM_COMPACT_INT: + case JIT_SYM_PREDICATE_TAG: case JIT_SYM_DESCR_TAG: return -1; case JIT_SYM_KNOWN_CLASS_TAG: @@ -1614,6 +1618,26 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored)) _Py_uop_sym_apply_predicate_narrowing(ctx, ref, true); TEST_PREDICATE(!_Py_uop_sym_is_const(ctx, subject), "predicate narrowing incorrectly narrowed subject (inverted/true)"); + subject = _Py_uop_sym_new_unknown(ctx); + value = _Py_uop_sym_new_const(ctx, one_obj); + ref = _Py_uop_sym_new_predicate(ctx, subject, value, JIT_PRED_IS); + if (PyJitRef_IsNull(subject) || PyJitRef_IsNull(value) || PyJitRef_IsNull(ref)) { + goto fail; + } + TEST_PREDICATE(_Py_uop_sym_matches_type(ref, &PyBool_Type), "predicate is not boolean"); + TEST_PREDICATE(_Py_uop_sym_truthiness(ctx, ref) == -1, "predicate is not unknown"); + TEST_PREDICATE(_Py_uop_sym_is_const(ctx, ref) == false, "predicate is constant"); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, ref) == NULL, "predicate is not NULL"); + TEST_PREDICATE(_Py_uop_sym_is_const(ctx, value) == true, "value is not constant"); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, value) == one_obj, "value is not 1"); + _Py_uop_sym_set_const(ctx, ref, Py_False); + TEST_PREDICATE(_Py_uop_sym_matches_type(ref, &PyBool_Type), "predicate is not boolean"); + TEST_PREDICATE(_Py_uop_sym_truthiness(ctx, ref) == 0, "predicate is not False"); + TEST_PREDICATE(_Py_uop_sym_is_const(ctx, ref) == true, "predicate is not constant"); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, ref) == Py_False, "predicate is not False"); + TEST_PREDICATE(_Py_uop_sym_is_const(ctx, value) == true, "value is not constant"); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, value) == one_obj, "value is not 1"); + val_big = PyNumber_Lshift(_PyLong_GetOne(), PyLong_FromLong(66)); if (val_big == NULL) { goto fail;

1 0

gh-144295: Fix data race in dict method lookup and global load (gh-144312)
by colesbury Jan. 30, 2026

Jan. 30, 2026

https://github.com/python/cpython/commit/e666a01ef42939f77f4c22ca47a610df5e… commit: e666a01ef42939f77f4c22ca47a610df5ef8b7ab branch: main author: Sam Gross <colesbury(a)gmail.com> committer: colesbury <colesbury(a)gmail.com> date: 2026-01-30T11:14:10-05:00 summary: gh-144295: Fix data race in dict method lookup and global load (gh-144312) In `_PyDict_GetMethodStackRef`, only use the fast-path unicode lookup when the dict is owned by the current thread or already marked as shared. This prevents a race between the lookup and concurrent dict resizes, which may free the PyDictKeysObject (i.e., it ensures that the resize uses QSBR). Address a similar issue in `_Py_dict_lookup_threadsafe_stackref` by calling `ensure_shared_on_read()`. files: M Lib/test/test_free_threading/test_dict.py M Objects/dictobject.c diff --git a/Lib/test/test_free_threading/test_dict.py b/Lib/test/test_free_threading/test_dict.py index 5d5d4e226caa40..1ffd924e9f477a 100644 --- a/Lib/test/test_free_threading/test_dict.py +++ b/Lib/test/test_free_threading/test_dict.py @@ -245,5 +245,27 @@ def reader(): with threading_helper.start_threads([t1, t2]): pass + def test_racing_dict_update_and_method_lookup(self): + # gh-144295: test race between dict modifications and method lookups. + # Uses BytesIO because the race requires a type without Py_TPFLAGS_INLINE_VALUES + # for the _PyDict_GetMethodStackRef code path. + import io + obj = io.BytesIO() + + def writer(): + for _ in range(10000): + obj.x = 1 + del obj.x + + def reader(): + for _ in range(10000): + obj.getvalue() + + t1 = Thread(target=writer) + t2 = Thread(target=reader) + + with threading_helper.start_threads([t1, t2]): + pass + if __name__ == "__main__": unittest.main() diff --git a/Objects/dictobject.c b/Objects/dictobject.c index aea9ea84202b07..c1584be3f0ed4a 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -1615,7 +1615,9 @@ lookup_threadsafe_unicode(PyDictKeysObject *dk, PyObject *key, Py_hash_t hash, _ Py_ssize_t _Py_dict_lookup_threadsafe_stackref(PyDictObject *mp, PyObject *key, Py_hash_t hash, _PyStackRef *value_addr) { - PyDictKeysObject *dk = _Py_atomic_load_ptr(&mp->ma_keys); + ensure_shared_on_read(mp); + + PyDictKeysObject *dk = _Py_atomic_load_ptr_acquire(&mp->ma_keys); if (dk->dk_kind == DICT_KEYS_UNICODE && PyUnicode_CheckExact(key)) { Py_ssize_t ix = lookup_threadsafe_unicode(dk, key, hash, value_addr); if (ix != DKIX_KEY_CHANGED) { @@ -1669,19 +1671,27 @@ _PyDict_GetMethodStackRef(PyDictObject *mp, PyObject *key, _PyStackRef *method) Py_hash_t hash = hash_unicode_key(key); #ifdef Py_GIL_DISABLED - PyDictKeysObject *dk = _Py_atomic_load_ptr_acquire(&mp->ma_keys); - if (dk->dk_kind == DICT_KEYS_UNICODE) { - _PyStackRef ref; - Py_ssize_t ix = lookup_threadsafe_unicode(dk, key, hash, &ref); - if (ix >= 0) { - assert(!PyStackRef_IsNull(ref)); - PyStackRef_XSETREF(*method, ref); - return 1; - } - else if (ix == DKIX_EMPTY) { - return 0; + // NOTE: We can only do the fast-path lookup if we are on the owning + // thread or if the dict is already marked as shared so that the load + // of ma_keys is safe without a lock. We cannot call ensure_shared_on_read() + // in this code path without incref'ing the dict because the dict is a + // borrowed reference protected by QSBR, and acquiring the lock could lead + // to a quiescent state (allowing the dict to be freed). + if (_Py_IsOwnedByCurrentThread((PyObject *)mp) || IS_DICT_SHARED(mp)) { + PyDictKeysObject *dk = _Py_atomic_load_ptr_acquire(&mp->ma_keys); + if (dk->dk_kind == DICT_KEYS_UNICODE) { + _PyStackRef ref; + Py_ssize_t ix = lookup_threadsafe_unicode(dk, key, hash, &ref); + if (ix >= 0) { + assert(!PyStackRef_IsNull(ref)); + PyStackRef_XSETREF(*method, ref); + return 1; + } + else if (ix == DKIX_EMPTY) { + return 0; + } + assert(ix == DKIX_KEY_CHANGED); } - assert(ix == DKIX_KEY_CHANGED); } #endif

1 0

gh-144145: Track nullness of properties in the Tier 2 JIT optimizer (GH-144122)
by Fidget-Spinner Jan. 30, 2026

Jan. 30, 2026

https://github.com/python/cpython/commit/1dc12b2883c89045469f3c401157d4df13… commit: 1dc12b2883c89045469f3c401157d4df13f535f0 branch: main author: Hai Zhu <haiizhu(a)outlook.com> committer: Fidget-Spinner <kenjin4096(a)gmail.com> date: 2026-01-30T15:25:19Z summary: gh-144145: Track nullness of properties in the Tier 2 JIT optimizer (GH-144122) files: A Misc/NEWS.d/next/Core_and_Builtins/2026-01-30-09-47-29.gh-issue-144145.mxJyUj.rst M Include/internal/pycore_optimizer.h M Include/internal/pycore_optimizer_types.h M Include/internal/pycore_uop_ids.h M Include/internal/pycore_uop_metadata.h M Python/bytecodes.c M Python/executor_cases.c.h M Python/optimizer_analysis.c M Python/optimizer_bytecodes.c M Python/optimizer_cases.c.h M Python/optimizer_symbols.c diff --git a/Include/internal/pycore_optimizer.h b/Include/internal/pycore_optimizer.h index 2ee518fb82f301..89e08e86ed6982 100644 --- a/Include/internal/pycore_optimizer.h +++ b/Include/internal/pycore_optimizer.h @@ -37,10 +37,15 @@ typedef struct _JitOptContext { // Arena for the symbolic types. ty_arena t_arena; + // Arena for the descriptor mappings. + descr_arena d_arena; + JitOptRef *n_consumed; JitOptRef *limit; JitOptRef locals_and_stack[MAX_ABSTRACT_INTERP_SIZE]; _PyJitUopBuffer out_buffer; + // Index of the last escaped uop in out_buffer. + int last_escape_index; } JitOptContext; @@ -295,6 +300,9 @@ extern JitOptRef _Py_uop_sym_new_truthiness(JitOptContext *ctx, JitOptRef value, extern bool _Py_uop_sym_is_compact_int(JitOptRef sym); extern JitOptRef _Py_uop_sym_new_compact_int(JitOptContext *ctx); extern void _Py_uop_sym_set_compact_int(JitOptContext *ctx, JitOptRef sym); +extern JitOptRef _Py_uop_sym_new_descr_object(JitOptContext *ctx, unsigned int type_version); +extern JitOptRef _Py_uop_sym_get_attr(JitOptContext *ctx, JitOptRef ref, uint16_t slot_index); +extern JitOptRef _Py_uop_sym_set_attr(JitOptContext *ctx, JitOptRef ref, uint16_t slot_index, JitOptRef value); extern JitOptRef _Py_uop_sym_new_predicate(JitOptContext *ctx, JitOptRef lhs_ref, JitOptRef rhs_ref, JitOptPredicateKind kind); extern void _Py_uop_sym_apply_predicate_narrowing(JitOptContext *ctx, JitOptRef sym, bool branch_is_true); diff --git a/Include/internal/pycore_optimizer_types.h b/Include/internal/pycore_optimizer_types.h index b4b93e8353812a..1996ce10735736 100644 --- a/Include/internal/pycore_optimizer_types.h +++ b/Include/internal/pycore_optimizer_types.h @@ -16,6 +16,10 @@ extern "C" { #define TY_ARENA_SIZE (UOP_MAX_TRACE_LENGTH * 5) +// Maximum descriptor mappings per object tracked symbolically +#define MAX_SYMBOLIC_DESCR_SIZE 16 +#define DESCR_ARENA_SIZE (MAX_SYMBOLIC_DESCR_SIZE * 100) + // Need extras for root frame and for overflow frame (see TRACE_STACK_PUSH()) #define MAX_ABSTRACT_FRAME_DEPTH (16) @@ -41,6 +45,7 @@ typedef enum _JitSymType { JIT_SYM_TRUTHINESS_TAG = 9, JIT_SYM_COMPACT_INT = 10, JIT_SYM_PREDICATE_TAG = 11, + JIT_SYM_DESCR_TAG = 12, } JitSymType; typedef struct _jit_opt_known_class { @@ -91,6 +96,31 @@ typedef struct { uint8_t tag; } JitOptCompactInt; +/* +Mapping from slot index or attribute offset to its symbolic value. +SAFETY: +This structure is used for both STORE_ATTR_SLOT and STORE_ATTR_INSTANCE_VALUE. +These two never appear on the same object type because: +__slots__ classes don't have Py_TPFLAGS_INLINE_VALUES +Therefore, there is no index collision between slot offsets and inline value offsets. +Note: +STORE_ATTR_WITH_HINT is NOT currently tracked. +If we want to track it in the future, we need to be careful about +potential index collisions with STORE_ATTR_INSTANCE_VALUE. +*/ +typedef struct { + uint16_t slot_index; + uint16_t symbol; +} JitOptDescrMapping; + +typedef struct _jit_opt_descr { + uint8_t tag; + uint8_t num_descrs; + uint16_t last_modified_index; // Index in out_buffer when this object was last modified + uint32_t type_version; + JitOptDescrMapping *descrs; +} JitOptDescrObject; + typedef union _jit_opt_symbol { uint8_t tag; JitOptKnownClass cls; @@ -99,6 +129,7 @@ typedef union _jit_opt_symbol { JitOptTuple tuple; JitOptTruthiness truthiness; JitOptCompactInt compact; + JitOptDescrObject descr; JitOptPredicate predicate; } JitOptSymbol; @@ -128,6 +159,11 @@ typedef struct ty_arena { JitOptSymbol arena[TY_ARENA_SIZE]; } ty_arena; +typedef struct descr_arena { + int descr_curr_number; + int descr_max_number; + JitOptDescrMapping arena[DESCR_ARENA_SIZE]; +} descr_arena; #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 8712d1afc7570b..a1abe168605cd5 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -340,905 +340,915 @@ extern "C" { #define _START_EXECUTOR 548 #define _STORE_ATTR 549 #define _STORE_ATTR_INSTANCE_VALUE 550 -#define _STORE_ATTR_SLOT 551 -#define _STORE_ATTR_WITH_HINT 552 +#define _STORE_ATTR_INSTANCE_VALUE_NULL 551 +#define _STORE_ATTR_SLOT 552 +#define _STORE_ATTR_SLOT_NULL 553 +#define _STORE_ATTR_WITH_HINT 554 #define _STORE_DEREF STORE_DEREF #define _STORE_GLOBAL STORE_GLOBAL #define _STORE_NAME STORE_NAME -#define _STORE_SLICE 553 -#define _STORE_SUBSCR 554 -#define _STORE_SUBSCR_DICT 555 -#define _STORE_SUBSCR_LIST_INT 556 -#define _SWAP 557 -#define _SWAP_2 558 -#define _SWAP_3 559 -#define _SWAP_FAST 560 -#define _SWAP_FAST_0 561 -#define _SWAP_FAST_1 562 -#define _SWAP_FAST_2 563 -#define _SWAP_FAST_3 564 -#define _SWAP_FAST_4 565 -#define _SWAP_FAST_5 566 -#define _SWAP_FAST_6 567 -#define _SWAP_FAST_7 568 -#define _TIER2_RESUME_CHECK 569 -#define _TO_BOOL 570 +#define _STORE_SLICE 555 +#define _STORE_SUBSCR 556 +#define _STORE_SUBSCR_DICT 557 +#define _STORE_SUBSCR_LIST_INT 558 +#define _SWAP 559 +#define _SWAP_2 560 +#define _SWAP_3 561 +#define _SWAP_FAST 562 +#define _SWAP_FAST_0 563 +#define _SWAP_FAST_1 564 +#define _SWAP_FAST_2 565 +#define _SWAP_FAST_3 566 +#define _SWAP_FAST_4 567 +#define _SWAP_FAST_5 568 +#define _SWAP_FAST_6 569 +#define _SWAP_FAST_7 570 +#define _TIER2_RESUME_CHECK 571 +#define _TO_BOOL 572 #define _TO_BOOL_BOOL TO_BOOL_BOOL -#define _TO_BOOL_INT 571 -#define _TO_BOOL_LIST 572 +#define _TO_BOOL_INT 573 +#define _TO_BOOL_LIST 574 #define _TO_BOOL_NONE TO_BOOL_NONE -#define _TO_BOOL_STR 573 +#define _TO_BOOL_STR 575 #define _TRACE_RECORD TRACE_RECORD -#define _UNARY_INVERT 574 -#define _UNARY_NEGATIVE 575 +#define _UNARY_INVERT 576 +#define _UNARY_NEGATIVE 577 #define _UNARY_NOT UNARY_NOT #define _UNPACK_EX UNPACK_EX -#define _UNPACK_SEQUENCE 576 -#define _UNPACK_SEQUENCE_LIST 577 -#define _UNPACK_SEQUENCE_TUPLE 578 -#define _UNPACK_SEQUENCE_TWO_TUPLE 579 +#define _UNPACK_SEQUENCE 578 +#define _UNPACK_SEQUENCE_LIST 579 +#define _UNPACK_SEQUENCE_TUPLE 580 +#define _UNPACK_SEQUENCE_TWO_TUPLE 581 #define _WITH_EXCEPT_START WITH_EXCEPT_START #define _YIELD_VALUE YIELD_VALUE -#define MAX_UOP_ID 579 -#define _BINARY_OP_r23 580 -#define _BINARY_OP_ADD_FLOAT_r03 581 -#define _BINARY_OP_ADD_FLOAT_r13 582 -#define _BINARY_OP_ADD_FLOAT_r23 583 -#define _BINARY_OP_ADD_INT_r03 584 -#define _BINARY_OP_ADD_INT_r13 585 -#define _BINARY_OP_ADD_INT_r23 586 -#define _BINARY_OP_ADD_UNICODE_r03 587 -#define _BINARY_OP_ADD_UNICODE_r13 588 -#define _BINARY_OP_ADD_UNICODE_r23 589 -#define _BINARY_OP_EXTEND_r23 590 -#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 591 -#define _BINARY_OP_MULTIPLY_FLOAT_r03 592 -#define _BINARY_OP_MULTIPLY_FLOAT_r13 593 -#define _BINARY_OP_MULTIPLY_FLOAT_r23 594 -#define _BINARY_OP_MULTIPLY_INT_r03 595 -#define _BINARY_OP_MULTIPLY_INT_r13 596 -#define _BINARY_OP_MULTIPLY_INT_r23 597 -#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 598 -#define _BINARY_OP_SUBSCR_DICT_r23 599 -#define _BINARY_OP_SUBSCR_INIT_CALL_r01 600 -#define _BINARY_OP_SUBSCR_INIT_CALL_r11 601 -#define _BINARY_OP_SUBSCR_INIT_CALL_r21 602 -#define _BINARY_OP_SUBSCR_INIT_CALL_r31 603 -#define _BINARY_OP_SUBSCR_LIST_INT_r23 604 -#define _BINARY_OP_SUBSCR_LIST_SLICE_r21 605 -#define _BINARY_OP_SUBSCR_STR_INT_r23 606 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 607 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 608 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 609 -#define _BINARY_OP_SUBSCR_USTR_INT_r23 610 -#define _BINARY_OP_SUBTRACT_FLOAT_r03 611 -#define _BINARY_OP_SUBTRACT_FLOAT_r13 612 -#define _BINARY_OP_SUBTRACT_FLOAT_r23 613 -#define _BINARY_OP_SUBTRACT_INT_r03 614 -#define _BINARY_OP_SUBTRACT_INT_r13 615 -#define _BINARY_OP_SUBTRACT_INT_r23 616 -#define _BINARY_SLICE_r31 617 -#define _BUILD_INTERPOLATION_r01 618 -#define _BUILD_LIST_r01 619 -#define _BUILD_MAP_r01 620 -#define _BUILD_SET_r01 621 -#define _BUILD_SLICE_r01 622 -#define _BUILD_STRING_r01 623 -#define _BUILD_TEMPLATE_r21 624 -#define _BUILD_TUPLE_r01 625 -#define _CALL_BUILTIN_CLASS_r01 626 -#define _CALL_BUILTIN_FAST_r01 627 -#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r01 628 -#define _CALL_BUILTIN_O_r03 629 -#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 630 -#define _CALL_INTRINSIC_1_r11 631 -#define _CALL_INTRINSIC_2_r21 632 -#define _CALL_ISINSTANCE_r31 633 -#define _CALL_KW_NON_PY_r11 634 -#define _CALL_LEN_r33 635 -#define _CALL_LIST_APPEND_r03 636 -#define _CALL_LIST_APPEND_r13 637 -#define _CALL_LIST_APPEND_r23 638 -#define _CALL_LIST_APPEND_r33 639 -#define _CALL_METHOD_DESCRIPTOR_FAST_r01 640 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01 641 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_r01 642 -#define _CALL_METHOD_DESCRIPTOR_O_r03 643 -#define _CALL_NON_PY_GENERAL_r01 644 -#define _CALL_STR_1_r32 645 -#define _CALL_TUPLE_1_r32 646 -#define _CALL_TYPE_1_r02 647 -#define _CALL_TYPE_1_r12 648 -#define _CALL_TYPE_1_r22 649 -#define _CALL_TYPE_1_r32 650 -#define _CHECK_AND_ALLOCATE_OBJECT_r00 651 -#define _CHECK_ATTR_CLASS_r01 652 -#define _CHECK_ATTR_CLASS_r11 653 -#define _CHECK_ATTR_CLASS_r22 654 -#define _CHECK_ATTR_CLASS_r33 655 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 656 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 657 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 658 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 659 -#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 660 -#define _CHECK_EG_MATCH_r22 661 -#define _CHECK_EXC_MATCH_r22 662 -#define _CHECK_FUNCTION_EXACT_ARGS_r00 663 -#define _CHECK_FUNCTION_VERSION_r00 664 -#define _CHECK_FUNCTION_VERSION_INLINE_r00 665 -#define _CHECK_FUNCTION_VERSION_INLINE_r11 666 -#define _CHECK_FUNCTION_VERSION_INLINE_r22 667 -#define _CHECK_FUNCTION_VERSION_INLINE_r33 668 -#define _CHECK_FUNCTION_VERSION_KW_r11 669 -#define _CHECK_IS_NOT_PY_CALLABLE_r00 670 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 671 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 672 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 673 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 674 -#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 675 -#define _CHECK_IS_PY_CALLABLE_EX_r03 676 -#define _CHECK_IS_PY_CALLABLE_EX_r13 677 -#define _CHECK_IS_PY_CALLABLE_EX_r23 678 -#define _CHECK_IS_PY_CALLABLE_EX_r33 679 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 680 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 681 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 682 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 683 -#define _CHECK_METHOD_VERSION_r00 684 -#define _CHECK_METHOD_VERSION_KW_r11 685 -#define _CHECK_PEP_523_r00 686 -#define _CHECK_PEP_523_r11 687 -#define _CHECK_PEP_523_r22 688 -#define _CHECK_PEP_523_r33 689 -#define _CHECK_PERIODIC_r00 690 -#define _CHECK_PERIODIC_AT_END_r00 691 -#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 692 -#define _CHECK_RECURSION_REMAINING_r00 693 -#define _CHECK_RECURSION_REMAINING_r11 694 -#define _CHECK_RECURSION_REMAINING_r22 695 -#define _CHECK_RECURSION_REMAINING_r33 696 -#define _CHECK_STACK_SPACE_r00 697 -#define _CHECK_STACK_SPACE_OPERAND_r00 698 -#define _CHECK_STACK_SPACE_OPERAND_r11 699 -#define _CHECK_STACK_SPACE_OPERAND_r22 700 -#define _CHECK_STACK_SPACE_OPERAND_r33 701 -#define _CHECK_VALIDITY_r00 702 -#define _CHECK_VALIDITY_r11 703 -#define _CHECK_VALIDITY_r22 704 -#define _CHECK_VALIDITY_r33 705 -#define _COLD_DYNAMIC_EXIT_r00 706 -#define _COLD_EXIT_r00 707 -#define _COMPARE_OP_r21 708 -#define _COMPARE_OP_FLOAT_r03 709 -#define _COMPARE_OP_FLOAT_r13 710 -#define _COMPARE_OP_FLOAT_r23 711 -#define _COMPARE_OP_INT_r23 712 -#define _COMPARE_OP_STR_r23 713 -#define _CONTAINS_OP_r23 714 -#define _CONTAINS_OP_DICT_r23 715 -#define _CONTAINS_OP_SET_r23 716 -#define _CONVERT_VALUE_r11 717 -#define _COPY_r01 718 -#define _COPY_1_r02 719 -#define _COPY_1_r12 720 -#define _COPY_1_r23 721 -#define _COPY_2_r03 722 -#define _COPY_2_r13 723 -#define _COPY_2_r23 724 -#define _COPY_3_r03 725 -#define _COPY_3_r13 726 -#define _COPY_3_r23 727 -#define _COPY_3_r33 728 -#define _COPY_FREE_VARS_r00 729 -#define _COPY_FREE_VARS_r11 730 -#define _COPY_FREE_VARS_r22 731 -#define _COPY_FREE_VARS_r33 732 -#define _CREATE_INIT_FRAME_r01 733 -#define _DELETE_ATTR_r10 734 -#define _DELETE_DEREF_r00 735 -#define _DELETE_FAST_r00 736 -#define _DELETE_GLOBAL_r00 737 -#define _DELETE_NAME_r00 738 -#define _DELETE_SUBSCR_r20 739 -#define _DEOPT_r00 740 -#define _DEOPT_r10 741 -#define _DEOPT_r20 742 -#define _DEOPT_r30 743 -#define _DICT_MERGE_r10 744 -#define _DICT_UPDATE_r10 745 -#define _DO_CALL_r01 746 -#define _DO_CALL_FUNCTION_EX_r31 747 -#define _DO_CALL_KW_r11 748 -#define _DYNAMIC_EXIT_r00 749 -#define _DYNAMIC_EXIT_r10 750 -#define _DYNAMIC_EXIT_r20 751 -#define _DYNAMIC_EXIT_r30 752 -#define _END_FOR_r10 753 -#define _END_SEND_r21 754 -#define _ERROR_POP_N_r00 755 -#define _EXIT_INIT_CHECK_r10 756 -#define _EXIT_TRACE_r00 757 -#define _EXIT_TRACE_r10 758 -#define _EXIT_TRACE_r20 759 -#define _EXIT_TRACE_r30 760 -#define _EXPAND_METHOD_r00 761 -#define _EXPAND_METHOD_KW_r11 762 -#define _FATAL_ERROR_r00 763 -#define _FATAL_ERROR_r11 764 -#define _FATAL_ERROR_r22 765 -#define _FATAL_ERROR_r33 766 -#define _FORMAT_SIMPLE_r11 767 -#define _FORMAT_WITH_SPEC_r21 768 -#define _FOR_ITER_r23 769 -#define _FOR_ITER_GEN_FRAME_r03 770 -#define _FOR_ITER_GEN_FRAME_r13 771 -#define _FOR_ITER_GEN_FRAME_r23 772 -#define _FOR_ITER_TIER_TWO_r23 773 -#define _GET_AITER_r11 774 -#define _GET_ANEXT_r12 775 -#define _GET_AWAITABLE_r11 776 -#define _GET_ITER_r12 777 -#define _GET_LEN_r12 778 -#define _GET_YIELD_FROM_ITER_r11 779 -#define _GUARD_BINARY_OP_EXTEND_r22 780 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 781 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 782 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 783 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 784 -#define _GUARD_BIT_IS_SET_POP_r00 785 -#define _GUARD_BIT_IS_SET_POP_r10 786 -#define _GUARD_BIT_IS_SET_POP_r21 787 -#define _GUARD_BIT_IS_SET_POP_r32 788 -#define _GUARD_BIT_IS_SET_POP_4_r00 789 -#define _GUARD_BIT_IS_SET_POP_4_r10 790 -#define _GUARD_BIT_IS_SET_POP_4_r21 791 -#define _GUARD_BIT_IS_SET_POP_4_r32 792 -#define _GUARD_BIT_IS_SET_POP_5_r00 793 -#define _GUARD_BIT_IS_SET_POP_5_r10 794 -#define _GUARD_BIT_IS_SET_POP_5_r21 795 -#define _GUARD_BIT_IS_SET_POP_5_r32 796 -#define _GUARD_BIT_IS_SET_POP_6_r00 797 -#define _GUARD_BIT_IS_SET_POP_6_r10 798 -#define _GUARD_BIT_IS_SET_POP_6_r21 799 -#define _GUARD_BIT_IS_SET_POP_6_r32 800 -#define _GUARD_BIT_IS_SET_POP_7_r00 801 -#define _GUARD_BIT_IS_SET_POP_7_r10 802 -#define _GUARD_BIT_IS_SET_POP_7_r21 803 -#define _GUARD_BIT_IS_SET_POP_7_r32 804 -#define _GUARD_BIT_IS_UNSET_POP_r00 805 -#define _GUARD_BIT_IS_UNSET_POP_r10 806 -#define _GUARD_BIT_IS_UNSET_POP_r21 807 -#define _GUARD_BIT_IS_UNSET_POP_r32 808 -#define _GUARD_BIT_IS_UNSET_POP_4_r00 809 -#define _GUARD_BIT_IS_UNSET_POP_4_r10 810 -#define _GUARD_BIT_IS_UNSET_POP_4_r21 811 -#define _GUARD_BIT_IS_UNSET_POP_4_r32 812 -#define _GUARD_BIT_IS_UNSET_POP_5_r00 813 -#define _GUARD_BIT_IS_UNSET_POP_5_r10 814 -#define _GUARD_BIT_IS_UNSET_POP_5_r21 815 -#define _GUARD_BIT_IS_UNSET_POP_5_r32 816 -#define _GUARD_BIT_IS_UNSET_POP_6_r00 817 -#define _GUARD_BIT_IS_UNSET_POP_6_r10 818 -#define _GUARD_BIT_IS_UNSET_POP_6_r21 819 -#define _GUARD_BIT_IS_UNSET_POP_6_r32 820 -#define _GUARD_BIT_IS_UNSET_POP_7_r00 821 -#define _GUARD_BIT_IS_UNSET_POP_7_r10 822 -#define _GUARD_BIT_IS_UNSET_POP_7_r21 823 -#define _GUARD_BIT_IS_UNSET_POP_7_r32 824 -#define _GUARD_CALLABLE_ISINSTANCE_r03 825 -#define _GUARD_CALLABLE_ISINSTANCE_r13 826 -#define _GUARD_CALLABLE_ISINSTANCE_r23 827 -#define _GUARD_CALLABLE_ISINSTANCE_r33 828 -#define _GUARD_CALLABLE_LEN_r03 829 -#define _GUARD_CALLABLE_LEN_r13 830 -#define _GUARD_CALLABLE_LEN_r23 831 -#define _GUARD_CALLABLE_LEN_r33 832 -#define _GUARD_CALLABLE_LIST_APPEND_r03 833 -#define _GUARD_CALLABLE_LIST_APPEND_r13 834 -#define _GUARD_CALLABLE_LIST_APPEND_r23 835 -#define _GUARD_CALLABLE_LIST_APPEND_r33 836 -#define _GUARD_CALLABLE_STR_1_r03 837 -#define _GUARD_CALLABLE_STR_1_r13 838 -#define _GUARD_CALLABLE_STR_1_r23 839 -#define _GUARD_CALLABLE_STR_1_r33 840 -#define _GUARD_CALLABLE_TUPLE_1_r03 841 -#define _GUARD_CALLABLE_TUPLE_1_r13 842 -#define _GUARD_CALLABLE_TUPLE_1_r23 843 -#define _GUARD_CALLABLE_TUPLE_1_r33 844 -#define _GUARD_CALLABLE_TYPE_1_r03 845 -#define _GUARD_CALLABLE_TYPE_1_r13 846 -#define _GUARD_CALLABLE_TYPE_1_r23 847 -#define _GUARD_CALLABLE_TYPE_1_r33 848 -#define _GUARD_DORV_NO_DICT_r01 849 -#define _GUARD_DORV_NO_DICT_r11 850 -#define _GUARD_DORV_NO_DICT_r22 851 -#define _GUARD_DORV_NO_DICT_r33 852 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 853 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 854 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 855 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 856 -#define _GUARD_GLOBALS_VERSION_r00 857 -#define _GUARD_GLOBALS_VERSION_r11 858 -#define _GUARD_GLOBALS_VERSION_r22 859 -#define _GUARD_GLOBALS_VERSION_r33 860 -#define _GUARD_IP_RETURN_GENERATOR_r00 861 -#define _GUARD_IP_RETURN_GENERATOR_r11 862 -#define _GUARD_IP_RETURN_GENERATOR_r22 863 -#define _GUARD_IP_RETURN_GENERATOR_r33 864 -#define _GUARD_IP_RETURN_VALUE_r00 865 -#define _GUARD_IP_RETURN_VALUE_r11 866 -#define _GUARD_IP_RETURN_VALUE_r22 867 -#define _GUARD_IP_RETURN_VALUE_r33 868 -#define _GUARD_IP_YIELD_VALUE_r00 869 -#define _GUARD_IP_YIELD_VALUE_r11 870 -#define _GUARD_IP_YIELD_VALUE_r22 871 -#define _GUARD_IP_YIELD_VALUE_r33 872 -#define _GUARD_IP__PUSH_FRAME_r00 873 -#define _GUARD_IP__PUSH_FRAME_r11 874 -#define _GUARD_IP__PUSH_FRAME_r22 875 -#define _GUARD_IP__PUSH_FRAME_r33 876 -#define _GUARD_IS_FALSE_POP_r00 877 -#define _GUARD_IS_FALSE_POP_r10 878 -#define _GUARD_IS_FALSE_POP_r21 879 -#define _GUARD_IS_FALSE_POP_r32 880 -#define _GUARD_IS_NONE_POP_r00 881 -#define _GUARD_IS_NONE_POP_r10 882 -#define _GUARD_IS_NONE_POP_r21 883 -#define _GUARD_IS_NONE_POP_r32 884 -#define _GUARD_IS_NOT_NONE_POP_r10 885 -#define _GUARD_IS_TRUE_POP_r00 886 -#define _GUARD_IS_TRUE_POP_r10 887 -#define _GUARD_IS_TRUE_POP_r21 888 -#define _GUARD_IS_TRUE_POP_r32 889 -#define _GUARD_KEYS_VERSION_r01 890 -#define _GUARD_KEYS_VERSION_r11 891 -#define _GUARD_KEYS_VERSION_r22 892 -#define _GUARD_KEYS_VERSION_r33 893 -#define _GUARD_NOS_COMPACT_ASCII_r02 894 -#define _GUARD_NOS_COMPACT_ASCII_r12 895 -#define _GUARD_NOS_COMPACT_ASCII_r22 896 -#define _GUARD_NOS_COMPACT_ASCII_r33 897 -#define _GUARD_NOS_DICT_r02 898 -#define _GUARD_NOS_DICT_r12 899 -#define _GUARD_NOS_DICT_r22 900 -#define _GUARD_NOS_DICT_r33 901 -#define _GUARD_NOS_FLOAT_r02 902 -#define _GUARD_NOS_FLOAT_r12 903 -#define _GUARD_NOS_FLOAT_r22 904 -#define _GUARD_NOS_FLOAT_r33 905 -#define _GUARD_NOS_INT_r02 906 -#define _GUARD_NOS_INT_r12 907 -#define _GUARD_NOS_INT_r22 908 -#define _GUARD_NOS_INT_r33 909 -#define _GUARD_NOS_LIST_r02 910 -#define _GUARD_NOS_LIST_r12 911 -#define _GUARD_NOS_LIST_r22 912 -#define _GUARD_NOS_LIST_r33 913 -#define _GUARD_NOS_NOT_NULL_r02 914 -#define _GUARD_NOS_NOT_NULL_r12 915 -#define _GUARD_NOS_NOT_NULL_r22 916 -#define _GUARD_NOS_NOT_NULL_r33 917 -#define _GUARD_NOS_NULL_r02 918 -#define _GUARD_NOS_NULL_r12 919 -#define _GUARD_NOS_NULL_r22 920 -#define _GUARD_NOS_NULL_r33 921 -#define _GUARD_NOS_OVERFLOWED_r02 922 -#define _GUARD_NOS_OVERFLOWED_r12 923 -#define _GUARD_NOS_OVERFLOWED_r22 924 -#define _GUARD_NOS_OVERFLOWED_r33 925 -#define _GUARD_NOS_TUPLE_r02 926 -#define _GUARD_NOS_TUPLE_r12 927 -#define _GUARD_NOS_TUPLE_r22 928 -#define _GUARD_NOS_TUPLE_r33 929 -#define _GUARD_NOS_UNICODE_r02 930 -#define _GUARD_NOS_UNICODE_r12 931 -#define _GUARD_NOS_UNICODE_r22 932 -#define _GUARD_NOS_UNICODE_r33 933 -#define _GUARD_NOT_EXHAUSTED_LIST_r02 934 -#define _GUARD_NOT_EXHAUSTED_LIST_r12 935 -#define _GUARD_NOT_EXHAUSTED_LIST_r22 936 -#define _GUARD_NOT_EXHAUSTED_LIST_r33 937 -#define _GUARD_NOT_EXHAUSTED_RANGE_r02 938 -#define _GUARD_NOT_EXHAUSTED_RANGE_r12 939 -#define _GUARD_NOT_EXHAUSTED_RANGE_r22 940 -#define _GUARD_NOT_EXHAUSTED_RANGE_r33 941 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 942 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 943 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 944 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 945 -#define _GUARD_THIRD_NULL_r03 946 -#define _GUARD_THIRD_NULL_r13 947 -#define _GUARD_THIRD_NULL_r23 948 -#define _GUARD_THIRD_NULL_r33 949 -#define _GUARD_TOS_ANY_SET_r01 950 -#define _GUARD_TOS_ANY_SET_r11 951 -#define _GUARD_TOS_ANY_SET_r22 952 -#define _GUARD_TOS_ANY_SET_r33 953 -#define _GUARD_TOS_DICT_r01 954 -#define _GUARD_TOS_DICT_r11 955 -#define _GUARD_TOS_DICT_r22 956 -#define _GUARD_TOS_DICT_r33 957 -#define _GUARD_TOS_FLOAT_r01 958 -#define _GUARD_TOS_FLOAT_r11 959 -#define _GUARD_TOS_FLOAT_r22 960 -#define _GUARD_TOS_FLOAT_r33 961 -#define _GUARD_TOS_INT_r01 962 -#define _GUARD_TOS_INT_r11 963 -#define _GUARD_TOS_INT_r22 964 -#define _GUARD_TOS_INT_r33 965 -#define _GUARD_TOS_LIST_r01 966 -#define _GUARD_TOS_LIST_r11 967 -#define _GUARD_TOS_LIST_r22 968 -#define _GUARD_TOS_LIST_r33 969 -#define _GUARD_TOS_OVERFLOWED_r01 970 -#define _GUARD_TOS_OVERFLOWED_r11 971 -#define _GUARD_TOS_OVERFLOWED_r22 972 -#define _GUARD_TOS_OVERFLOWED_r33 973 -#define _GUARD_TOS_SLICE_r01 974 -#define _GUARD_TOS_SLICE_r11 975 -#define _GUARD_TOS_SLICE_r22 976 -#define _GUARD_TOS_SLICE_r33 977 -#define _GUARD_TOS_TUPLE_r01 978 -#define _GUARD_TOS_TUPLE_r11 979 -#define _GUARD_TOS_TUPLE_r22 980 -#define _GUARD_TOS_TUPLE_r33 981 -#define _GUARD_TOS_UNICODE_r01 982 -#define _GUARD_TOS_UNICODE_r11 983 -#define _GUARD_TOS_UNICODE_r22 984 -#define _GUARD_TOS_UNICODE_r33 985 -#define _GUARD_TYPE_VERSION_r01 986 -#define _GUARD_TYPE_VERSION_r11 987 -#define _GUARD_TYPE_VERSION_r22 988 -#define _GUARD_TYPE_VERSION_r33 989 -#define _GUARD_TYPE_VERSION_AND_LOCK_r01 990 -#define _GUARD_TYPE_VERSION_AND_LOCK_r11 991 -#define _GUARD_TYPE_VERSION_AND_LOCK_r22 992 -#define _GUARD_TYPE_VERSION_AND_LOCK_r33 993 -#define _HANDLE_PENDING_AND_DEOPT_r00 994 -#define _HANDLE_PENDING_AND_DEOPT_r10 995 -#define _HANDLE_PENDING_AND_DEOPT_r20 996 -#define _HANDLE_PENDING_AND_DEOPT_r30 997 -#define _IMPORT_FROM_r12 998 -#define _IMPORT_NAME_r21 999 -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1000 -#define _INIT_CALL_PY_EXACT_ARGS_r01 1001 -#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1002 -#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1003 -#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1004 -#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1005 -#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1006 -#define _INSERT_1_LOAD_CONST_INLINE_r02 1007 -#define _INSERT_1_LOAD_CONST_INLINE_r12 1008 -#define _INSERT_1_LOAD_CONST_INLINE_r23 1009 -#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r02 1010 -#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r12 1011 -#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r23 1012 -#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r03 1013 -#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r13 1014 -#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r23 1015 -#define _INSERT_NULL_r10 1016 -#define _INSTRUMENTED_FOR_ITER_r23 1017 -#define _INSTRUMENTED_INSTRUCTION_r00 1018 -#define _INSTRUMENTED_JUMP_FORWARD_r00 1019 -#define _INSTRUMENTED_JUMP_FORWARD_r11 1020 -#define _INSTRUMENTED_JUMP_FORWARD_r22 1021 -#define _INSTRUMENTED_JUMP_FORWARD_r33 1022 -#define _INSTRUMENTED_LINE_r00 1023 -#define _INSTRUMENTED_NOT_TAKEN_r00 1024 -#define _INSTRUMENTED_NOT_TAKEN_r11 1025 -#define _INSTRUMENTED_NOT_TAKEN_r22 1026 -#define _INSTRUMENTED_NOT_TAKEN_r33 1027 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1028 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1029 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1030 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1031 -#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1032 -#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1033 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1034 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1035 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1036 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1037 -#define _IS_NONE_r11 1038 -#define _IS_OP_r03 1039 -#define _IS_OP_r13 1040 -#define _IS_OP_r23 1041 -#define _ITER_CHECK_LIST_r02 1042 -#define _ITER_CHECK_LIST_r12 1043 -#define _ITER_CHECK_LIST_r22 1044 -#define _ITER_CHECK_LIST_r33 1045 -#define _ITER_CHECK_RANGE_r02 1046 -#define _ITER_CHECK_RANGE_r12 1047 -#define _ITER_CHECK_RANGE_r22 1048 -#define _ITER_CHECK_RANGE_r33 1049 -#define _ITER_CHECK_TUPLE_r02 1050 -#define _ITER_CHECK_TUPLE_r12 1051 -#define _ITER_CHECK_TUPLE_r22 1052 -#define _ITER_CHECK_TUPLE_r33 1053 -#define _ITER_JUMP_LIST_r02 1054 -#define _ITER_JUMP_LIST_r12 1055 -#define _ITER_JUMP_LIST_r22 1056 -#define _ITER_JUMP_LIST_r33 1057 -#define _ITER_JUMP_RANGE_r02 1058 -#define _ITER_JUMP_RANGE_r12 1059 -#define _ITER_JUMP_RANGE_r22 1060 -#define _ITER_JUMP_RANGE_r33 1061 -#define _ITER_JUMP_TUPLE_r02 1062 -#define _ITER_JUMP_TUPLE_r12 1063 -#define _ITER_JUMP_TUPLE_r22 1064 -#define _ITER_JUMP_TUPLE_r33 1065 -#define _ITER_NEXT_LIST_r23 1066 -#define _ITER_NEXT_LIST_TIER_TWO_r23 1067 -#define _ITER_NEXT_RANGE_r03 1068 -#define _ITER_NEXT_RANGE_r13 1069 -#define _ITER_NEXT_RANGE_r23 1070 -#define _ITER_NEXT_TUPLE_r03 1071 -#define _ITER_NEXT_TUPLE_r13 1072 -#define _ITER_NEXT_TUPLE_r23 1073 -#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1074 -#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1075 -#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1076 -#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1077 -#define _JUMP_TO_TOP_r00 1078 -#define _LIST_APPEND_r10 1079 -#define _LIST_EXTEND_r10 1080 -#define _LOAD_ATTR_r10 1081 -#define _LOAD_ATTR_CLASS_r11 1082 -#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_r11 1083 -#define _LOAD_ATTR_INSTANCE_VALUE_r02 1084 -#define _LOAD_ATTR_INSTANCE_VALUE_r12 1085 -#define _LOAD_ATTR_INSTANCE_VALUE_r23 1086 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1087 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1088 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1089 -#define _LOAD_ATTR_METHOD_NO_DICT_r02 1090 -#define _LOAD_ATTR_METHOD_NO_DICT_r12 1091 -#define _LOAD_ATTR_METHOD_NO_DICT_r23 1092 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1093 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1094 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1095 -#define _LOAD_ATTR_MODULE_r12 1096 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1097 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1098 -#define _LOAD_ATTR_PROPERTY_FRAME_r11 1099 -#define _LOAD_ATTR_SLOT_r02 1100 -#define _LOAD_ATTR_SLOT_r12 1101 -#define _LOAD_ATTR_SLOT_r23 1102 -#define _LOAD_ATTR_WITH_HINT_r12 1103 -#define _LOAD_BUILD_CLASS_r01 1104 -#define _LOAD_BYTECODE_r00 1105 -#define _LOAD_COMMON_CONSTANT_r01 1106 -#define _LOAD_COMMON_CONSTANT_r12 1107 -#define _LOAD_COMMON_CONSTANT_r23 1108 -#define _LOAD_CONST_r01 1109 -#define _LOAD_CONST_r12 1110 -#define _LOAD_CONST_r23 1111 -#define _LOAD_CONST_INLINE_r01 1112 -#define _LOAD_CONST_INLINE_r12 1113 -#define _LOAD_CONST_INLINE_r23 1114 -#define _LOAD_CONST_INLINE_BORROW_r01 1115 -#define _LOAD_CONST_INLINE_BORROW_r12 1116 -#define _LOAD_CONST_INLINE_BORROW_r23 1117 -#define _LOAD_CONST_UNDER_INLINE_r02 1118 -#define _LOAD_CONST_UNDER_INLINE_r12 1119 -#define _LOAD_CONST_UNDER_INLINE_r23 1120 -#define _LOAD_CONST_UNDER_INLINE_BORROW_r02 1121 -#define _LOAD_CONST_UNDER_INLINE_BORROW_r12 1122 -#define _LOAD_CONST_UNDER_INLINE_BORROW_r23 1123 -#define _LOAD_DEREF_r01 1124 -#define _LOAD_FAST_r01 1125 -#define _LOAD_FAST_r12 1126 -#define _LOAD_FAST_r23 1127 -#define _LOAD_FAST_0_r01 1128 -#define _LOAD_FAST_0_r12 1129 -#define _LOAD_FAST_0_r23 1130 -#define _LOAD_FAST_1_r01 1131 -#define _LOAD_FAST_1_r12 1132 -#define _LOAD_FAST_1_r23 1133 -#define _LOAD_FAST_2_r01 1134 -#define _LOAD_FAST_2_r12 1135 -#define _LOAD_FAST_2_r23 1136 -#define _LOAD_FAST_3_r01 1137 -#define _LOAD_FAST_3_r12 1138 -#define _LOAD_FAST_3_r23 1139 -#define _LOAD_FAST_4_r01 1140 -#define _LOAD_FAST_4_r12 1141 -#define _LOAD_FAST_4_r23 1142 -#define _LOAD_FAST_5_r01 1143 -#define _LOAD_FAST_5_r12 1144 -#define _LOAD_FAST_5_r23 1145 -#define _LOAD_FAST_6_r01 1146 -#define _LOAD_FAST_6_r12 1147 -#define _LOAD_FAST_6_r23 1148 -#define _LOAD_FAST_7_r01 1149 -#define _LOAD_FAST_7_r12 1150 -#define _LOAD_FAST_7_r23 1151 -#define _LOAD_FAST_AND_CLEAR_r01 1152 -#define _LOAD_FAST_AND_CLEAR_r12 1153 -#define _LOAD_FAST_AND_CLEAR_r23 1154 -#define _LOAD_FAST_BORROW_r01 1155 -#define _LOAD_FAST_BORROW_r12 1156 -#define _LOAD_FAST_BORROW_r23 1157 -#define _LOAD_FAST_BORROW_0_r01 1158 -#define _LOAD_FAST_BORROW_0_r12 1159 -#define _LOAD_FAST_BORROW_0_r23 1160 -#define _LOAD_FAST_BORROW_1_r01 1161 -#define _LOAD_FAST_BORROW_1_r12 1162 -#define _LOAD_FAST_BORROW_1_r23 1163 -#define _LOAD_FAST_BORROW_2_r01 1164 -#define _LOAD_FAST_BORROW_2_r12 1165 -#define _LOAD_FAST_BORROW_2_r23 1166 -#define _LOAD_FAST_BORROW_3_r01 1167 -#define _LOAD_FAST_BORROW_3_r12 1168 -#define _LOAD_FAST_BORROW_3_r23 1169 -#define _LOAD_FAST_BORROW_4_r01 1170 -#define _LOAD_FAST_BORROW_4_r12 1171 -#define _LOAD_FAST_BORROW_4_r23 1172 -#define _LOAD_FAST_BORROW_5_r01 1173 -#define _LOAD_FAST_BORROW_5_r12 1174 -#define _LOAD_FAST_BORROW_5_r23 1175 -#define _LOAD_FAST_BORROW_6_r01 1176 -#define _LOAD_FAST_BORROW_6_r12 1177 -#define _LOAD_FAST_BORROW_6_r23 1178 -#define _LOAD_FAST_BORROW_7_r01 1179 -#define _LOAD_FAST_BORROW_7_r12 1180 -#define _LOAD_FAST_BORROW_7_r23 1181 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1182 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1183 -#define _LOAD_FAST_CHECK_r01 1184 -#define _LOAD_FAST_CHECK_r12 1185 -#define _LOAD_FAST_CHECK_r23 1186 -#define _LOAD_FAST_LOAD_FAST_r02 1187 -#define _LOAD_FAST_LOAD_FAST_r13 1188 -#define _LOAD_FROM_DICT_OR_DEREF_r11 1189 -#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1190 -#define _LOAD_GLOBAL_r00 1191 -#define _LOAD_GLOBAL_BUILTINS_r01 1192 -#define _LOAD_GLOBAL_MODULE_r01 1193 -#define _LOAD_LOCALS_r01 1194 -#define _LOAD_LOCALS_r12 1195 -#define _LOAD_LOCALS_r23 1196 -#define _LOAD_NAME_r01 1197 -#define _LOAD_SMALL_INT_r01 1198 -#define _LOAD_SMALL_INT_r12 1199 -#define _LOAD_SMALL_INT_r23 1200 -#define _LOAD_SMALL_INT_0_r01 1201 -#define _LOAD_SMALL_INT_0_r12 1202 -#define _LOAD_SMALL_INT_0_r23 1203 -#define _LOAD_SMALL_INT_1_r01 1204 -#define _LOAD_SMALL_INT_1_r12 1205 -#define _LOAD_SMALL_INT_1_r23 1206 -#define _LOAD_SMALL_INT_2_r01 1207 -#define _LOAD_SMALL_INT_2_r12 1208 -#define _LOAD_SMALL_INT_2_r23 1209 -#define _LOAD_SMALL_INT_3_r01 1210 -#define _LOAD_SMALL_INT_3_r12 1211 -#define _LOAD_SMALL_INT_3_r23 1212 -#define _LOAD_SPECIAL_r00 1213 -#define _LOAD_SUPER_ATTR_ATTR_r31 1214 -#define _LOAD_SUPER_ATTR_METHOD_r32 1215 -#define _MAKE_CALLARGS_A_TUPLE_r33 1216 -#define _MAKE_CELL_r00 1217 -#define _MAKE_FUNCTION_r11 1218 -#define _MAKE_WARM_r00 1219 -#define _MAKE_WARM_r11 1220 -#define _MAKE_WARM_r22 1221 -#define _MAKE_WARM_r33 1222 -#define _MAP_ADD_r20 1223 -#define _MATCH_CLASS_r31 1224 -#define _MATCH_KEYS_r23 1225 -#define _MATCH_MAPPING_r02 1226 -#define _MATCH_MAPPING_r12 1227 -#define _MATCH_MAPPING_r23 1228 -#define _MATCH_SEQUENCE_r02 1229 -#define _MATCH_SEQUENCE_r12 1230 -#define _MATCH_SEQUENCE_r23 1231 -#define _MAYBE_EXPAND_METHOD_r00 1232 -#define _MAYBE_EXPAND_METHOD_KW_r11 1233 -#define _MONITOR_CALL_r00 1234 -#define _MONITOR_CALL_KW_r11 1235 -#define _MONITOR_JUMP_BACKWARD_r00 1236 -#define _MONITOR_JUMP_BACKWARD_r11 1237 -#define _MONITOR_JUMP_BACKWARD_r22 1238 -#define _MONITOR_JUMP_BACKWARD_r33 1239 -#define _MONITOR_RESUME_r00 1240 -#define _NOP_r00 1241 -#define _NOP_r11 1242 -#define _NOP_r22 1243 -#define _NOP_r33 1244 -#define _POP_CALL_r20 1245 -#define _POP_CALL_LOAD_CONST_INLINE_BORROW_r21 1246 -#define _POP_CALL_ONE_r30 1247 -#define _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31 1248 -#define _POP_CALL_TWO_r30 1249 -#define _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31 1250 -#define _POP_EXCEPT_r10 1251 -#define _POP_ITER_r20 1252 -#define _POP_JUMP_IF_FALSE_r00 1253 -#define _POP_JUMP_IF_FALSE_r10 1254 -#define _POP_JUMP_IF_FALSE_r21 1255 -#define _POP_JUMP_IF_FALSE_r32 1256 -#define _POP_JUMP_IF_TRUE_r00 1257 -#define _POP_JUMP_IF_TRUE_r10 1258 -#define _POP_JUMP_IF_TRUE_r21 1259 -#define _POP_JUMP_IF_TRUE_r32 1260 -#define _POP_TOP_r10 1261 -#define _POP_TOP_FLOAT_r00 1262 -#define _POP_TOP_FLOAT_r10 1263 -#define _POP_TOP_FLOAT_r21 1264 -#define _POP_TOP_FLOAT_r32 1265 -#define _POP_TOP_INT_r00 1266 -#define _POP_TOP_INT_r10 1267 -#define _POP_TOP_INT_r21 1268 -#define _POP_TOP_INT_r32 1269 -#define _POP_TOP_LOAD_CONST_INLINE_r11 1270 -#define _POP_TOP_LOAD_CONST_INLINE_BORROW_r11 1271 -#define _POP_TOP_NOP_r00 1272 -#define _POP_TOP_NOP_r10 1273 -#define _POP_TOP_NOP_r21 1274 -#define _POP_TOP_NOP_r32 1275 -#define _POP_TOP_UNICODE_r00 1276 -#define _POP_TOP_UNICODE_r10 1277 -#define _POP_TOP_UNICODE_r21 1278 -#define _POP_TOP_UNICODE_r32 1279 -#define _POP_TWO_r20 1280 -#define _POP_TWO_LOAD_CONST_INLINE_BORROW_r21 1281 -#define _PUSH_EXC_INFO_r02 1282 -#define _PUSH_EXC_INFO_r12 1283 -#define _PUSH_EXC_INFO_r23 1284 -#define _PUSH_FRAME_r10 1285 -#define _PUSH_NULL_r01 1286 -#define _PUSH_NULL_r12 1287 -#define _PUSH_NULL_r23 1288 -#define _PUSH_NULL_CONDITIONAL_r00 1289 -#define _PY_FRAME_EX_r31 1290 -#define _PY_FRAME_GENERAL_r01 1291 -#define _PY_FRAME_KW_r11 1292 -#define _QUICKEN_RESUME_r00 1293 -#define _QUICKEN_RESUME_r11 1294 -#define _QUICKEN_RESUME_r22 1295 -#define _QUICKEN_RESUME_r33 1296 -#define _REPLACE_WITH_TRUE_r02 1297 -#define _REPLACE_WITH_TRUE_r12 1298 -#define _REPLACE_WITH_TRUE_r23 1299 -#define _RESUME_CHECK_r00 1300 -#define _RESUME_CHECK_r11 1301 -#define _RESUME_CHECK_r22 1302 -#define _RESUME_CHECK_r33 1303 -#define _RETURN_GENERATOR_r01 1304 -#define _RETURN_VALUE_r11 1305 -#define _SAVE_RETURN_OFFSET_r00 1306 -#define _SAVE_RETURN_OFFSET_r11 1307 -#define _SAVE_RETURN_OFFSET_r22 1308 -#define _SAVE_RETURN_OFFSET_r33 1309 -#define _SEND_r22 1310 -#define _SEND_GEN_FRAME_r22 1311 -#define _SETUP_ANNOTATIONS_r00 1312 -#define _SET_ADD_r10 1313 -#define _SET_FUNCTION_ATTRIBUTE_r01 1314 -#define _SET_FUNCTION_ATTRIBUTE_r11 1315 -#define _SET_FUNCTION_ATTRIBUTE_r21 1316 -#define _SET_FUNCTION_ATTRIBUTE_r32 1317 -#define _SET_IP_r00 1318 -#define _SET_IP_r11 1319 -#define _SET_IP_r22 1320 -#define _SET_IP_r33 1321 -#define _SET_UPDATE_r10 1322 -#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r02 1323 -#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12 1324 -#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22 1325 -#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32 1326 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03 1327 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13 1328 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23 1329 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33 1330 -#define _SPILL_OR_RELOAD_r01 1331 -#define _SPILL_OR_RELOAD_r02 1332 -#define _SPILL_OR_RELOAD_r03 1333 -#define _SPILL_OR_RELOAD_r10 1334 -#define _SPILL_OR_RELOAD_r12 1335 -#define _SPILL_OR_RELOAD_r13 1336 -#define _SPILL_OR_RELOAD_r20 1337 -#define _SPILL_OR_RELOAD_r21 1338 -#define _SPILL_OR_RELOAD_r23 1339 -#define _SPILL_OR_RELOAD_r30 1340 -#define _SPILL_OR_RELOAD_r31 1341 -#define _SPILL_OR_RELOAD_r32 1342 -#define _START_EXECUTOR_r00 1343 -#define _STORE_ATTR_r20 1344 -#define _STORE_ATTR_INSTANCE_VALUE_r21 1345 -#define _STORE_ATTR_SLOT_r21 1346 -#define _STORE_ATTR_WITH_HINT_r21 1347 -#define _STORE_DEREF_r10 1348 -#define _STORE_FAST_LOAD_FAST_r11 1349 -#define _STORE_FAST_STORE_FAST_r20 1350 -#define _STORE_GLOBAL_r10 1351 -#define _STORE_NAME_r10 1352 -#define _STORE_SLICE_r30 1353 -#define _STORE_SUBSCR_r30 1354 -#define _STORE_SUBSCR_DICT_r31 1355 -#define _STORE_SUBSCR_LIST_INT_r32 1356 -#define _SWAP_r11 1357 -#define _SWAP_2_r02 1358 -#define _SWAP_2_r12 1359 -#define _SWAP_2_r22 1360 -#define _SWAP_2_r33 1361 -#define _SWAP_3_r03 1362 -#define _SWAP_3_r13 1363 -#define _SWAP_3_r23 1364 -#define _SWAP_3_r33 1365 -#define _SWAP_FAST_r01 1366 -#define _SWAP_FAST_r11 1367 -#define _SWAP_FAST_r22 1368 -#define _SWAP_FAST_r33 1369 -#define _SWAP_FAST_0_r01 1370 -#define _SWAP_FAST_0_r11 1371 -#define _SWAP_FAST_0_r22 1372 -#define _SWAP_FAST_0_r33 1373 -#define _SWAP_FAST_1_r01 1374 -#define _SWAP_FAST_1_r11 1375 -#define _SWAP_FAST_1_r22 1376 -#define _SWAP_FAST_1_r33 1377 -#define _SWAP_FAST_2_r01 1378 -#define _SWAP_FAST_2_r11 1379 -#define _SWAP_FAST_2_r22 1380 -#define _SWAP_FAST_2_r33 1381 -#define _SWAP_FAST_3_r01 1382 -#define _SWAP_FAST_3_r11 1383 -#define _SWAP_FAST_3_r22 1384 -#define _SWAP_FAST_3_r33 1385 -#define _SWAP_FAST_4_r01 1386 -#define _SWAP_FAST_4_r11 1387 -#define _SWAP_FAST_4_r22 1388 -#define _SWAP_FAST_4_r33 1389 -#define _SWAP_FAST_5_r01 1390 -#define _SWAP_FAST_5_r11 1391 -#define _SWAP_FAST_5_r22 1392 -#define _SWAP_FAST_5_r33 1393 -#define _SWAP_FAST_6_r01 1394 -#define _SWAP_FAST_6_r11 1395 -#define _SWAP_FAST_6_r22 1396 -#define _SWAP_FAST_6_r33 1397 -#define _SWAP_FAST_7_r01 1398 -#define _SWAP_FAST_7_r11 1399 -#define _SWAP_FAST_7_r22 1400 -#define _SWAP_FAST_7_r33 1401 -#define _TIER2_RESUME_CHECK_r00 1402 -#define _TIER2_RESUME_CHECK_r11 1403 -#define _TIER2_RESUME_CHECK_r22 1404 -#define _TIER2_RESUME_CHECK_r33 1405 -#define _TO_BOOL_r11 1406 -#define _TO_BOOL_BOOL_r01 1407 -#define _TO_BOOL_BOOL_r11 1408 -#define _TO_BOOL_BOOL_r22 1409 -#define _TO_BOOL_BOOL_r33 1410 -#define _TO_BOOL_INT_r02 1411 -#define _TO_BOOL_INT_r12 1412 -#define _TO_BOOL_INT_r23 1413 -#define _TO_BOOL_LIST_r02 1414 -#define _TO_BOOL_LIST_r12 1415 -#define _TO_BOOL_LIST_r23 1416 -#define _TO_BOOL_NONE_r01 1417 -#define _TO_BOOL_NONE_r11 1418 -#define _TO_BOOL_NONE_r22 1419 -#define _TO_BOOL_NONE_r33 1420 -#define _TO_BOOL_STR_r02 1421 -#define _TO_BOOL_STR_r12 1422 -#define _TO_BOOL_STR_r23 1423 -#define _TRACE_RECORD_r00 1424 -#define _UNARY_INVERT_r12 1425 -#define _UNARY_NEGATIVE_r12 1426 -#define _UNARY_NOT_r01 1427 -#define _UNARY_NOT_r11 1428 -#define _UNARY_NOT_r22 1429 -#define _UNARY_NOT_r33 1430 -#define _UNPACK_EX_r10 1431 -#define _UNPACK_SEQUENCE_r10 1432 -#define _UNPACK_SEQUENCE_LIST_r10 1433 -#define _UNPACK_SEQUENCE_TUPLE_r10 1434 -#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1435 -#define _WITH_EXCEPT_START_r33 1436 -#define _YIELD_VALUE_r11 1437 -#define MAX_UOP_REGS_ID 1437 +#define MAX_UOP_ID 581 +#define _BINARY_OP_r23 582 +#define _BINARY_OP_ADD_FLOAT_r03 583 +#define _BINARY_OP_ADD_FLOAT_r13 584 +#define _BINARY_OP_ADD_FLOAT_r23 585 +#define _BINARY_OP_ADD_INT_r03 586 +#define _BINARY_OP_ADD_INT_r13 587 +#define _BINARY_OP_ADD_INT_r23 588 +#define _BINARY_OP_ADD_UNICODE_r03 589 +#define _BINARY_OP_ADD_UNICODE_r13 590 +#define _BINARY_OP_ADD_UNICODE_r23 591 +#define _BINARY_OP_EXTEND_r23 592 +#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 593 +#define _BINARY_OP_MULTIPLY_FLOAT_r03 594 +#define _BINARY_OP_MULTIPLY_FLOAT_r13 595 +#define _BINARY_OP_MULTIPLY_FLOAT_r23 596 +#define _BINARY_OP_MULTIPLY_INT_r03 597 +#define _BINARY_OP_MULTIPLY_INT_r13 598 +#define _BINARY_OP_MULTIPLY_INT_r23 599 +#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 600 +#define _BINARY_OP_SUBSCR_DICT_r23 601 +#define _BINARY_OP_SUBSCR_INIT_CALL_r01 602 +#define _BINARY_OP_SUBSCR_INIT_CALL_r11 603 +#define _BINARY_OP_SUBSCR_INIT_CALL_r21 604 +#define _BINARY_OP_SUBSCR_INIT_CALL_r31 605 +#define _BINARY_OP_SUBSCR_LIST_INT_r23 606 +#define _BINARY_OP_SUBSCR_LIST_SLICE_r21 607 +#define _BINARY_OP_SUBSCR_STR_INT_r23 608 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 609 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 610 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 611 +#define _BINARY_OP_SUBSCR_USTR_INT_r23 612 +#define _BINARY_OP_SUBTRACT_FLOAT_r03 613 +#define _BINARY_OP_SUBTRACT_FLOAT_r13 614 +#define _BINARY_OP_SUBTRACT_FLOAT_r23 615 +#define _BINARY_OP_SUBTRACT_INT_r03 616 +#define _BINARY_OP_SUBTRACT_INT_r13 617 +#define _BINARY_OP_SUBTRACT_INT_r23 618 +#define _BINARY_SLICE_r31 619 +#define _BUILD_INTERPOLATION_r01 620 +#define _BUILD_LIST_r01 621 +#define _BUILD_MAP_r01 622 +#define _BUILD_SET_r01 623 +#define _BUILD_SLICE_r01 624 +#define _BUILD_STRING_r01 625 +#define _BUILD_TEMPLATE_r21 626 +#define _BUILD_TUPLE_r01 627 +#define _CALL_BUILTIN_CLASS_r01 628 +#define _CALL_BUILTIN_FAST_r01 629 +#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r01 630 +#define _CALL_BUILTIN_O_r03 631 +#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 632 +#define _CALL_INTRINSIC_1_r11 633 +#define _CALL_INTRINSIC_2_r21 634 +#define _CALL_ISINSTANCE_r31 635 +#define _CALL_KW_NON_PY_r11 636 +#define _CALL_LEN_r33 637 +#define _CALL_LIST_APPEND_r03 638 +#define _CALL_LIST_APPEND_r13 639 +#define _CALL_LIST_APPEND_r23 640 +#define _CALL_LIST_APPEND_r33 641 +#define _CALL_METHOD_DESCRIPTOR_FAST_r01 642 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01 643 +#define _CALL_METHOD_DESCRIPTOR_NOARGS_r01 644 +#define _CALL_METHOD_DESCRIPTOR_O_r03 645 +#define _CALL_NON_PY_GENERAL_r01 646 +#define _CALL_STR_1_r32 647 +#define _CALL_TUPLE_1_r32 648 +#define _CALL_TYPE_1_r02 649 +#define _CALL_TYPE_1_r12 650 +#define _CALL_TYPE_1_r22 651 +#define _CALL_TYPE_1_r32 652 +#define _CHECK_AND_ALLOCATE_OBJECT_r00 653 +#define _CHECK_ATTR_CLASS_r01 654 +#define _CHECK_ATTR_CLASS_r11 655 +#define _CHECK_ATTR_CLASS_r22 656 +#define _CHECK_ATTR_CLASS_r33 657 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 658 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 659 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 660 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 661 +#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 662 +#define _CHECK_EG_MATCH_r22 663 +#define _CHECK_EXC_MATCH_r22 664 +#define _CHECK_FUNCTION_EXACT_ARGS_r00 665 +#define _CHECK_FUNCTION_VERSION_r00 666 +#define _CHECK_FUNCTION_VERSION_INLINE_r00 667 +#define _CHECK_FUNCTION_VERSION_INLINE_r11 668 +#define _CHECK_FUNCTION_VERSION_INLINE_r22 669 +#define _CHECK_FUNCTION_VERSION_INLINE_r33 670 +#define _CHECK_FUNCTION_VERSION_KW_r11 671 +#define _CHECK_IS_NOT_PY_CALLABLE_r00 672 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 673 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 674 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 675 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 676 +#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 677 +#define _CHECK_IS_PY_CALLABLE_EX_r03 678 +#define _CHECK_IS_PY_CALLABLE_EX_r13 679 +#define _CHECK_IS_PY_CALLABLE_EX_r23 680 +#define _CHECK_IS_PY_CALLABLE_EX_r33 681 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 682 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 683 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 684 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 685 +#define _CHECK_METHOD_VERSION_r00 686 +#define _CHECK_METHOD_VERSION_KW_r11 687 +#define _CHECK_PEP_523_r00 688 +#define _CHECK_PEP_523_r11 689 +#define _CHECK_PEP_523_r22 690 +#define _CHECK_PEP_523_r33 691 +#define _CHECK_PERIODIC_r00 692 +#define _CHECK_PERIODIC_AT_END_r00 693 +#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 694 +#define _CHECK_RECURSION_REMAINING_r00 695 +#define _CHECK_RECURSION_REMAINING_r11 696 +#define _CHECK_RECURSION_REMAINING_r22 697 +#define _CHECK_RECURSION_REMAINING_r33 698 +#define _CHECK_STACK_SPACE_r00 699 +#define _CHECK_STACK_SPACE_OPERAND_r00 700 +#define _CHECK_STACK_SPACE_OPERAND_r11 701 +#define _CHECK_STACK_SPACE_OPERAND_r22 702 +#define _CHECK_STACK_SPACE_OPERAND_r33 703 +#define _CHECK_VALIDITY_r00 704 +#define _CHECK_VALIDITY_r11 705 +#define _CHECK_VALIDITY_r22 706 +#define _CHECK_VALIDITY_r33 707 +#define _COLD_DYNAMIC_EXIT_r00 708 +#define _COLD_EXIT_r00 709 +#define _COMPARE_OP_r21 710 +#define _COMPARE_OP_FLOAT_r03 711 +#define _COMPARE_OP_FLOAT_r13 712 +#define _COMPARE_OP_FLOAT_r23 713 +#define _COMPARE_OP_INT_r23 714 +#define _COMPARE_OP_STR_r23 715 +#define _CONTAINS_OP_r23 716 +#define _CONTAINS_OP_DICT_r23 717 +#define _CONTAINS_OP_SET_r23 718 +#define _CONVERT_VALUE_r11 719 +#define _COPY_r01 720 +#define _COPY_1_r02 721 +#define _COPY_1_r12 722 +#define _COPY_1_r23 723 +#define _COPY_2_r03 724 +#define _COPY_2_r13 725 +#define _COPY_2_r23 726 +#define _COPY_3_r03 727 +#define _COPY_3_r13 728 +#define _COPY_3_r23 729 +#define _COPY_3_r33 730 +#define _COPY_FREE_VARS_r00 731 +#define _COPY_FREE_VARS_r11 732 +#define _COPY_FREE_VARS_r22 733 +#define _COPY_FREE_VARS_r33 734 +#define _CREATE_INIT_FRAME_r01 735 +#define _DELETE_ATTR_r10 736 +#define _DELETE_DEREF_r00 737 +#define _DELETE_FAST_r00 738 +#define _DELETE_GLOBAL_r00 739 +#define _DELETE_NAME_r00 740 +#define _DELETE_SUBSCR_r20 741 +#define _DEOPT_r00 742 +#define _DEOPT_r10 743 +#define _DEOPT_r20 744 +#define _DEOPT_r30 745 +#define _DICT_MERGE_r10 746 +#define _DICT_UPDATE_r10 747 +#define _DO_CALL_r01 748 +#define _DO_CALL_FUNCTION_EX_r31 749 +#define _DO_CALL_KW_r11 750 +#define _DYNAMIC_EXIT_r00 751 +#define _DYNAMIC_EXIT_r10 752 +#define _DYNAMIC_EXIT_r20 753 +#define _DYNAMIC_EXIT_r30 754 +#define _END_FOR_r10 755 +#define _END_SEND_r21 756 +#define _ERROR_POP_N_r00 757 +#define _EXIT_INIT_CHECK_r10 758 +#define _EXIT_TRACE_r00 759 +#define _EXIT_TRACE_r10 760 +#define _EXIT_TRACE_r20 761 +#define _EXIT_TRACE_r30 762 +#define _EXPAND_METHOD_r00 763 +#define _EXPAND_METHOD_KW_r11 764 +#define _FATAL_ERROR_r00 765 +#define _FATAL_ERROR_r11 766 +#define _FATAL_ERROR_r22 767 +#define _FATAL_ERROR_r33 768 +#define _FORMAT_SIMPLE_r11 769 +#define _FORMAT_WITH_SPEC_r21 770 +#define _FOR_ITER_r23 771 +#define _FOR_ITER_GEN_FRAME_r03 772 +#define _FOR_ITER_GEN_FRAME_r13 773 +#define _FOR_ITER_GEN_FRAME_r23 774 +#define _FOR_ITER_TIER_TWO_r23 775 +#define _GET_AITER_r11 776 +#define _GET_ANEXT_r12 777 +#define _GET_AWAITABLE_r11 778 +#define _GET_ITER_r12 779 +#define _GET_LEN_r12 780 +#define _GET_YIELD_FROM_ITER_r11 781 +#define _GUARD_BINARY_OP_EXTEND_r22 782 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 783 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 784 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 785 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 786 +#define _GUARD_BIT_IS_SET_POP_r00 787 +#define _GUARD_BIT_IS_SET_POP_r10 788 +#define _GUARD_BIT_IS_SET_POP_r21 789 +#define _GUARD_BIT_IS_SET_POP_r32 790 +#define _GUARD_BIT_IS_SET_POP_4_r00 791 +#define _GUARD_BIT_IS_SET_POP_4_r10 792 +#define _GUARD_BIT_IS_SET_POP_4_r21 793 +#define _GUARD_BIT_IS_SET_POP_4_r32 794 +#define _GUARD_BIT_IS_SET_POP_5_r00 795 +#define _GUARD_BIT_IS_SET_POP_5_r10 796 +#define _GUARD_BIT_IS_SET_POP_5_r21 797 +#define _GUARD_BIT_IS_SET_POP_5_r32 798 +#define _GUARD_BIT_IS_SET_POP_6_r00 799 +#define _GUARD_BIT_IS_SET_POP_6_r10 800 +#define _GUARD_BIT_IS_SET_POP_6_r21 801 +#define _GUARD_BIT_IS_SET_POP_6_r32 802 +#define _GUARD_BIT_IS_SET_POP_7_r00 803 +#define _GUARD_BIT_IS_SET_POP_7_r10 804 +#define _GUARD_BIT_IS_SET_POP_7_r21 805 +#define _GUARD_BIT_IS_SET_POP_7_r32 806 +#define _GUARD_BIT_IS_UNSET_POP_r00 807 +#define _GUARD_BIT_IS_UNSET_POP_r10 808 +#define _GUARD_BIT_IS_UNSET_POP_r21 809 +#define _GUARD_BIT_IS_UNSET_POP_r32 810 +#define _GUARD_BIT_IS_UNSET_POP_4_r00 811 +#define _GUARD_BIT_IS_UNSET_POP_4_r10 812 +#define _GUARD_BIT_IS_UNSET_POP_4_r21 813 +#define _GUARD_BIT_IS_UNSET_POP_4_r32 814 +#define _GUARD_BIT_IS_UNSET_POP_5_r00 815 +#define _GUARD_BIT_IS_UNSET_POP_5_r10 816 +#define _GUARD_BIT_IS_UNSET_POP_5_r21 817 +#define _GUARD_BIT_IS_UNSET_POP_5_r32 818 +#define _GUARD_BIT_IS_UNSET_POP_6_r00 819 +#define _GUARD_BIT_IS_UNSET_POP_6_r10 820 +#define _GUARD_BIT_IS_UNSET_POP_6_r21 821 +#define _GUARD_BIT_IS_UNSET_POP_6_r32 822 +#define _GUARD_BIT_IS_UNSET_POP_7_r00 823 +#define _GUARD_BIT_IS_UNSET_POP_7_r10 824 +#define _GUARD_BIT_IS_UNSET_POP_7_r21 825 +#define _GUARD_BIT_IS_UNSET_POP_7_r32 826 +#define _GUARD_CALLABLE_ISINSTANCE_r03 827 +#define _GUARD_CALLABLE_ISINSTANCE_r13 828 +#define _GUARD_CALLABLE_ISINSTANCE_r23 829 +#define _GUARD_CALLABLE_ISINSTANCE_r33 830 +#define _GUARD_CALLABLE_LEN_r03 831 +#define _GUARD_CALLABLE_LEN_r13 832 +#define _GUARD_CALLABLE_LEN_r23 833 +#define _GUARD_CALLABLE_LEN_r33 834 +#define _GUARD_CALLABLE_LIST_APPEND_r03 835 +#define _GUARD_CALLABLE_LIST_APPEND_r13 836 +#define _GUARD_CALLABLE_LIST_APPEND_r23 837 +#define _GUARD_CALLABLE_LIST_APPEND_r33 838 +#define _GUARD_CALLABLE_STR_1_r03 839 +#define _GUARD_CALLABLE_STR_1_r13 840 +#define _GUARD_CALLABLE_STR_1_r23 841 +#define _GUARD_CALLABLE_STR_1_r33 842 +#define _GUARD_CALLABLE_TUPLE_1_r03 843 +#define _GUARD_CALLABLE_TUPLE_1_r13 844 +#define _GUARD_CALLABLE_TUPLE_1_r23 845 +#define _GUARD_CALLABLE_TUPLE_1_r33 846 +#define _GUARD_CALLABLE_TYPE_1_r03 847 +#define _GUARD_CALLABLE_TYPE_1_r13 848 +#define _GUARD_CALLABLE_TYPE_1_r23 849 +#define _GUARD_CALLABLE_TYPE_1_r33 850 +#define _GUARD_DORV_NO_DICT_r01 851 +#define _GUARD_DORV_NO_DICT_r11 852 +#define _GUARD_DORV_NO_DICT_r22 853 +#define _GUARD_DORV_NO_DICT_r33 854 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 855 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 856 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 857 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 858 +#define _GUARD_GLOBALS_VERSION_r00 859 +#define _GUARD_GLOBALS_VERSION_r11 860 +#define _GUARD_GLOBALS_VERSION_r22 861 +#define _GUARD_GLOBALS_VERSION_r33 862 +#define _GUARD_IP_RETURN_GENERATOR_r00 863 +#define _GUARD_IP_RETURN_GENERATOR_r11 864 +#define _GUARD_IP_RETURN_GENERATOR_r22 865 +#define _GUARD_IP_RETURN_GENERATOR_r33 866 +#define _GUARD_IP_RETURN_VALUE_r00 867 +#define _GUARD_IP_RETURN_VALUE_r11 868 +#define _GUARD_IP_RETURN_VALUE_r22 869 +#define _GUARD_IP_RETURN_VALUE_r33 870 +#define _GUARD_IP_YIELD_VALUE_r00 871 +#define _GUARD_IP_YIELD_VALUE_r11 872 +#define _GUARD_IP_YIELD_VALUE_r22 873 +#define _GUARD_IP_YIELD_VALUE_r33 874 +#define _GUARD_IP__PUSH_FRAME_r00 875 +#define _GUARD_IP__PUSH_FRAME_r11 876 +#define _GUARD_IP__PUSH_FRAME_r22 877 +#define _GUARD_IP__PUSH_FRAME_r33 878 +#define _GUARD_IS_FALSE_POP_r00 879 +#define _GUARD_IS_FALSE_POP_r10 880 +#define _GUARD_IS_FALSE_POP_r21 881 +#define _GUARD_IS_FALSE_POP_r32 882 +#define _GUARD_IS_NONE_POP_r00 883 +#define _GUARD_IS_NONE_POP_r10 884 +#define _GUARD_IS_NONE_POP_r21 885 +#define _GUARD_IS_NONE_POP_r32 886 +#define _GUARD_IS_NOT_NONE_POP_r10 887 +#define _GUARD_IS_TRUE_POP_r00 888 +#define _GUARD_IS_TRUE_POP_r10 889 +#define _GUARD_IS_TRUE_POP_r21 890 +#define _GUARD_IS_TRUE_POP_r32 891 +#define _GUARD_KEYS_VERSION_r01 892 +#define _GUARD_KEYS_VERSION_r11 893 +#define _GUARD_KEYS_VERSION_r22 894 +#define _GUARD_KEYS_VERSION_r33 895 +#define _GUARD_NOS_COMPACT_ASCII_r02 896 +#define _GUARD_NOS_COMPACT_ASCII_r12 897 +#define _GUARD_NOS_COMPACT_ASCII_r22 898 +#define _GUARD_NOS_COMPACT_ASCII_r33 899 +#define _GUARD_NOS_DICT_r02 900 +#define _GUARD_NOS_DICT_r12 901 +#define _GUARD_NOS_DICT_r22 902 +#define _GUARD_NOS_DICT_r33 903 +#define _GUARD_NOS_FLOAT_r02 904 +#define _GUARD_NOS_FLOAT_r12 905 +#define _GUARD_NOS_FLOAT_r22 906 +#define _GUARD_NOS_FLOAT_r33 907 +#define _GUARD_NOS_INT_r02 908 +#define _GUARD_NOS_INT_r12 909 +#define _GUARD_NOS_INT_r22 910 +#define _GUARD_NOS_INT_r33 911 +#define _GUARD_NOS_LIST_r02 912 +#define _GUARD_NOS_LIST_r12 913 +#define _GUARD_NOS_LIST_r22 914 +#define _GUARD_NOS_LIST_r33 915 +#define _GUARD_NOS_NOT_NULL_r02 916 +#define _GUARD_NOS_NOT_NULL_r12 917 +#define _GUARD_NOS_NOT_NULL_r22 918 +#define _GUARD_NOS_NOT_NULL_r33 919 +#define _GUARD_NOS_NULL_r02 920 +#define _GUARD_NOS_NULL_r12 921 +#define _GUARD_NOS_NULL_r22 922 +#define _GUARD_NOS_NULL_r33 923 +#define _GUARD_NOS_OVERFLOWED_r02 924 +#define _GUARD_NOS_OVERFLOWED_r12 925 +#define _GUARD_NOS_OVERFLOWED_r22 926 +#define _GUARD_NOS_OVERFLOWED_r33 927 +#define _GUARD_NOS_TUPLE_r02 928 +#define _GUARD_NOS_TUPLE_r12 929 +#define _GUARD_NOS_TUPLE_r22 930 +#define _GUARD_NOS_TUPLE_r33 931 +#define _GUARD_NOS_UNICODE_r02 932 +#define _GUARD_NOS_UNICODE_r12 933 +#define _GUARD_NOS_UNICODE_r22 934 +#define _GUARD_NOS_UNICODE_r33 935 +#define _GUARD_NOT_EXHAUSTED_LIST_r02 936 +#define _GUARD_NOT_EXHAUSTED_LIST_r12 937 +#define _GUARD_NOT_EXHAUSTED_LIST_r22 938 +#define _GUARD_NOT_EXHAUSTED_LIST_r33 939 +#define _GUARD_NOT_EXHAUSTED_RANGE_r02 940 +#define _GUARD_NOT_EXHAUSTED_RANGE_r12 941 +#define _GUARD_NOT_EXHAUSTED_RANGE_r22 942 +#define _GUARD_NOT_EXHAUSTED_RANGE_r33 943 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 944 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 945 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 946 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 947 +#define _GUARD_THIRD_NULL_r03 948 +#define _GUARD_THIRD_NULL_r13 949 +#define _GUARD_THIRD_NULL_r23 950 +#define _GUARD_THIRD_NULL_r33 951 +#define _GUARD_TOS_ANY_SET_r01 952 +#define _GUARD_TOS_ANY_SET_r11 953 +#define _GUARD_TOS_ANY_SET_r22 954 +#define _GUARD_TOS_ANY_SET_r33 955 +#define _GUARD_TOS_DICT_r01 956 +#define _GUARD_TOS_DICT_r11 957 +#define _GUARD_TOS_DICT_r22 958 +#define _GUARD_TOS_DICT_r33 959 +#define _GUARD_TOS_FLOAT_r01 960 +#define _GUARD_TOS_FLOAT_r11 961 +#define _GUARD_TOS_FLOAT_r22 962 +#define _GUARD_TOS_FLOAT_r33 963 +#define _GUARD_TOS_INT_r01 964 +#define _GUARD_TOS_INT_r11 965 +#define _GUARD_TOS_INT_r22 966 +#define _GUARD_TOS_INT_r33 967 +#define _GUARD_TOS_LIST_r01 968 +#define _GUARD_TOS_LIST_r11 969 +#define _GUARD_TOS_LIST_r22 970 +#define _GUARD_TOS_LIST_r33 971 +#define _GUARD_TOS_OVERFLOWED_r01 972 +#define _GUARD_TOS_OVERFLOWED_r11 973 +#define _GUARD_TOS_OVERFLOWED_r22 974 +#define _GUARD_TOS_OVERFLOWED_r33 975 +#define _GUARD_TOS_SLICE_r01 976 +#define _GUARD_TOS_SLICE_r11 977 +#define _GUARD_TOS_SLICE_r22 978 +#define _GUARD_TOS_SLICE_r33 979 +#define _GUARD_TOS_TUPLE_r01 980 +#define _GUARD_TOS_TUPLE_r11 981 +#define _GUARD_TOS_TUPLE_r22 982 +#define _GUARD_TOS_TUPLE_r33 983 +#define _GUARD_TOS_UNICODE_r01 984 +#define _GUARD_TOS_UNICODE_r11 985 +#define _GUARD_TOS_UNICODE_r22 986 +#define _GUARD_TOS_UNICODE_r33 987 +#define _GUARD_TYPE_VERSION_r01 988 +#define _GUARD_TYPE_VERSION_r11 989 +#define _GUARD_TYPE_VERSION_r22 990 +#define _GUARD_TYPE_VERSION_r33 991 +#define _GUARD_TYPE_VERSION_AND_LOCK_r01 992 +#define _GUARD_TYPE_VERSION_AND_LOCK_r11 993 +#define _GUARD_TYPE_VERSION_AND_LOCK_r22 994 +#define _GUARD_TYPE_VERSION_AND_LOCK_r33 995 +#define _HANDLE_PENDING_AND_DEOPT_r00 996 +#define _HANDLE_PENDING_AND_DEOPT_r10 997 +#define _HANDLE_PENDING_AND_DEOPT_r20 998 +#define _HANDLE_PENDING_AND_DEOPT_r30 999 +#define _IMPORT_FROM_r12 1000 +#define _IMPORT_NAME_r21 1001 +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1002 +#define _INIT_CALL_PY_EXACT_ARGS_r01 1003 +#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1004 +#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1005 +#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1006 +#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1007 +#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1008 +#define _INSERT_1_LOAD_CONST_INLINE_r02 1009 +#define _INSERT_1_LOAD_CONST_INLINE_r12 1010 +#define _INSERT_1_LOAD_CONST_INLINE_r23 1011 +#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r02 1012 +#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r12 1013 +#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r23 1014 +#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r03 1015 +#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r13 1016 +#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r23 1017 +#define _INSERT_NULL_r10 1018 +#define _INSTRUMENTED_FOR_ITER_r23 1019 +#define _INSTRUMENTED_INSTRUCTION_r00 1020 +#define _INSTRUMENTED_JUMP_FORWARD_r00 1021 +#define _INSTRUMENTED_JUMP_FORWARD_r11 1022 +#define _INSTRUMENTED_JUMP_FORWARD_r22 1023 +#define _INSTRUMENTED_JUMP_FORWARD_r33 1024 +#define _INSTRUMENTED_LINE_r00 1025 +#define _INSTRUMENTED_NOT_TAKEN_r00 1026 +#define _INSTRUMENTED_NOT_TAKEN_r11 1027 +#define _INSTRUMENTED_NOT_TAKEN_r22 1028 +#define _INSTRUMENTED_NOT_TAKEN_r33 1029 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1030 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1031 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1032 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1033 +#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1034 +#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1035 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1036 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1037 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1038 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1039 +#define _IS_NONE_r11 1040 +#define _IS_OP_r03 1041 +#define _IS_OP_r13 1042 +#define _IS_OP_r23 1043 +#define _ITER_CHECK_LIST_r02 1044 +#define _ITER_CHECK_LIST_r12 1045 +#define _ITER_CHECK_LIST_r22 1046 +#define _ITER_CHECK_LIST_r33 1047 +#define _ITER_CHECK_RANGE_r02 1048 +#define _ITER_CHECK_RANGE_r12 1049 +#define _ITER_CHECK_RANGE_r22 1050 +#define _ITER_CHECK_RANGE_r33 1051 +#define _ITER_CHECK_TUPLE_r02 1052 +#define _ITER_CHECK_TUPLE_r12 1053 +#define _ITER_CHECK_TUPLE_r22 1054 +#define _ITER_CHECK_TUPLE_r33 1055 +#define _ITER_JUMP_LIST_r02 1056 +#define _ITER_JUMP_LIST_r12 1057 +#define _ITER_JUMP_LIST_r22 1058 +#define _ITER_JUMP_LIST_r33 1059 +#define _ITER_JUMP_RANGE_r02 1060 +#define _ITER_JUMP_RANGE_r12 1061 +#define _ITER_JUMP_RANGE_r22 1062 +#define _ITER_JUMP_RANGE_r33 1063 +#define _ITER_JUMP_TUPLE_r02 1064 +#define _ITER_JUMP_TUPLE_r12 1065 +#define _ITER_JUMP_TUPLE_r22 1066 +#define _ITER_JUMP_TUPLE_r33 1067 +#define _ITER_NEXT_LIST_r23 1068 +#define _ITER_NEXT_LIST_TIER_TWO_r23 1069 +#define _ITER_NEXT_RANGE_r03 1070 +#define _ITER_NEXT_RANGE_r13 1071 +#define _ITER_NEXT_RANGE_r23 1072 +#define _ITER_NEXT_TUPLE_r03 1073 +#define _ITER_NEXT_TUPLE_r13 1074 +#define _ITER_NEXT_TUPLE_r23 1075 +#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1076 +#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1077 +#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1078 +#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1079 +#define _JUMP_TO_TOP_r00 1080 +#define _LIST_APPEND_r10 1081 +#define _LIST_EXTEND_r10 1082 +#define _LOAD_ATTR_r10 1083 +#define _LOAD_ATTR_CLASS_r11 1084 +#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_r11 1085 +#define _LOAD_ATTR_INSTANCE_VALUE_r02 1086 +#define _LOAD_ATTR_INSTANCE_VALUE_r12 1087 +#define _LOAD_ATTR_INSTANCE_VALUE_r23 1088 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1089 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1090 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1091 +#define _LOAD_ATTR_METHOD_NO_DICT_r02 1092 +#define _LOAD_ATTR_METHOD_NO_DICT_r12 1093 +#define _LOAD_ATTR_METHOD_NO_DICT_r23 1094 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1095 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1096 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1097 +#define _LOAD_ATTR_MODULE_r12 1098 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1099 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1100 +#define _LOAD_ATTR_PROPERTY_FRAME_r11 1101 +#define _LOAD_ATTR_SLOT_r02 1102 +#define _LOAD_ATTR_SLOT_r12 1103 +#define _LOAD_ATTR_SLOT_r23 1104 +#define _LOAD_ATTR_WITH_HINT_r12 1105 +#define _LOAD_BUILD_CLASS_r01 1106 +#define _LOAD_BYTECODE_r00 1107 +#define _LOAD_COMMON_CONSTANT_r01 1108 +#define _LOAD_COMMON_CONSTANT_r12 1109 +#define _LOAD_COMMON_CONSTANT_r23 1110 +#define _LOAD_CONST_r01 1111 +#define _LOAD_CONST_r12 1112 +#define _LOAD_CONST_r23 1113 +#define _LOAD_CONST_INLINE_r01 1114 +#define _LOAD_CONST_INLINE_r12 1115 +#define _LOAD_CONST_INLINE_r23 1116 +#define _LOAD_CONST_INLINE_BORROW_r01 1117 +#define _LOAD_CONST_INLINE_BORROW_r12 1118 +#define _LOAD_CONST_INLINE_BORROW_r23 1119 +#define _LOAD_CONST_UNDER_INLINE_r02 1120 +#define _LOAD_CONST_UNDER_INLINE_r12 1121 +#define _LOAD_CONST_UNDER_INLINE_r23 1122 +#define _LOAD_CONST_UNDER_INLINE_BORROW_r02 1123 +#define _LOAD_CONST_UNDER_INLINE_BORROW_r12 1124 +#define _LOAD_CONST_UNDER_INLINE_BORROW_r23 1125 +#define _LOAD_DEREF_r01 1126 +#define _LOAD_FAST_r01 1127 +#define _LOAD_FAST_r12 1128 +#define _LOAD_FAST_r23 1129 +#define _LOAD_FAST_0_r01 1130 +#define _LOAD_FAST_0_r12 1131 +#define _LOAD_FAST_0_r23 1132 +#define _LOAD_FAST_1_r01 1133 +#define _LOAD_FAST_1_r12 1134 +#define _LOAD_FAST_1_r23 1135 +#define _LOAD_FAST_2_r01 1136 +#define _LOAD_FAST_2_r12 1137 +#define _LOAD_FAST_2_r23 1138 +#define _LOAD_FAST_3_r01 1139 +#define _LOAD_FAST_3_r12 1140 +#define _LOAD_FAST_3_r23 1141 +#define _LOAD_FAST_4_r01 1142 +#define _LOAD_FAST_4_r12 1143 +#define _LOAD_FAST_4_r23 1144 +#define _LOAD_FAST_5_r01 1145 +#define _LOAD_FAST_5_r12 1146 +#define _LOAD_FAST_5_r23 1147 +#define _LOAD_FAST_6_r01 1148 +#define _LOAD_FAST_6_r12 1149 +#define _LOAD_FAST_6_r23 1150 +#define _LOAD_FAST_7_r01 1151 +#define _LOAD_FAST_7_r12 1152 +#define _LOAD_FAST_7_r23 1153 +#define _LOAD_FAST_AND_CLEAR_r01 1154 +#define _LOAD_FAST_AND_CLEAR_r12 1155 +#define _LOAD_FAST_AND_CLEAR_r23 1156 +#define _LOAD_FAST_BORROW_r01 1157 +#define _LOAD_FAST_BORROW_r12 1158 +#define _LOAD_FAST_BORROW_r23 1159 +#define _LOAD_FAST_BORROW_0_r01 1160 +#define _LOAD_FAST_BORROW_0_r12 1161 +#define _LOAD_FAST_BORROW_0_r23 1162 +#define _LOAD_FAST_BORROW_1_r01 1163 +#define _LOAD_FAST_BORROW_1_r12 1164 +#define _LOAD_FAST_BORROW_1_r23 1165 +#define _LOAD_FAST_BORROW_2_r01 1166 +#define _LOAD_FAST_BORROW_2_r12 1167 +#define _LOAD_FAST_BORROW_2_r23 1168 +#define _LOAD_FAST_BORROW_3_r01 1169 +#define _LOAD_FAST_BORROW_3_r12 1170 +#define _LOAD_FAST_BORROW_3_r23 1171 +#define _LOAD_FAST_BORROW_4_r01 1172 +#define _LOAD_FAST_BORROW_4_r12 1173 +#define _LOAD_FAST_BORROW_4_r23 1174 +#define _LOAD_FAST_BORROW_5_r01 1175 +#define _LOAD_FAST_BORROW_5_r12 1176 +#define _LOAD_FAST_BORROW_5_r23 1177 +#define _LOAD_FAST_BORROW_6_r01 1178 +#define _LOAD_FAST_BORROW_6_r12 1179 +#define _LOAD_FAST_BORROW_6_r23 1180 +#define _LOAD_FAST_BORROW_7_r01 1181 +#define _LOAD_FAST_BORROW_7_r12 1182 +#define _LOAD_FAST_BORROW_7_r23 1183 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1184 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1185 +#define _LOAD_FAST_CHECK_r01 1186 +#define _LOAD_FAST_CHECK_r12 1187 +#define _LOAD_FAST_CHECK_r23 1188 +#define _LOAD_FAST_LOAD_FAST_r02 1189 +#define _LOAD_FAST_LOAD_FAST_r13 1190 +#define _LOAD_FROM_DICT_OR_DEREF_r11 1191 +#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1192 +#define _LOAD_GLOBAL_r00 1193 +#define _LOAD_GLOBAL_BUILTINS_r01 1194 +#define _LOAD_GLOBAL_MODULE_r01 1195 +#define _LOAD_LOCALS_r01 1196 +#define _LOAD_LOCALS_r12 1197 +#define _LOAD_LOCALS_r23 1198 +#define _LOAD_NAME_r01 1199 +#define _LOAD_SMALL_INT_r01 1200 +#define _LOAD_SMALL_INT_r12 1201 +#define _LOAD_SMALL_INT_r23 1202 +#define _LOAD_SMALL_INT_0_r01 1203 +#define _LOAD_SMALL_INT_0_r12 1204 +#define _LOAD_SMALL_INT_0_r23 1205 +#define _LOAD_SMALL_INT_1_r01 1206 +#define _LOAD_SMALL_INT_1_r12 1207 +#define _LOAD_SMALL_INT_1_r23 1208 +#define _LOAD_SMALL_INT_2_r01 1209 +#define _LOAD_SMALL_INT_2_r12 1210 +#define _LOAD_SMALL_INT_2_r23 1211 +#define _LOAD_SMALL_INT_3_r01 1212 +#define _LOAD_SMALL_INT_3_r12 1213 +#define _LOAD_SMALL_INT_3_r23 1214 +#define _LOAD_SPECIAL_r00 1215 +#define _LOAD_SUPER_ATTR_ATTR_r31 1216 +#define _LOAD_SUPER_ATTR_METHOD_r32 1217 +#define _MAKE_CALLARGS_A_TUPLE_r33 1218 +#define _MAKE_CELL_r00 1219 +#define _MAKE_FUNCTION_r11 1220 +#define _MAKE_WARM_r00 1221 +#define _MAKE_WARM_r11 1222 +#define _MAKE_WARM_r22 1223 +#define _MAKE_WARM_r33 1224 +#define _MAP_ADD_r20 1225 +#define _MATCH_CLASS_r31 1226 +#define _MATCH_KEYS_r23 1227 +#define _MATCH_MAPPING_r02 1228 +#define _MATCH_MAPPING_r12 1229 +#define _MATCH_MAPPING_r23 1230 +#define _MATCH_SEQUENCE_r02 1231 +#define _MATCH_SEQUENCE_r12 1232 +#define _MATCH_SEQUENCE_r23 1233 +#define _MAYBE_EXPAND_METHOD_r00 1234 +#define _MAYBE_EXPAND_METHOD_KW_r11 1235 +#define _MONITOR_CALL_r00 1236 +#define _MONITOR_CALL_KW_r11 1237 +#define _MONITOR_JUMP_BACKWARD_r00 1238 +#define _MONITOR_JUMP_BACKWARD_r11 1239 +#define _MONITOR_JUMP_BACKWARD_r22 1240 +#define _MONITOR_JUMP_BACKWARD_r33 1241 +#define _MONITOR_RESUME_r00 1242 +#define _NOP_r00 1243 +#define _NOP_r11 1244 +#define _NOP_r22 1245 +#define _NOP_r33 1246 +#define _POP_CALL_r20 1247 +#define _POP_CALL_LOAD_CONST_INLINE_BORROW_r21 1248 +#define _POP_CALL_ONE_r30 1249 +#define _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31 1250 +#define _POP_CALL_TWO_r30 1251 +#define _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31 1252 +#define _POP_EXCEPT_r10 1253 +#define _POP_ITER_r20 1254 +#define _POP_JUMP_IF_FALSE_r00 1255 +#define _POP_JUMP_IF_FALSE_r10 1256 +#define _POP_JUMP_IF_FALSE_r21 1257 +#define _POP_JUMP_IF_FALSE_r32 1258 +#define _POP_JUMP_IF_TRUE_r00 1259 +#define _POP_JUMP_IF_TRUE_r10 1260 +#define _POP_JUMP_IF_TRUE_r21 1261 +#define _POP_JUMP_IF_TRUE_r32 1262 +#define _POP_TOP_r10 1263 +#define _POP_TOP_FLOAT_r00 1264 +#define _POP_TOP_FLOAT_r10 1265 +#define _POP_TOP_FLOAT_r21 1266 +#define _POP_TOP_FLOAT_r32 1267 +#define _POP_TOP_INT_r00 1268 +#define _POP_TOP_INT_r10 1269 +#define _POP_TOP_INT_r21 1270 +#define _POP_TOP_INT_r32 1271 +#define _POP_TOP_LOAD_CONST_INLINE_r11 1272 +#define _POP_TOP_LOAD_CONST_INLINE_BORROW_r11 1273 +#define _POP_TOP_NOP_r00 1274 +#define _POP_TOP_NOP_r10 1275 +#define _POP_TOP_NOP_r21 1276 +#define _POP_TOP_NOP_r32 1277 +#define _POP_TOP_UNICODE_r00 1278 +#define _POP_TOP_UNICODE_r10 1279 +#define _POP_TOP_UNICODE_r21 1280 +#define _POP_TOP_UNICODE_r32 1281 +#define _POP_TWO_r20 1282 +#define _POP_TWO_LOAD_CONST_INLINE_BORROW_r21 1283 +#define _PUSH_EXC_INFO_r02 1284 +#define _PUSH_EXC_INFO_r12 1285 +#define _PUSH_EXC_INFO_r23 1286 +#define _PUSH_FRAME_r10 1287 +#define _PUSH_NULL_r01 1288 +#define _PUSH_NULL_r12 1289 +#define _PUSH_NULL_r23 1290 +#define _PUSH_NULL_CONDITIONAL_r00 1291 +#define _PY_FRAME_EX_r31 1292 +#define _PY_FRAME_GENERAL_r01 1293 +#define _PY_FRAME_KW_r11 1294 +#define _QUICKEN_RESUME_r00 1295 +#define _QUICKEN_RESUME_r11 1296 +#define _QUICKEN_RESUME_r22 1297 +#define _QUICKEN_RESUME_r33 1298 +#define _REPLACE_WITH_TRUE_r02 1299 +#define _REPLACE_WITH_TRUE_r12 1300 +#define _REPLACE_WITH_TRUE_r23 1301 +#define _RESUME_CHECK_r00 1302 +#define _RESUME_CHECK_r11 1303 +#define _RESUME_CHECK_r22 1304 +#define _RESUME_CHECK_r33 1305 +#define _RETURN_GENERATOR_r01 1306 +#define _RETURN_VALUE_r11 1307 +#define _SAVE_RETURN_OFFSET_r00 1308 +#define _SAVE_RETURN_OFFSET_r11 1309 +#define _SAVE_RETURN_OFFSET_r22 1310 +#define _SAVE_RETURN_OFFSET_r33 1311 +#define _SEND_r22 1312 +#define _SEND_GEN_FRAME_r22 1313 +#define _SETUP_ANNOTATIONS_r00 1314 +#define _SET_ADD_r10 1315 +#define _SET_FUNCTION_ATTRIBUTE_r01 1316 +#define _SET_FUNCTION_ATTRIBUTE_r11 1317 +#define _SET_FUNCTION_ATTRIBUTE_r21 1318 +#define _SET_FUNCTION_ATTRIBUTE_r32 1319 +#define _SET_IP_r00 1320 +#define _SET_IP_r11 1321 +#define _SET_IP_r22 1322 +#define _SET_IP_r33 1323 +#define _SET_UPDATE_r10 1324 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r02 1325 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12 1326 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22 1327 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32 1328 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03 1329 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13 1330 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23 1331 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33 1332 +#define _SPILL_OR_RELOAD_r01 1333 +#define _SPILL_OR_RELOAD_r02 1334 +#define _SPILL_OR_RELOAD_r03 1335 +#define _SPILL_OR_RELOAD_r10 1336 +#define _SPILL_OR_RELOAD_r12 1337 +#define _SPILL_OR_RELOAD_r13 1338 +#define _SPILL_OR_RELOAD_r20 1339 +#define _SPILL_OR_RELOAD_r21 1340 +#define _SPILL_OR_RELOAD_r23 1341 +#define _SPILL_OR_RELOAD_r30 1342 +#define _SPILL_OR_RELOAD_r31 1343 +#define _SPILL_OR_RELOAD_r32 1344 +#define _START_EXECUTOR_r00 1345 +#define _STORE_ATTR_r20 1346 +#define _STORE_ATTR_INSTANCE_VALUE_r21 1347 +#define _STORE_ATTR_INSTANCE_VALUE_NULL_r01 1348 +#define _STORE_ATTR_INSTANCE_VALUE_NULL_r11 1349 +#define _STORE_ATTR_INSTANCE_VALUE_NULL_r21 1350 +#define _STORE_ATTR_INSTANCE_VALUE_NULL_r32 1351 +#define _STORE_ATTR_SLOT_r21 1352 +#define _STORE_ATTR_SLOT_NULL_r01 1353 +#define _STORE_ATTR_SLOT_NULL_r11 1354 +#define _STORE_ATTR_SLOT_NULL_r21 1355 +#define _STORE_ATTR_SLOT_NULL_r32 1356 +#define _STORE_ATTR_WITH_HINT_r21 1357 +#define _STORE_DEREF_r10 1358 +#define _STORE_FAST_LOAD_FAST_r11 1359 +#define _STORE_FAST_STORE_FAST_r20 1360 +#define _STORE_GLOBAL_r10 1361 +#define _STORE_NAME_r10 1362 +#define _STORE_SLICE_r30 1363 +#define _STORE_SUBSCR_r30 1364 +#define _STORE_SUBSCR_DICT_r31 1365 +#define _STORE_SUBSCR_LIST_INT_r32 1366 +#define _SWAP_r11 1367 +#define _SWAP_2_r02 1368 +#define _SWAP_2_r12 1369 +#define _SWAP_2_r22 1370 +#define _SWAP_2_r33 1371 +#define _SWAP_3_r03 1372 +#define _SWAP_3_r13 1373 +#define _SWAP_3_r23 1374 +#define _SWAP_3_r33 1375 +#define _SWAP_FAST_r01 1376 +#define _SWAP_FAST_r11 1377 +#define _SWAP_FAST_r22 1378 +#define _SWAP_FAST_r33 1379 +#define _SWAP_FAST_0_r01 1380 +#define _SWAP_FAST_0_r11 1381 +#define _SWAP_FAST_0_r22 1382 +#define _SWAP_FAST_0_r33 1383 +#define _SWAP_FAST_1_r01 1384 +#define _SWAP_FAST_1_r11 1385 +#define _SWAP_FAST_1_r22 1386 +#define _SWAP_FAST_1_r33 1387 +#define _SWAP_FAST_2_r01 1388 +#define _SWAP_FAST_2_r11 1389 +#define _SWAP_FAST_2_r22 1390 +#define _SWAP_FAST_2_r33 1391 +#define _SWAP_FAST_3_r01 1392 +#define _SWAP_FAST_3_r11 1393 +#define _SWAP_FAST_3_r22 1394 +#define _SWAP_FAST_3_r33 1395 +#define _SWAP_FAST_4_r01 1396 +#define _SWAP_FAST_4_r11 1397 +#define _SWAP_FAST_4_r22 1398 +#define _SWAP_FAST_4_r33 1399 +#define _SWAP_FAST_5_r01 1400 +#define _SWAP_FAST_5_r11 1401 +#define _SWAP_FAST_5_r22 1402 +#define _SWAP_FAST_5_r33 1403 +#define _SWAP_FAST_6_r01 1404 +#define _SWAP_FAST_6_r11 1405 +#define _SWAP_FAST_6_r22 1406 +#define _SWAP_FAST_6_r33 1407 +#define _SWAP_FAST_7_r01 1408 +#define _SWAP_FAST_7_r11 1409 +#define _SWAP_FAST_7_r22 1410 +#define _SWAP_FAST_7_r33 1411 +#define _TIER2_RESUME_CHECK_r00 1412 +#define _TIER2_RESUME_CHECK_r11 1413 +#define _TIER2_RESUME_CHECK_r22 1414 +#define _TIER2_RESUME_CHECK_r33 1415 +#define _TO_BOOL_r11 1416 +#define _TO_BOOL_BOOL_r01 1417 +#define _TO_BOOL_BOOL_r11 1418 +#define _TO_BOOL_BOOL_r22 1419 +#define _TO_BOOL_BOOL_r33 1420 +#define _TO_BOOL_INT_r02 1421 +#define _TO_BOOL_INT_r12 1422 +#define _TO_BOOL_INT_r23 1423 +#define _TO_BOOL_LIST_r02 1424 +#define _TO_BOOL_LIST_r12 1425 +#define _TO_BOOL_LIST_r23 1426 +#define _TO_BOOL_NONE_r01 1427 +#define _TO_BOOL_NONE_r11 1428 +#define _TO_BOOL_NONE_r22 1429 +#define _TO_BOOL_NONE_r33 1430 +#define _TO_BOOL_STR_r02 1431 +#define _TO_BOOL_STR_r12 1432 +#define _TO_BOOL_STR_r23 1433 +#define _TRACE_RECORD_r00 1434 +#define _UNARY_INVERT_r12 1435 +#define _UNARY_NEGATIVE_r12 1436 +#define _UNARY_NOT_r01 1437 +#define _UNARY_NOT_r11 1438 +#define _UNARY_NOT_r22 1439 +#define _UNARY_NOT_r33 1440 +#define _UNPACK_EX_r10 1441 +#define _UNPACK_SEQUENCE_r10 1442 +#define _UNPACK_SEQUENCE_LIST_r10 1443 +#define _UNPACK_SEQUENCE_TUPLE_r10 1444 +#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1445 +#define _WITH_EXCEPT_START_r33 1446 +#define _YIELD_VALUE_r11 1447 +#define MAX_UOP_REGS_ID 1447 #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 07c4f0aeb4a95d..d19f219c165324 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -201,8 +201,10 @@ const uint32_t _PyUop_Flags[MAX_UOP_ID+1] = { [_LOAD_ATTR_PROPERTY_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_GUARD_DORV_NO_DICT] = HAS_EXIT_FLAG, [_STORE_ATTR_INSTANCE_VALUE] = HAS_ESCAPES_FLAG, + [_STORE_ATTR_INSTANCE_VALUE_NULL] = HAS_DEOPT_FLAG, [_STORE_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_STORE_ATTR_SLOT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_STORE_ATTR_SLOT_NULL] = HAS_DEOPT_FLAG, [_COMPARE_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_COMPARE_OP_FLOAT] = HAS_ARG_FLAG, [_COMPARE_OP_INT] = HAS_ARG_FLAG, @@ -1883,6 +1885,15 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { { -1, -1, -1 }, }, }, + [_STORE_ATTR_INSTANCE_VALUE_NULL] = { + .best = { 0, 1, 2, 3 }, + .entries = { + { 1, 0, _STORE_ATTR_INSTANCE_VALUE_NULL_r01 }, + { 1, 1, _STORE_ATTR_INSTANCE_VALUE_NULL_r11 }, + { 1, 2, _STORE_ATTR_INSTANCE_VALUE_NULL_r21 }, + { 2, 3, _STORE_ATTR_INSTANCE_VALUE_NULL_r32 }, + }, + }, [_STORE_ATTR_WITH_HINT] = { .best = { 2, 2, 2, 2 }, .entries = { @@ -1901,6 +1912,15 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { { -1, -1, -1 }, }, }, + [_STORE_ATTR_SLOT_NULL] = { + .best = { 0, 1, 2, 3 }, + .entries = { + { 1, 0, _STORE_ATTR_SLOT_NULL_r01 }, + { 1, 1, _STORE_ATTR_SLOT_NULL_r11 }, + { 1, 2, _STORE_ATTR_SLOT_NULL_r21 }, + { 2, 3, _STORE_ATTR_SLOT_NULL_r32 }, + }, + }, [_COMPARE_OP] = { .best = { 2, 2, 2, 2 }, .entries = { @@ -3815,8 +3835,16 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_GUARD_DORV_NO_DICT_r22] = _GUARD_DORV_NO_DICT, [_GUARD_DORV_NO_DICT_r33] = _GUARD_DORV_NO_DICT, [_STORE_ATTR_INSTANCE_VALUE_r21] = _STORE_ATTR_INSTANCE_VALUE, + [_STORE_ATTR_INSTANCE_VALUE_NULL_r01] = _STORE_ATTR_INSTANCE_VALUE_NULL, + [_STORE_ATTR_INSTANCE_VALUE_NULL_r11] = _STORE_ATTR_INSTANCE_VALUE_NULL, + [_STORE_ATTR_INSTANCE_VALUE_NULL_r21] = _STORE_ATTR_INSTANCE_VALUE_NULL, + [_STORE_ATTR_INSTANCE_VALUE_NULL_r32] = _STORE_ATTR_INSTANCE_VALUE_NULL, [_STORE_ATTR_WITH_HINT_r21] = _STORE_ATTR_WITH_HINT, [_STORE_ATTR_SLOT_r21] = _STORE_ATTR_SLOT, + [_STORE_ATTR_SLOT_NULL_r01] = _STORE_ATTR_SLOT_NULL, + [_STORE_ATTR_SLOT_NULL_r11] = _STORE_ATTR_SLOT_NULL, + [_STORE_ATTR_SLOT_NULL_r21] = _STORE_ATTR_SLOT_NULL, + [_STORE_ATTR_SLOT_NULL_r32] = _STORE_ATTR_SLOT_NULL, [_COMPARE_OP_r21] = _COMPARE_OP, [_COMPARE_OP_FLOAT_r03] = _COMPARE_OP_FLOAT, [_COMPARE_OP_FLOAT_r13] = _COMPARE_OP_FLOAT, @@ -5234,8 +5262,18 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_STORE_ATTR_r20] = "_STORE_ATTR_r20", [_STORE_ATTR_INSTANCE_VALUE] = "_STORE_ATTR_INSTANCE_VALUE", [_STORE_ATTR_INSTANCE_VALUE_r21] = "_STORE_ATTR_INSTANCE_VALUE_r21", + [_STORE_ATTR_INSTANCE_VALUE_NULL] = "_STORE_ATTR_INSTANCE_VALUE_NULL", + [_STORE_ATTR_INSTANCE_VALUE_NULL_r01] = "_STORE_ATTR_INSTANCE_VALUE_NULL_r01", + [_STORE_ATTR_INSTANCE_VALUE_NULL_r11] = "_STORE_ATTR_INSTANCE_VALUE_NULL_r11", + [_STORE_ATTR_INSTANCE_VALUE_NULL_r21] = "_STORE_ATTR_INSTANCE_VALUE_NULL_r21", + [_STORE_ATTR_INSTANCE_VALUE_NULL_r32] = "_STORE_ATTR_INSTANCE_VALUE_NULL_r32", [_STORE_ATTR_SLOT] = "_STORE_ATTR_SLOT", [_STORE_ATTR_SLOT_r21] = "_STORE_ATTR_SLOT_r21", + [_STORE_ATTR_SLOT_NULL] = "_STORE_ATTR_SLOT_NULL", + [_STORE_ATTR_SLOT_NULL_r01] = "_STORE_ATTR_SLOT_NULL_r01", + [_STORE_ATTR_SLOT_NULL_r11] = "_STORE_ATTR_SLOT_NULL_r11", + [_STORE_ATTR_SLOT_NULL_r21] = "_STORE_ATTR_SLOT_NULL_r21", + [_STORE_ATTR_SLOT_NULL_r32] = "_STORE_ATTR_SLOT_NULL_r32", [_STORE_ATTR_WITH_HINT] = "_STORE_ATTR_WITH_HINT", [_STORE_ATTR_WITH_HINT_r21] = "_STORE_ATTR_WITH_HINT_r21", [_STORE_DEREF] = "_STORE_DEREF", @@ -5697,10 +5735,14 @@ int _PyUop_num_popped(int opcode, int oparg) return 0; case _STORE_ATTR_INSTANCE_VALUE: return 2; + case _STORE_ATTR_INSTANCE_VALUE_NULL: + return 2; case _STORE_ATTR_WITH_HINT: return 2; case _STORE_ATTR_SLOT: return 2; + case _STORE_ATTR_SLOT_NULL: + return 2; case _COMPARE_OP: return 2; case _COMPARE_OP_FLOAT: diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-01-30-09-47-29.gh-issue-144145.mxJyUj.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-01-30-09-47-29.gh-issue-144145.mxJyUj.rst new file mode 100644 index 00000000000000..561cda687064be --- /dev/null +++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-01-30-09-47-29.gh-issue-144145.mxJyUj.rst @@ -0,0 +1 @@ +Track nullness of attributes of objects in the JIT optimizer. Patch by Hai Zhu. diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 4c808016a00cb6..8bc58240e908a7 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -2671,6 +2671,23 @@ dummy_func( Py_XDECREF(old_value); } + op(_STORE_ATTR_INSTANCE_VALUE_NULL, (offset/1, value, owner -- o)) { + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + + STAT_INC(STORE_ATTR, hit); + assert(_PyObject_GetManagedDict(owner_o) == NULL); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *old_value = *value_ptr; + DEOPT_IF(old_value != NULL); + FT_ATOMIC_STORE_PTR_RELEASE(*value_ptr, PyStackRef_AsPyObjectSteal(value)); + PyDictValues *values = _PyObject_InlineValues(owner_o); + Py_ssize_t index = value_ptr - values->values; + _PyDictValues_AddToInsertionOrder(values, index); + UNLOCK_OBJECT(owner_o); + INPUTS_DEAD(); + o = owner; + } + macro(STORE_ATTR_INSTANCE_VALUE) = unused/1 + _GUARD_TYPE_VERSION_AND_LOCK + @@ -2733,6 +2750,20 @@ dummy_func( Py_XDECREF(old_value); } + op(_STORE_ATTR_SLOT_NULL, (index/1, value, owner -- o)) { + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + + DEOPT_IF(!LOCK_OBJECT(owner_o)); + char *addr = (char *)owner_o + index; + STAT_INC(STORE_ATTR, hit); + PyObject *old_value = *(PyObject **)addr; + DEOPT_IF(old_value != NULL); + FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value)); + UNLOCK_OBJECT(owner_o); + INPUTS_DEAD(); + o = owner; + } + macro(STORE_ATTR_SLOT) = unused/1 + _GUARD_TYPE_VERSION + diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 8901c259525081..1a705098472425 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -9782,6 +9782,147 @@ break; } + case _STORE_ATTR_INSTANCE_VALUE_NULL_r01: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + owner = stack_pointer[-1]; + value = stack_pointer[-2]; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + STAT_INC(STORE_ATTR, hit); + assert(_PyObject_GetManagedDict(owner_o) == NULL); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *old_value = *value_ptr; + if (old_value != NULL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + FT_ATOMIC_STORE_PTR_RELEASE(*value_ptr, PyStackRef_AsPyObjectSteal(value)); + PyDictValues *values = _PyObject_InlineValues(owner_o); + Py_ssize_t index = value_ptr - values->values; + _PyDictValues_AddToInsertionOrder(values, index); + UNLOCK_OBJECT(owner_o); + o = owner; + _tos_cache0 = o; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _STORE_ATTR_INSTANCE_VALUE_NULL_r11: { + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + value = stack_pointer[-1]; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + STAT_INC(STORE_ATTR, hit); + assert(_PyObject_GetManagedDict(owner_o) == NULL); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *old_value = *value_ptr; + if (old_value != NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + FT_ATOMIC_STORE_PTR_RELEASE(*value_ptr, PyStackRef_AsPyObjectSteal(value)); + PyDictValues *values = _PyObject_InlineValues(owner_o); + Py_ssize_t index = value_ptr - values->values; + _PyDictValues_AddToInsertionOrder(values, index); + UNLOCK_OBJECT(owner_o); + o = owner; + _tos_cache0 = o; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _STORE_ATTR_INSTANCE_VALUE_NULL_r21: { + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + value = _stack_item_0; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + STAT_INC(STORE_ATTR, hit); + assert(_PyObject_GetManagedDict(owner_o) == NULL); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *old_value = *value_ptr; + if (old_value != NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + FT_ATOMIC_STORE_PTR_RELEASE(*value_ptr, PyStackRef_AsPyObjectSteal(value)); + PyDictValues *values = _PyObject_InlineValues(owner_o); + Py_ssize_t index = value_ptr - values->values; + _PyDictValues_AddToInsertionOrder(values, index); + UNLOCK_OBJECT(owner_o); + o = owner; + _tos_cache0 = o; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _STORE_ATTR_INSTANCE_VALUE_NULL_r32: { + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + value = _stack_item_1; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + STAT_INC(STORE_ATTR, hit); + assert(_PyObject_GetManagedDict(owner_o) == NULL); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *old_value = *value_ptr; + if (old_value != NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + FT_ATOMIC_STORE_PTR_RELEASE(*value_ptr, PyStackRef_AsPyObjectSteal(value)); + PyDictValues *values = _PyObject_InlineValues(owner_o); + Py_ssize_t index = value_ptr - values->values; + _PyDictValues_AddToInsertionOrder(values, index); + UNLOCK_OBJECT(owner_o); + o = owner; + _tos_cache1 = o; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + case _STORE_ATTR_WITH_HINT_r21: { CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); @@ -9914,6 +10055,157 @@ break; } + case _STORE_ATTR_SLOT_NULL_r01: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + owner = stack_pointer[-1]; + value = stack_pointer[-2]; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + char *addr = (char *)owner_o + index; + STAT_INC(STORE_ATTR, hit); + PyObject *old_value = *(PyObject **)addr; + if (old_value != NULL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value)); + UNLOCK_OBJECT(owner_o); + o = owner; + _tos_cache0 = o; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _STORE_ATTR_SLOT_NULL_r11: { + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + value = stack_pointer[-1]; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + char *addr = (char *)owner_o + index; + STAT_INC(STORE_ATTR, hit); + PyObject *old_value = *(PyObject **)addr; + if (old_value != NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value)); + UNLOCK_OBJECT(owner_o); + o = owner; + _tos_cache0 = o; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _STORE_ATTR_SLOT_NULL_r21: { + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + value = _stack_item_0; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + char *addr = (char *)owner_o + index; + STAT_INC(STORE_ATTR, hit); + PyObject *old_value = *(PyObject **)addr; + if (old_value != NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value)); + UNLOCK_OBJECT(owner_o); + o = owner; + _tos_cache0 = o; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _STORE_ATTR_SLOT_NULL_r32: { + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + value = _stack_item_1; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + char *addr = (char *)owner_o + index; + STAT_INC(STORE_ATTR, hit); + PyObject *old_value = *(PyObject **)addr; + if (old_value != NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value)); + UNLOCK_OBJECT(owner_o); + o = owner; + _tos_cache1 = o; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + case _COMPARE_OP_r21: { CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); diff --git a/Python/optimizer_analysis.c b/Python/optimizer_analysis.c index 039aacf23ae3a3..0a1f2672f4b6a0 100644 --- a/Python/optimizer_analysis.c +++ b/Python/optimizer_analysis.c @@ -269,6 +269,9 @@ add_op(JitOptContext *ctx, _PyUOpInstruction *this_instr, #define sym_is_compact_int _Py_uop_sym_is_compact_int #define sym_new_compact_int _Py_uop_sym_new_compact_int #define sym_new_truthiness _Py_uop_sym_new_truthiness +#define sym_new_descr_object _Py_uop_sym_new_descr_object +#define sym_get_attr _Py_uop_sym_get_attr +#define sym_set_attr _Py_uop_sym_set_attr #define sym_new_predicate _Py_uop_sym_new_predicate #define sym_apply_predicate_narrowing _Py_uop_sym_apply_predicate_narrowing @@ -503,7 +506,6 @@ optimize_uops( int oparg = this_instr->oparg; opcode = this_instr->opcode; - if (!CURRENT_FRAME_IS_INIT_SHIM()) { stack_pointer = ctx->frame->stack_pointer; } @@ -524,9 +526,15 @@ optimize_uops( if (ctx->out_buffer.next == out_ptr) { *(ctx->out_buffer.next++) = *this_instr; } + // Track escapes - but skip when from init shim frame, since self hasn't escaped yet + bool is_init_shim = CURRENT_FRAME_IS_INIT_SHIM(); + if ((_PyUop_Flags[out_ptr->opcode] & HAS_ESCAPES_FLAG) && !is_init_shim) + { + ctx->last_escape_index = uop_buffer_length(&ctx->out_buffer) - 1; + } assert(ctx->frame != NULL); DUMP_UOP(ctx, "out", uop_buffer_length(&ctx->out_buffer) - 1, out_ptr, stack_pointer); - if (!CURRENT_FRAME_IS_INIT_SHIM() && !ctx->done) { + if (!is_init_shim && !ctx->done) { DPRINTF(3, " stack_level %d\n", STACK_LEVEL()); ctx->frame->stack_pointer = stack_pointer; assert(STACK_LEVEL() >= 0); diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index 5a3480ab31676b..4ccecd472b36da 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -38,6 +38,9 @@ typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame; #define sym_new_compact_int _Py_uop_sym_new_compact_int #define sym_is_compact_int _Py_uop_sym_is_compact_int #define sym_new_truthiness _Py_uop_sym_new_truthiness +#define sym_new_descr_object _Py_uop_sym_new_descr_object +#define sym_get_attr _Py_uop_sym_get_attr +#define sym_set_attr _Py_uop_sym_set_attr #define sym_new_predicate _Py_uop_sym_new_predicate #define sym_apply_predicate_narrowing _Py_uop_sym_apply_predicate_narrowing @@ -103,6 +106,14 @@ dummy_func(void) { } op(_STORE_ATTR_INSTANCE_VALUE, (offset/1, value, owner -- o)) { + JitOptRef old_value = sym_set_attr(ctx, owner, (uint16_t)offset, value); + if (sym_is_null(old_value)) { + ADD_OP(_STORE_ATTR_INSTANCE_VALUE_NULL, 0, offset); + } + o = owner; + } + + op(_STORE_ATTR_INSTANCE_VALUE_NULL, (offset/1, value, owner -- o)) { (void)value; o = owner; } @@ -125,7 +136,14 @@ dummy_func(void) { } op(_STORE_ATTR_SLOT, (index/1, value, owner -- o)) { - (void)index; + JitOptRef old_value = sym_set_attr(ctx, owner, (uint16_t)index, value); + if (sym_is_null(old_value)) { + ADD_OP(_STORE_ATTR_SLOT_NULL, 0, index); + } + o = owner; + } + + op(_STORE_ATTR_SLOT_NULL, (index/1, value, owner -- o)) { (void)value; o = owner; } @@ -749,8 +767,7 @@ dummy_func(void) { } op(_LOAD_ATTR_SLOT, (index/1, owner -- attr, o)) { - attr = sym_new_not_null(ctx); - (void)index; + attr = sym_get_attr(ctx, owner, (uint16_t)index); o = owner; } @@ -934,10 +951,14 @@ dummy_func(void) { } op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable, self_or_null, args[oparg] -- callable, self_or_null, args[oparg])) { - (void)type_version; (void)args; callable = sym_new_not_null(ctx); - self_or_null = sym_new_not_null(ctx); + PyTypeObject *tp = _PyType_LookupByVersion(type_version); + if (tp != NULL) { + self_or_null = sym_new_descr_object(ctx, type_version); + } else { + self_or_null = sym_new_not_null(ctx); + } } op(_CREATE_INIT_FRAME, (init, self, args[oparg] -- init_frame)) { diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 9dc1da3c93bb69..4a6f2450680bf9 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -1936,8 +1936,7 @@ JitOptRef o; owner = stack_pointer[-1]; uint16_t index = (uint16_t)this_instr->operand0; - attr = sym_new_not_null(ctx); - (void)index; + attr = sym_get_attr(ctx, owner, (uint16_t)index); o = owner; CHECK_STACK_BOUNDS(1); stack_pointer[-1] = attr; @@ -2006,6 +2005,25 @@ } case _STORE_ATTR_INSTANCE_VALUE: { + JitOptRef owner; + JitOptRef value; + JitOptRef o; + owner = stack_pointer[-1]; + value = stack_pointer[-2]; + uint16_t offset = (uint16_t)this_instr->operand0; + JitOptRef old_value = sym_set_attr(ctx, owner, (uint16_t)offset, value); + if (sym_is_null(old_value)) { + ADD_OP(_STORE_ATTR_INSTANCE_VALUE_NULL, 0, offset); + } + o = owner; + CHECK_STACK_BOUNDS(-1); + stack_pointer[-2] = o; + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + break; + } + + case _STORE_ATTR_INSTANCE_VALUE_NULL: { JitOptRef owner; JitOptRef value; JitOptRef o; @@ -2044,7 +2062,25 @@ owner = stack_pointer[-1]; value = stack_pointer[-2]; uint16_t index = (uint16_t)this_instr->operand0; - (void)index; + JitOptRef old_value = sym_set_attr(ctx, owner, (uint16_t)index, value); + if (sym_is_null(old_value)) { + ADD_OP(_STORE_ATTR_SLOT_NULL, 0, index); + } + o = owner; + CHECK_STACK_BOUNDS(-1); + stack_pointer[-2] = o; + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + break; + } + + case _STORE_ATTR_SLOT_NULL: { + JitOptRef owner; + JitOptRef value; + JitOptRef o; + owner = stack_pointer[-1]; + value = stack_pointer[-2]; + uint16_t index = (uint16_t)this_instr->operand0; (void)value; o = owner; CHECK_STACK_BOUNDS(-1); @@ -3192,11 +3228,15 @@ self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; uint32_t type_version = (uint32_t)this_instr->operand0; - (void)type_version; (void)args; callable = sym_new_not_null(ctx); - self_or_null = sym_new_not_null(ctx); stack_pointer[-2 - oparg] = callable; + PyTypeObject *tp = _PyType_LookupByVersion(type_version); + if (tp != NULL) { + self_or_null = sym_new_descr_object(ctx, type_version); + } else { + self_or_null = sym_new_not_null(ctx); + } stack_pointer[-1 - oparg] = self_or_null; break; } diff --git a/Python/optimizer_symbols.c b/Python/optimizer_symbols.c index 51cf6e189f0f49..ff94807c6db1c5 100644 --- a/Python/optimizer_symbols.c +++ b/Python/optimizer_symbols.c @@ -113,6 +113,15 @@ _PyUOpSymPrint(JitOptRef ref) case JIT_SYM_COMPACT_INT: printf("<compact_int at %p>", (void *)sym); break; + case JIT_SYM_DESCR_TAG: { + PyTypeObject *descr_type = _PyType_LookupByVersion(sym->descr.type_version); + if (descr_type) { + printf("<%s descr[%d] v%u at %p>", descr_type->tp_name, sym->descr.num_descrs, sym->descr.type_version, (void *)sym); + } else { + printf("<descr[%d] v%u at %p>", sym->descr.num_descrs, sym->descr.type_version, (void *)sym); + } + break; + } default: printf("<tag=%d at %p>", sym->tag, (void *)sym); break; @@ -320,6 +329,11 @@ _Py_uop_sym_set_type(JitOptContext *ctx, JitOptRef ref, PyTypeObject *typ) sym_set_bottom(ctx, sym); } return; + case JIT_SYM_DESCR_TAG: + if (typ->tp_version_tag != sym->descr.type_version) { + sym_set_bottom(ctx, sym); + } + return; } } @@ -384,6 +398,12 @@ _Py_uop_sym_set_type_version(JitOptContext *ctx, JitOptRef ref, unsigned int ver return false; } return true; + case JIT_SYM_DESCR_TAG: + if (version != sym->descr.type_version) { + sym_set_bottom(ctx, sym); + return false; + } + return true; } Py_UNREACHABLE(); } @@ -483,6 +503,9 @@ _Py_uop_sym_set_const(JitOptContext *ctx, JitOptRef ref, PyObject *const_val) sym_set_bottom(ctx, sym); } return; + case JIT_SYM_DESCR_TAG: + sym_set_bottom(ctx, sym); + return; } } @@ -603,7 +626,8 @@ _Py_uop_sym_get_type(JitOptRef ref) return &PyBool_Type; case JIT_SYM_COMPACT_INT: return &PyLong_Type; - + case JIT_SYM_DESCR_TAG: + return _PyType_LookupByVersion(sym->descr.type_version); } Py_UNREACHABLE(); } @@ -632,6 +656,8 @@ _Py_uop_sym_get_type_version(JitOptRef ref) return PyBool_Type.tp_version_tag; case JIT_SYM_COMPACT_INT: return PyLong_Type.tp_version_tag; + case JIT_SYM_DESCR_TAG: + return sym->descr.type_version; } Py_UNREACHABLE(); } @@ -666,6 +692,7 @@ _Py_uop_sym_truthiness(JitOptContext *ctx, JitOptRef ref) case JIT_SYM_NON_NULL_TAG: case JIT_SYM_UNKNOWN_TAG: case JIT_SYM_COMPACT_INT: + case JIT_SYM_DESCR_TAG: return -1; case JIT_SYM_KNOWN_CLASS_TAG: /* TODO : @@ -823,6 +850,7 @@ _Py_uop_sym_set_compact_int(JitOptContext *ctx, JitOptRef ref) case JIT_SYM_TUPLE_TAG: case JIT_SYM_PREDICATE_TAG: case JIT_SYM_TRUTHINESS_TAG: + case JIT_SYM_DESCR_TAG: sym_set_bottom(ctx, sym); return; case JIT_SYM_BOTTOM_TAG: @@ -937,6 +965,116 @@ _Py_uop_sym_new_compact_int(JitOptContext *ctx) return PyJitRef_Wrap(sym); } +JitOptRef +_Py_uop_sym_new_descr_object(JitOptContext *ctx, unsigned int type_version) +{ + JitOptSymbol *res = sym_new(ctx); + if (res == NULL) { + return out_of_space_ref(ctx); + } + res->tag = JIT_SYM_DESCR_TAG; + res->descr.num_descrs = 0; + res->descr.descrs = NULL; + res->descr.type_version = type_version; + res->descr.last_modified_index = uop_buffer_length(&ctx->out_buffer); + return PyJitRef_Wrap(res); +} + +JitOptRef +_Py_uop_sym_get_attr(JitOptContext *ctx, JitOptRef ref, uint16_t slot_index) +{ + JitOptSymbol *sym = PyJitRef_Unwrap(ref); + + switch (sym->tag) { + case JIT_SYM_DESCR_TAG: + // Only return tracked slot values if: + // 1. Symbol has mappings allocated + // 2. No escape has occurred since last modification (state is fresh) + if (sym->descr.descrs != NULL && + sym->descr.last_modified_index >= ctx->last_escape_index) + { + for (int i = 0; i < sym->descr.num_descrs; i++) { + if (sym->descr.descrs[i].slot_index == slot_index) { + return PyJitRef_Wrap(allocation_base(ctx) + sym->descr.descrs[i].symbol); + } + } + } + break; + default: + break; + } + + return _Py_uop_sym_new_not_null(ctx); +} + +static JitOptDescrMapping * +descr_arena_alloc(JitOptContext *ctx) +{ + if (ctx->d_arena.descr_curr_number + MAX_SYMBOLIC_DESCR_SIZE > ctx->d_arena.descr_max_number) { + return NULL; + } + JitOptDescrMapping *descrs = &ctx->d_arena.arena[ctx->d_arena.descr_curr_number]; + ctx->d_arena.descr_curr_number += MAX_SYMBOLIC_DESCR_SIZE; + return descrs; +} + +JitOptRef +_Py_uop_sym_set_attr(JitOptContext *ctx, JitOptRef ref, uint16_t slot_index, JitOptRef value) +{ + JitOptSymbol *sym = PyJitRef_Unwrap(ref); + int curr_index = uop_buffer_length(&ctx->out_buffer); + + switch (sym->tag) { + case JIT_SYM_DESCR_TAG: + break; + default: + return _Py_uop_sym_new_not_null(ctx); + } + + // Check escape + if (sym->descr.last_modified_index < ctx->last_escape_index) { + sym->descr.num_descrs = 0; + } + + // Get old value before updating + JitOptRef old_value = PyJitRef_NULL; + if (sym->descr.descrs != NULL) { + for (int i = 0; i < sym->descr.num_descrs; i++) { + if (sym->descr.descrs[i].slot_index == slot_index) { + old_value = PyJitRef_Wrap(allocation_base(ctx) + sym->descr.descrs[i].symbol); + break; + } + } + } + + // Update the last modified timestamp + sym->descr.last_modified_index = curr_index; + + // Check if have arena space allocated + if (sym->descr.descrs == NULL) { + sym->descr.descrs = descr_arena_alloc(ctx); + if (sym->descr.descrs == NULL) { + return PyJitRef_IsNull(old_value) ? _Py_uop_sym_new_not_null(ctx) : old_value; + } + } + // Check if the slot already exists + for (int i = 0; i < sym->descr.num_descrs; i++) { + if (sym->descr.descrs[i].slot_index == slot_index) { + sym->descr.descrs[i].symbol = (uint16_t)(PyJitRef_Unwrap(value) - allocation_base(ctx)); + assert(!PyJitRef_IsNull(old_value)); + return old_value; + } + } + // Add new mapping if there's space + if (sym->descr.num_descrs < MAX_SYMBOLIC_DESCR_SIZE) { + int idx = sym->descr.num_descrs++; + sym->descr.descrs[idx].slot_index = slot_index; + sym->descr.descrs[idx].symbol = (uint16_t)(PyJitRef_Unwrap(value) - allocation_base(ctx)); + } + + return PyJitRef_IsNull(old_value) ? PyJitRef_Borrow(_Py_uop_sym_new_null(ctx)) : old_value; +} + // 0 on success, -1 on error. _Py_UOpsAbstractFrame * _Py_uop_frame_new( @@ -1026,6 +1164,10 @@ _Py_uop_abstractcontext_init(JitOptContext *ctx) ctx->t_arena.ty_curr_number = 0; ctx->t_arena.ty_max_number = TY_ARENA_SIZE; + // Setup the arena for descriptor mappings. + ctx->d_arena.descr_curr_number = 0; + ctx->d_arena.descr_max_number = DESCR_ARENA_SIZE; + // Frame setup ctx->curr_frame_depth = 0; @@ -1036,6 +1178,7 @@ _Py_uop_abstractcontext_init(JitOptContext *ctx) ctx->out_of_space = false; ctx->contradiction = false; ctx->builtins_watched = false; + ctx->last_escape_index = 0; } int @@ -1497,6 +1640,61 @@ _Py_uop_symbols_test(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored)) TEST_PREDICATE(_Py_uop_sym_matches_type(ref_int, &PyLong_Type), "43 is not an int"); TEST_PREDICATE(_Py_uop_sym_get_const(ctx, ref_int) == val_43, "43 isn't 43"); + JitOptRef descr_obj = _Py_uop_sym_new_descr_object(ctx, 42); + TEST_PREDICATE(!_Py_uop_sym_is_null(descr_obj), "descr object is NULL"); + TEST_PREDICATE(_Py_uop_sym_is_not_null(descr_obj), "descr object is not not-null"); + TEST_PREDICATE(_Py_uop_sym_get_type_version(descr_obj) == 42, + "descr object has wrong type version"); + + JitOptRef slot_val = _Py_uop_sym_new_const(ctx, val_42); + JitOptRef old_val = _Py_uop_sym_set_attr(ctx, descr_obj, 0, slot_val); + TEST_PREDICATE(_Py_uop_sym_is_null(old_val), "set_attr on new slot should return NULL"); + JitOptRef retrieved = _Py_uop_sym_get_attr(ctx, descr_obj, 0); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, retrieved) == val_42, + "descr getattr(0) didn't return val_42"); + + JitOptRef missing = _Py_uop_sym_get_attr(ctx, descr_obj, 99); + TEST_PREDICATE(_Py_uop_sym_is_not_null(missing), "missing slot is not not-null"); + TEST_PREDICATE(!_Py_uop_sym_is_const(ctx, missing), "missing slot is const"); + + JitOptRef slot_val2 = _Py_uop_sym_new_const(ctx, val_43); + old_val = _Py_uop_sym_set_attr(ctx, descr_obj, 0, slot_val2); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, old_val) == val_42, + "set_attr should return old value (val_42)"); + retrieved = _Py_uop_sym_get_attr(ctx, descr_obj, 0); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, retrieved) == val_43, + "descr getattr(0) didn't return val_43 after update"); + + // Test multiple slots + JitOptRef slot_val3 = _Py_uop_sym_new_const(ctx, val_42); + _Py_uop_sym_set_attr(ctx, descr_obj, 1, slot_val3); + retrieved = _Py_uop_sym_get_attr(ctx, descr_obj, 1); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, retrieved) == val_42, + "descr getattr(1) didn't return val_42"); + retrieved = _Py_uop_sym_get_attr(ctx, descr_obj, 0); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, retrieved) == val_43, + "descr getattr(0) changed unexpectedly"); + + // Test escape invalidation + JitOptRef descr_obj3 = _Py_uop_sym_new_descr_object(ctx, 100); + JitOptRef escape_val = _Py_uop_sym_new_const(ctx, val_42); + _Py_uop_sym_set_attr(ctx, descr_obj3, 0, escape_val); + retrieved = _Py_uop_sym_get_attr(ctx, descr_obj3, 0); + TEST_PREDICATE(_Py_uop_sym_get_const(ctx, retrieved) == val_42, + "descr getattr before escape didn't return val_42"); + // Simulate escape by setting last_escape_index higher + ctx->last_escape_index = INT_MAX; + retrieved = _Py_uop_sym_get_attr(ctx, descr_obj3, 0); + TEST_PREDICATE(!_Py_uop_sym_is_const(ctx, retrieved), + "descr getattr after escape should not return const"); + TEST_PREDICATE(_Py_uop_sym_is_not_null(retrieved), + "descr getattr after escape should return not-null"); + ctx->last_escape_index = 0; + + JitOptRef descr_obj2 = _Py_uop_sym_new_descr_object(ctx, 42); + _Py_uop_sym_set_type_version(ctx, descr_obj2, 43); + TEST_PREDICATE(_Py_uop_sym_is_bottom(descr_obj2), + "descr object with wrong type version isn't bottom"); _Py_uop_abstractcontext_fini(ctx); Py_DECREF(val_42); Py_DECREF(val_43);

1 0

gh-144342: Use `time.sleep` in `profiling.sampling` (#144343)
by pablogsal Jan. 30, 2026

Jan. 30, 2026

https://github.com/python/cpython/commit/be4ee8ee420adb211b77645f30ca1eb935… commit: be4ee8ee420adb211b77645f30ca1eb9356ed1c0 branch: main author: Maurycy Pawłowski-Wieroński <maurycy(a)maurycy.com> committer: pablogsal <Pablogsal(a)gmail.com> date: 2026-01-30T15:13:21Z summary: gh-144342: Use `time.sleep` in `profiling.sampling` (#144343) files: M Lib/profiling/sampling/sample.py diff --git a/Lib/profiling/sampling/sample.py b/Lib/profiling/sampling/sample.py index f657849e72bb62..c6abfb1c8ee885 100644 --- a/Lib/profiling/sampling/sample.py +++ b/Lib/profiling/sampling/sample.py @@ -100,7 +100,11 @@ def sample(self, collector, duration_sec=None, *, async_aware=False): break current_time = time.perf_counter() - if next_time < current_time: + if next_time > current_time: + sleep_time = (next_time - current_time) * 0.9 + if sleep_time > 0.0001: + time.sleep(sleep_time) + elif next_time < current_time: try: with _pause_threads(self.unwinder, self.blocking): if async_aware == "all":

1 0

gh-143423: Fix free-threaded build detection in sampling profiler (#143426)
by pablogsal Jan. 30, 2026

Jan. 30, 2026

https://github.com/python/cpython/commit/5f57f6970bdea45cc2b192d612bfd8199f… commit: 5f57f6970bdea45cc2b192d612bfd8199f51491e branch: main author: Divyanshu Choudhury <divyanshuchoudhury3(a)gmail.com> committer: pablogsal <Pablogsal(a)gmail.com> date: 2026-01-30T00:35:30Z summary: gh-143423: Fix free-threaded build detection in sampling profiler (#143426) files: A Misc/NEWS.d/next/Library/2026-01-05-05-31-05.gh-issue-143423.X7YdnR.rst M Lib/profiling/sampling/sample.py diff --git a/Lib/profiling/sampling/sample.py b/Lib/profiling/sampling/sample.py index e73306ebf290e7..f657849e72bb62 100644 --- a/Lib/profiling/sampling/sample.py +++ b/Lib/profiling/sampling/sample.py @@ -42,6 +42,7 @@ def _pause_threads(unwinder, blocking): LiveStatsCollector = None _FREE_THREADED_BUILD = sysconfig.get_config_var("Py_GIL_DISABLED") is not None + # Minimum number of samples required before showing the TUI # If fewer samples are collected, we skip the TUI and just print a message MIN_SAMPLES_FOR_TUI = 200 @@ -64,19 +65,23 @@ def __init__(self, pid, sample_interval_usec, all_threads, *, mode=PROFILING_MOD self.realtime_stats = False def _new_unwinder(self, native, gc, opcodes, skip_non_matching_threads): - if _FREE_THREADED_BUILD: - unwinder = _remote_debugging.RemoteUnwinder( - self.pid, all_threads=self.all_threads, mode=self.mode, native=native, gc=gc, - opcodes=opcodes, skip_non_matching_threads=skip_non_matching_threads, - cache_frames=True, stats=self.collect_stats - ) + kwargs = {} + if _FREE_THREADED_BUILD or self.all_threads: + kwargs['all_threads'] = self.all_threads else: - unwinder = _remote_debugging.RemoteUnwinder( - self.pid, only_active_thread=bool(self.all_threads), mode=self.mode, native=native, gc=gc, - opcodes=opcodes, skip_non_matching_threads=skip_non_matching_threads, - cache_frames=True, stats=self.collect_stats - ) - return unwinder + kwargs['only_active_thread'] = bool(self.all_threads) + + return _remote_debugging.RemoteUnwinder( + self.pid, + mode=self.mode, + native=native, + gc=gc, + opcodes=opcodes, + skip_non_matching_threads=skip_non_matching_threads, + cache_frames=True, + stats=self.collect_stats, + **kwargs + ) def sample(self, collector, duration_sec=None, *, async_aware=False): sample_interval_sec = self.sample_interval_usec / 1_000_000 diff --git a/Misc/NEWS.d/next/Library/2026-01-05-05-31-05.gh-issue-143423.X7YdnR.rst b/Misc/NEWS.d/next/Library/2026-01-05-05-31-05.gh-issue-143423.X7YdnR.rst new file mode 100644 index 00000000000000..d9276dfd400a5d --- /dev/null +++ b/Misc/NEWS.d/next/Library/2026-01-05-05-31-05.gh-issue-143423.X7YdnR.rst @@ -0,0 +1 @@ +Fix free-threaded build detection in the sampling profiler when Py_GIL_DISABLED is set to 0.

1 0

gh-143192 Avoid incref/decref pair in long_bitwise (gh-143194)
by colesbury Jan. 29, 2026

Jan. 29, 2026

https://github.com/python/cpython/commit/1b081434666d244d2fa083d47251d90175… commit: 1b081434666d244d2fa083d47251d90175ac69da branch: main author: Pieter Eendebak <pieter.eendebak(a)gmail.com> committer: colesbury <colesbury(a)gmail.com> date: 2026-01-29T16:32:09-05:00 summary: gh-143192 Avoid incref/decref pair in long_bitwise (gh-143194) Remove unnecessary reference count operations in long_bitwise in order to avoid reference count contention in the free-threading build. files: A Misc/NEWS.d/next/Core_and_Builtins/2025-12-29-19-31-46.gh-issue-143192.JxGAyl.rst M Objects/longobject.c diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2025-12-29-19-31-46.gh-issue-143192.JxGAyl.rst b/Misc/NEWS.d/next/Core_and_Builtins/2025-12-29-19-31-46.gh-issue-143192.JxGAyl.rst new file mode 100644 index 00000000000000..3a99b3d9e6a1c2 --- /dev/null +++ b/Misc/NEWS.d/next/Core_and_Builtins/2025-12-29-19-31-46.gh-issue-143192.JxGAyl.rst @@ -0,0 +1 @@ +Improve performance of bitwise operations on multi-digit ints. diff --git a/Objects/longobject.c b/Objects/longobject.c index 74958cb8b9bbb0..7ce5d0535b884e 100644 --- a/Objects/longobject.c +++ b/Objects/longobject.c @@ -5589,46 +5589,45 @@ long_bitwise(PyLongObject *a, Py_ssize_t size_a, size_b, size_z, i; PyLongObject *z; + PyLongObject *new_a = NULL; + PyLongObject *new_b = NULL; + /* Bitwise operations for negative numbers operate as though on a two's complement representation. So convert arguments from sign-magnitude to two's complement, and convert the result back to sign-magnitude at the end. */ - /* If a is negative, replace it by its two's complement. */ size_a = _PyLong_DigitCount(a); + size_b = _PyLong_DigitCount(b); + /* Swap a and b if necessary to ensure size_a >= size_b. */ + if (size_a < size_b) { + z = a; a = b; b = z; + size_z = size_a; size_a = size_b; size_b = size_z; + } + + /* If a is negative, replace it by its two's complement. */ nega = _PyLong_IsNegative(a); if (nega) { z = long_alloc(size_a); if (z == NULL) return NULL; v_complement(z->long_value.ob_digit, a->long_value.ob_digit, size_a); + new_a = z; // reference to decrement instead of a itself a = z; } - else - /* Keep reference count consistent. */ - Py_INCREF(a); /* Same for b. */ - size_b = _PyLong_DigitCount(b); negb = _PyLong_IsNegative(b); if (negb) { z = long_alloc(size_b); if (z == NULL) { - Py_DECREF(a); + Py_XDECREF(new_a); return NULL; } v_complement(z->long_value.ob_digit, b->long_value.ob_digit, size_b); + new_b = z; // reference to decrement instead of b itself b = z; } - else - Py_INCREF(b); - - /* Swap a and b if necessary to ensure size_a >= size_b. */ - if (size_a < size_b) { - z = a; a = b; b = z; - size_z = size_a; size_a = size_b; size_b = size_z; - negz = nega; nega = negb; negb = negz; - } /* JRH: The original logic here was to allocate the result value (z) as the longer of the two operands. However, there are some cases @@ -5658,8 +5657,8 @@ long_bitwise(PyLongObject *a, the final two's complement of z doesn't overflow. */ z = long_alloc(size_z + negz); if (z == NULL) { - Py_DECREF(a); - Py_DECREF(b); + Py_XDECREF(new_a); + Py_XDECREF(new_b); return NULL; } @@ -5696,8 +5695,8 @@ long_bitwise(PyLongObject *a, v_complement(z->long_value.ob_digit, z->long_value.ob_digit, size_z+1); } - Py_DECREF(a); - Py_DECREF(b); + Py_XDECREF(new_a); + Py_XDECREF(new_b); return (PyObject *)maybe_small_long(long_normalize(z)); }

1 0