iSharkFly-Open
/
python-peps
mirror of https://github.com/python/peps.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

PEP 617: Resolve unreferenced footnotes (#3250)

This commit is contained in:
Adam Turner 2023-08-02 18:08:18 +01:00 committed by GitHub
parent 5a77bca05b
commit 8e978d4ac3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 29 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
pep-0617.rst
View File

@ -1,7 +1,5 @@
PEP: 617 PEP: 617
Title: New PEG parser for CPython Title: New PEG parser for CPython
Version: $Revision$
Last-Modified: $Date$
Author: Guido van Rossum <guido@python.org>, Author: Guido van Rossum <guido@python.org>,
Pablo Galindo <pablogsal@python.org>, Pablo Galindo <pablogsal@python.org>,
Lysandros Nikolaou <lisandrosnik@gmail.com> Lysandros Nikolaou <lisandrosnik@gmail.com>
@ -13,6 +11,8 @@ Created: 24-Mar-2020
Python-Version: 3.9 Python-Version: 3.9
Post-History: 02-Apr-2020 Post-History: 02-Apr-2020
.. highlight:: PEG
======== ========
Overview Overview
======== ========
@ -40,7 +40,7 @@ and the *follow sets* of the grammar:
* Given a rule, the *first set* is the collection of all terminals that can occur * Given a rule, the *first set* is the collection of all terminals that can occur
first in a full derivation of that rule. Intuitively, this helps the parser decide first in a full derivation of that rule. Intuitively, this helps the parser decide
among the alternatives in a rule. For among the alternatives in a rule. For
instance, given the rule :: instance, given the rule::
rule: A | B rule: A | B
@ -298,13 +298,13 @@ and "hidden left-recursion" like::
Syntax Syntax
------ ------
The grammar consists of a sequence of rules of the form: :: The grammar consists of a sequence of rules of the form::
rule_name: expression rule_name: expression
Optionally, a type can be included right after the rule name, which Optionally, a type can be included right after the rule name, which
specifies the return type of the C or Python function corresponding to specifies the return type of the C or Python function corresponding to
the rule: :: the rule::
rule_name[return_type]: expression rule_name[return_type]: expression
@ -324,7 +324,7 @@ Python-style comments.
Match e1, then match e2. Match e1, then match e2.
:: .. code:: PEG
rule_name: first_rule second_rule rule_name: first_rule second_rule
@ -339,7 +339,7 @@ The first alternative can also appear on the line after the rule name
for formatting purposes. In that case, a \| must be used before the for formatting purposes. In that case, a \| must be used before the
first alternative, like so: first alternative, like so:
:: .. code:: PEG
rule_name[return_type]: rule_name[return_type]:
| first_alt | first_alt
@ -350,14 +350,14 @@ first alternative, like so:
Match e. Match e.
:: .. code:: PEG
rule_name: (e) rule_name: (e)
A slightly more complex and useful example includes using the grouping A slightly more complex and useful example includes using the grouping
operator together with the repeat operators: operator together with the repeat operators:
:: .. code:: PEG
rule_name: (e1 e2)* rule_name: (e1 e2)*
@ -366,14 +366,14 @@ operator together with the repeat operators:
Optionally match e. Optionally match e.
:: .. code:: PEG
rule_name: [e] rule_name: [e]
A more useful example includes defining that a trailing comma is A more useful example includes defining that a trailing comma is
optional: optional:
:: .. code:: PEG
rule_name: e (',' e)* [','] rule_name: e (',' e)* [',']
@ -384,7 +384,7 @@ optional:
Match zero or more occurrences of e. Match zero or more occurrences of e.
:: .. code:: PEG
rule_name: (e1 e2)* rule_name: (e1 e2)*
@ -395,7 +395,7 @@ Match zero or more occurrences of e.
Match one or more occurrences of e. Match one or more occurrences of e.
:: .. code:: PEG
rule_name: (e1 e2)+ rule_name: (e1 e2)+
@ -406,7 +406,7 @@ Match one or more occurrences of e, separated by s. The generated parse
tree does not include the separator. This is otherwise identical to tree does not include the separator. This is otherwise identical to
``(e (s e)*)``. ``(e (s e)*)``.
:: .. code:: PEG
rule_name: ','.e+ rule_name: ','.e+
@ -428,7 +428,7 @@ An example taken from the proposed Python grammar specifies that a primary
consists of an atom, which is not followed by a ``.`` or a ``(`` or a consists of an atom, which is not followed by a ``.`` or a ``(`` or a
``[``: ``[``:
:: .. code:: PEG
primary: atom !'.' !'(' !'[' primary: atom !'.' !'(' !'['
@ -439,7 +439,7 @@ consists of an atom, which is not followed by a ``.`` or a ``(`` or a
Commit to the current alternative, even if it fails to parse. Commit to the current alternative, even if it fails to parse.
:: .. code:: PEG
rule_name: '(' ~ some_rule ')' | some_alt rule_name: '(' ~ some_rule ')' | some_alt
@ -451,7 +451,7 @@ Variables in the Grammar
~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~
A subexpression can be named by preceding it with an identifier and an A subexpression can be named by preceding it with an identifier and an
``=`` sign. The name can then be used in the action (see below), like this: :: ``=`` sign. The name can then be used in the action (see below), like this::
rule_name[return_type]: '(' a=some_other_rule ')' { a } rule_name[return_type]: '(' a=some_other_rule ')' { a }
@ -469,7 +469,7 @@ files should be written, each one with a different set of actions, keeping
everything else apart from said actions identical in both files. As an everything else apart from said actions identical in both files. As an
example of a grammar with Python actions, the piece of the parser generator example of a grammar with Python actions, the piece of the parser generator
that parses grammar files is bootstrapped from a meta-grammar file with that parses grammar files is bootstrapped from a meta-grammar file with
Python actions that generate the grammar tree as a result of the parsing. Python actions that generate the grammar tree as a result of the parsing.
In the specific case of the new proposed PEG grammar for Python, having In the specific case of the new proposed PEG grammar for Python, having
actions allows directly describing how the AST is composed in the grammar actions allows directly describing how the AST is composed in the grammar
@ -496,7 +496,7 @@ with all the parsed expressions gets returned (this is meant for debugging).
The full meta-grammar for the grammars supported by the PEG generator is: The full meta-grammar for the grammars supported by the PEG generator is:
:: .. code:: PEG
start[Grammar]: grammar ENDMARKER { grammar } start[Grammar]: grammar ENDMARKER { grammar }
@ -589,25 +589,25 @@ As an illustrative example this simple grammar file allows directly
generating a full parser that can parse simple arithmetic expressions and that generating a full parser that can parse simple arithmetic expressions and that
returns a valid C-based Python AST: returns a valid C-based Python AST:
:: .. code:: PEG
start[mod_ty]: a=expr_stmt* $ { Module(a, NULL, p->arena) } start[mod_ty]: a=expr_stmt* $ { Module(a, NULL, p->arena) }
expr_stmt[stmt_ty]: a=expr NEWLINE { _Py_Expr(a, EXTRA) } expr_stmt[stmt_ty]: a=expr NEWLINE { _Py_Expr(a, EXTRA) }
expr[expr_ty]: expr[expr_ty]:
| l=expr '+' r=term { _Py_BinOp(l, Add, r, EXTRA) } | l=expr '+' r=term { _Py_BinOp(l, Add, r, EXTRA) }
| l=expr '-' r=term { _Py_BinOp(l, Sub, r, EXTRA) } | l=expr '-' r=term { _Py_BinOp(l, Sub, r, EXTRA) }
| t=term { t } | t=term { t }
term[expr_ty]: term[expr_ty]:
| l=term '*' r=factor { _Py_BinOp(l, Mult, r, EXTRA) } | l=term '*' r=factor { _Py_BinOp(l, Mult, r, EXTRA) }
| l=term '/' r=factor { _Py_BinOp(l, Div, r, EXTRA) } | l=term '/' r=factor { _Py_BinOp(l, Div, r, EXTRA) }
| f=factor { f } | f=factor { f }
factor[expr_ty]: factor[expr_ty]:
| '(' e=expr ')' { e } | '(' e=expr ')' { e }
| a=atom { a } | a=atom { a }
atom[expr_ty]: atom[expr_ty]:
| n=NAME { n } | n=NAME { n }
| n=NUMBER { n } | n=NUMBER { n }
| s=STRING { s } | s=STRING { s }
@ -619,7 +619,7 @@ for the parser.
A similar grammar written to target Python AST objects: A similar grammar written to target Python AST objects:
:: .. code:: PEG
start: expr NEWLINE? ENDMARKER { ast.Expression(expr) } start: expr NEWLINE? ENDMARKER { ast.Expression(expr) }
expr: expr:
@ -787,17 +787,16 @@ References
========== ==========
.. [1] Ford, Bryan .. [1] Ford, Bryan
http://pdos.csail.mit.edu/~baford/packrat/thesis https://pdos.csail.mit.edu/~baford/packrat/thesis/
.. [2] Medeiros et al. .. [2] Medeiros et al.
https://arxiv.org/pdf/1207.0443.pdf https://arxiv.org/pdf/1207.0443.pdf
.. [3] Warth et al. .. [3] Warth et al.
http://web.cs.ucla.edu/~todd/research/pepm08.pdf https://web.cs.ucla.edu/~todd/research/pepm08.pdf
.. [#GUIDO_PEG] [4] Guido's series on PEG parsing
Guido's series on PEG parsing \ https://medium.com/@gvanrossum_83706/peg-parsing-series-de5d41b2ed60
https://medium.com/@gvanrossum_83706/peg-parsing-series-de5d41b2ed60
========= =========
Copyright Copyright