From de4d919b0d0926be82f78ec67be2dcfc0cc4bb3c Mon Sep 17 00:00:00 2001 From: Pablo Galindo Date: Wed, 6 May 2020 21:58:48 +0100 Subject: [PATCH 1/8] bpo-40334: Add the new grammar to the grammar specification documentation --- Doc/conf.py | 2 +- Doc/reference/grammar.rst | 3 +- Doc/tools/extensions/peg_highlight.py | 85 +++++++++++++++++++++++++++ 3 files changed, 88 insertions(+), 2 deletions(-) create mode 100644 Doc/tools/extensions/peg_highlight.py diff --git a/Doc/conf.py b/Doc/conf.py index 12d74ea24ce4ac..bfb2a98fc63a2f 100644 --- a/Doc/conf.py +++ b/Doc/conf.py @@ -15,7 +15,7 @@ extensions = ['sphinx.ext.coverage', 'sphinx.ext.doctest', 'pyspecific', 'c_annotations', 'escape4chm', - 'asdl_highlight'] + 'asdl_highlight', 'peg_highlight'] doctest_global_setup = ''' diff --git a/Doc/reference/grammar.rst b/Doc/reference/grammar.rst index 83d0f8532c6366..ed864286493b61 100644 --- a/Doc/reference/grammar.rst +++ b/Doc/reference/grammar.rst @@ -4,4 +4,5 @@ Full Grammar specification This is the full Python grammar, as it is read by the parser generator and used to parse Python source files: -.. literalinclude:: ../../Grammar/Grammar +.. literalinclude:: ../../Grammar/python.gram + :language: peg diff --git a/Doc/tools/extensions/peg_highlight.py b/Doc/tools/extensions/peg_highlight.py new file mode 100644 index 00000000000000..2d19bb813b8b3d --- /dev/null +++ b/Doc/tools/extensions/peg_highlight.py @@ -0,0 +1,85 @@ +from pygments.lexer import RegexLexer, bygroups, include +from pygments.token import (Comment, Generic, Keyword, Name, Operator, + Punctuation, Text) + +from sphinx.highlighting import lexers + +class PEGLexer(RegexLexer): + """Pygments Lexer for PEG grammar (.gram) files + + This lexer stripts the following elements from the grammar: + + - Meta-tags + - Variable assignments + - Actions + - Lookaheads + - Rule types + - Rule options + """ + name = "PEG" + aliases = ["peg"] + filenames = ["*.gram"] + _name = r"([^\W\d]\w*)" + _text_ws = r"(\s*)" + + tokens = { + "ws": [ + (r"\n", Text), + (r"\s+", Text), + (r"#.*$", Comment.Singleline), + ], + "lookaheads": [ + (r"(&\w+\s?)", bygroups(None)), + (r"(&'.+'\s?)", bygroups(None)), + (r'(&".+"\s?)', bygroups(None)), + (r"(&\(.+\)\s?)", bygroups(None)), + (r"(!\w+\s?)", bygroups(None)), + (r"(!'.+'\s?)", bygroups(None)), + (r'(!".+"\s?)', bygroups(None)), + (r"(!\(.+\)\s?)", bygroups(None)), + ], + "metas": [ + (r"(@\w+ '''(.|\n)+?''')", bygroups(None)), + (r"^(@.*)$", bygroups(None)), + ], + "actions": [ + (r"{(.|\n)+?}", bygroups(None)), + ], + "strings": [ + (r"'\w+?'", Keyword), + (r'"\w+?"', Keyword), + (r"'\W+?'", Text), + (r'"\W+?"', Text), + ], + "variables": [ + ( + _name + _text_ws + "(=)", + bygroups(None, None, None), + ), + ], + "root": [ + include("ws"), + include("lookaheads"), + include("metas"), + include("actions"), + include("strings"), + include("variables"), + ( + r"\b(?!(NULL|EXTRA))([A-Z_]+)\b\s*(?!\()", + Text, + ), + ( + r"^\s*" + _name + "\s*" + '(\[.*\])?' + "\s*" + '(\(.+\))?' + "\s*(:)", + bygroups(Name.Function, None, None, Punctuation) + ), + (_name, Name.Function), + (r"[\||\.|\+|\*|\?]", Operator), + (r"{|}|\(|\)|\[|\]", Punctuation), + (r".", Text), + ], + } + + +def setup(app): + lexers["peg"] = PEGLexer() + return {'version': '1.0', 'parallel_read_safe': True} From 22e6c71ed8c6dec1143c21337ba32ead312e5968 Mon Sep 17 00:00:00 2001 From: Pablo Galindo Date: Wed, 6 May 2020 22:33:08 +0100 Subject: [PATCH 2/8] Update Doc/tools/extensions/peg_highlight.py Co-authored-by: Guido van Rossum --- Doc/tools/extensions/peg_highlight.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Doc/tools/extensions/peg_highlight.py b/Doc/tools/extensions/peg_highlight.py index 2d19bb813b8b3d..f4f8d440b39e35 100644 --- a/Doc/tools/extensions/peg_highlight.py +++ b/Doc/tools/extensions/peg_highlight.py @@ -7,7 +7,7 @@ class PEGLexer(RegexLexer): """Pygments Lexer for PEG grammar (.gram) files - This lexer stripts the following elements from the grammar: + This lexer strips the following elements from the grammar: - Meta-tags - Variable assignments From c83284e66e5b768547ecf7d715dc6d5ecaa735a6 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Sun, 26 Jul 2020 15:10:17 -0700 Subject: [PATCH 3/8] Tweak text intro to the grammar --- Doc/reference/grammar.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Doc/reference/grammar.rst b/Doc/reference/grammar.rst index ed864286493b61..da4f2ca83a8d55 100644 --- a/Doc/reference/grammar.rst +++ b/Doc/reference/grammar.rst @@ -1,8 +1,8 @@ Full Grammar specification ========================== -This is the full Python grammar, as it is read by the parser generator and used -to parse Python source files: +This is the full Python grammar, derived directly from the grammar +used to generate the CPython parser (see :source:`Grammar/python.gram`). .. literalinclude:: ../../Grammar/python.gram :language: peg From 27f7f008cca8a5b430a4a1d9fb7152b636ec0424 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Sun, 26 Jul 2020 15:34:14 -0700 Subject: [PATCH 4/8] Suppress all rules named invalid_* or incorrect_* --- Doc/tools/extensions/peg_highlight.py | 38 +++++++++++---------------- 1 file changed, 16 insertions(+), 22 deletions(-) diff --git a/Doc/tools/extensions/peg_highlight.py b/Doc/tools/extensions/peg_highlight.py index f4f8d440b39e35..12f99b9e25dfa2 100644 --- a/Doc/tools/extensions/peg_highlight.py +++ b/Doc/tools/extensions/peg_highlight.py @@ -1,9 +1,9 @@ from pygments.lexer import RegexLexer, bygroups, include -from pygments.token import (Comment, Generic, Keyword, Name, Operator, - Punctuation, Text) +from pygments.token import Comment, Generic, Keyword, Name, Operator, Punctuation, Text from sphinx.highlighting import lexers + class PEGLexer(RegexLexer): """Pygments Lexer for PEG grammar (.gram) files @@ -15,7 +15,9 @@ class PEGLexer(RegexLexer): - Lookaheads - Rule types - Rule options + - Rules named `invalid_*` or `incorrect_*` """ + name = "PEG" aliases = ["peg"] filenames = ["*.gram"] @@ -23,11 +25,7 @@ class PEGLexer(RegexLexer): _text_ws = r"(\s*)" tokens = { - "ws": [ - (r"\n", Text), - (r"\s+", Text), - (r"#.*$", Comment.Singleline), - ], + "ws": [(r"\n", Text), (r"\s+", Text), (r"#.*$", Comment.Singleline),], "lookaheads": [ (r"(&\w+\s?)", bygroups(None)), (r"(&'.+'\s?)", bygroups(None)), @@ -42,35 +40,31 @@ class PEGLexer(RegexLexer): (r"(@\w+ '''(.|\n)+?''')", bygroups(None)), (r"^(@.*)$", bygroups(None)), ], - "actions": [ - (r"{(.|\n)+?}", bygroups(None)), - ], + "actions": [(r"{(.|\n)+?}", bygroups(None)),], "strings": [ (r"'\w+?'", Keyword), (r'"\w+?"', Keyword), (r"'\W+?'", Text), (r'"\W+?"', Text), ], - "variables": [ - ( - _name + _text_ws + "(=)", - bygroups(None, None, None), - ), + "variables": [(_name + _text_ws + "(=)", bygroups(None, None, None),),], + "invalids": [ + (r"^(\s+\|\s+invalid_\w+\s*\n)", bygroups(None)), + (r"^(\s+\|\s+incorrect_\w+\s*\n)", bygroups(None)), + (r"^(#.*invalid syntax.*(?:.|\n)*)", bygroups(None),), ], "root": [ + include("invalids"), include("ws"), include("lookaheads"), include("metas"), include("actions"), include("strings"), include("variables"), + (r"\b(?!(NULL|EXTRA))([A-Z_]+)\b\s*(?!\()", Text,), ( - r"\b(?!(NULL|EXTRA))([A-Z_]+)\b\s*(?!\()", - Text, - ), - ( - r"^\s*" + _name + "\s*" + '(\[.*\])?' + "\s*" + '(\(.+\))?' + "\s*(:)", - bygroups(Name.Function, None, None, Punctuation) + r"^\s*" + _name + "\s*" + "(\[.*\])?" + "\s*" + "(\(.+\))?" + "\s*(:)", + bygroups(Name.Function, None, None, Punctuation), ), (_name, Name.Function), (r"[\||\.|\+|\*|\?]", Operator), @@ -82,4 +76,4 @@ class PEGLexer(RegexLexer): def setup(app): lexers["peg"] = PEGLexer() - return {'version': '1.0', 'parallel_read_safe': True} + return {"version": "1.0", "parallel_read_safe": True} From 266a99ae5678deee8da01370b3b339b52684c2d2 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Sun, 26 Jul 2020 15:48:10 -0700 Subject: [PATCH 5/8] Now we can remove Grammar/Grammar --- Grammar/Grammar | 206 ------------------------------------------------ 1 file changed, 206 deletions(-) delete mode 100644 Grammar/Grammar diff --git a/Grammar/Grammar b/Grammar/Grammar deleted file mode 100644 index 61a26243f886be..00000000000000 --- a/Grammar/Grammar +++ /dev/null @@ -1,206 +0,0 @@ -# Grammar for Python - -# NOTE: Editing this file has no effect except on the docs. - -# Start symbols for the grammar: -# single_input is a single interactive statement; -# file_input is a module or sequence of commands read from an input file; -# eval_input is the input for the eval() functions. -# func_type_input is a PEP 484 Python 2 function type comment -# NB: compound_stmt in single_input is followed by extra NEWLINE! -# NB: due to the way TYPE_COMMENT is tokenized it will always be followed by a NEWLINE -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE -file_input: (NEWLINE | stmt)* ENDMARKER -eval_input: testlist NEWLINE* ENDMARKER - -decorator: '@' namedexpr_test NEWLINE -decorators: decorator+ -decorated: decorators (classdef | funcdef | async_funcdef) - -async_funcdef: ASYNC funcdef -funcdef: 'def' NAME parameters ['->' test] ':' [TYPE_COMMENT] func_body_suite - -parameters: '(' [typedargslist] ')' - -# The following definition for typedarglist is equivalent to this set of rules: -# -# arguments = argument (',' [TYPE_COMMENT] argument)* -# argument = tfpdef ['=' test] -# kwargs = '**' tfpdef [','] [TYPE_COMMENT] -# args = '*' [tfpdef] -# kwonly_kwargs = (',' [TYPE_COMMENT] argument)* (TYPE_COMMENT | [',' [TYPE_COMMENT] [kwargs]]) -# args_kwonly_kwargs = args kwonly_kwargs | kwargs -# poskeyword_args_kwonly_kwargs = arguments ( TYPE_COMMENT | [',' [TYPE_COMMENT] [args_kwonly_kwargs]]) -# typedargslist_no_posonly = poskeyword_args_kwonly_kwargs | args_kwonly_kwargs -# typedarglist = (arguments ',' [TYPE_COMMENT] '/' [',' [[TYPE_COMMENT] typedargslist_no_posonly]])|(typedargslist_no_posonly)" -# -# It needs to be fully expanded to allow our LL(1) parser to work on it. - -typedargslist: ( - (tfpdef ['=' test] (',' [TYPE_COMMENT] tfpdef ['=' test])* ',' [TYPE_COMMENT] '/' [',' [ [TYPE_COMMENT] tfpdef ['=' test] ( - ',' [TYPE_COMMENT] tfpdef ['=' test])* (TYPE_COMMENT | [',' [TYPE_COMMENT] [ - '*' [tfpdef] (',' [TYPE_COMMENT] tfpdef ['=' test])* (TYPE_COMMENT | [',' [TYPE_COMMENT] ['**' tfpdef [','] [TYPE_COMMENT]]]) - | '**' tfpdef [','] [TYPE_COMMENT]]]) - | '*' [tfpdef] (',' [TYPE_COMMENT] tfpdef ['=' test])* (TYPE_COMMENT | [',' [TYPE_COMMENT] ['**' tfpdef [','] [TYPE_COMMENT]]]) - | '**' tfpdef [','] [TYPE_COMMENT]]] ) -| (tfpdef ['=' test] (',' [TYPE_COMMENT] tfpdef ['=' test])* (TYPE_COMMENT | [',' [TYPE_COMMENT] [ - '*' [tfpdef] (',' [TYPE_COMMENT] tfpdef ['=' test])* (TYPE_COMMENT | [',' [TYPE_COMMENT] ['**' tfpdef [','] [TYPE_COMMENT]]]) - | '**' tfpdef [','] [TYPE_COMMENT]]]) - | '*' [tfpdef] (',' [TYPE_COMMENT] tfpdef ['=' test])* (TYPE_COMMENT | [',' [TYPE_COMMENT] ['**' tfpdef [','] [TYPE_COMMENT]]]) - | '**' tfpdef [','] [TYPE_COMMENT]) -) -tfpdef: NAME [':' test] - -# The following definition for varargslist is equivalent to this set of rules: -# -# arguments = argument (',' argument )* -# argument = vfpdef ['=' test] -# kwargs = '**' vfpdef [','] -# args = '*' [vfpdef] -# kwonly_kwargs = (',' argument )* [',' [kwargs]] -# args_kwonly_kwargs = args kwonly_kwargs | kwargs -# poskeyword_args_kwonly_kwargs = arguments [',' [args_kwonly_kwargs]] -# vararglist_no_posonly = poskeyword_args_kwonly_kwargs | args_kwonly_kwargs -# varargslist = arguments ',' '/' [','[(vararglist_no_posonly)]] | (vararglist_no_posonly) -# -# It needs to be fully expanded to allow our LL(1) parser to work on it. - -varargslist: vfpdef ['=' test ](',' vfpdef ['=' test])* ',' '/' [',' [ (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' [ - '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] - | '**' vfpdef [',']]] - | '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] - | '**' vfpdef [',']) ]] | (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' [ - '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] - | '**' vfpdef [',']]] - | '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] - | '**' vfpdef [','] -) -vfpdef: NAME - -stmt: simple_stmt | compound_stmt -simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE -small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | nonlocal_stmt | assert_stmt) -expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | - [('=' (yield_expr|testlist_star_expr))+ [TYPE_COMMENT]] ) -annassign: ':' test ['=' (yield_expr|testlist_star_expr)] -testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] -augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//=') -# For normal and annotated assignments, additional restrictions enforced by the interpreter -del_stmt: 'del' exprlist -pass_stmt: 'pass' -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt -break_stmt: 'break' -continue_stmt: 'continue' -return_stmt: 'return' [testlist_star_expr] -yield_stmt: yield_expr -raise_stmt: 'raise' [test ['from' test]] -import_stmt: import_name | import_from -import_name: 'import' dotted_as_names -# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS -import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)) -import_as_name: NAME ['as' NAME] -dotted_as_name: dotted_name ['as' NAME] -import_as_names: import_as_name (',' import_as_name)* [','] -dotted_as_names: dotted_as_name (',' dotted_as_name)* -dotted_name: NAME ('.' NAME)* -global_stmt: 'global' NAME (',' NAME)* -nonlocal_stmt: 'nonlocal' NAME (',' NAME)* -assert_stmt: 'assert' test [',' test] - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt -async_stmt: ASYNC (funcdef | with_stmt | for_stmt) -if_stmt: 'if' namedexpr_test ':' suite ('elif' namedexpr_test ':' suite)* ['else' ':' suite] -while_stmt: 'while' namedexpr_test ':' suite ['else' ':' suite] -for_stmt: 'for' exprlist 'in' testlist ':' [TYPE_COMMENT] suite ['else' ':' suite] -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ['else' ':' suite] - ['finally' ':' suite] | - 'finally' ':' suite)) -with_stmt: 'with' with_item (',' with_item)* ':' [TYPE_COMMENT] suite -with_item: test ['as' expr] -# NB compile.c makes sure that the default except clause is last -except_clause: 'except' [test ['as' NAME]] -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT - -namedexpr_test: test [':=' test] -test: or_test ['if' or_test 'else' test] | lambdef -test_nocond: or_test | lambdef_nocond -lambdef: 'lambda' [varargslist] ':' test -lambdef_nocond: 'lambda' [varargslist] ':' test_nocond -or_test: and_test ('or' and_test)* -and_test: not_test ('and' not_test)* -not_test: 'not' not_test | comparison -comparison: expr (comp_op expr)* -# <> isn't actually a valid comparison operator in Python. It's here for the -# sake of a __future__ import described in PEP 401 (which really works :-) -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' -star_expr: '*' expr -expr: xor_expr ('|' xor_expr)* -xor_expr: and_expr ('^' and_expr)* -and_expr: shift_expr ('&' shift_expr)* -shift_expr: arith_expr (('<<'|'>>') arith_expr)* -arith_expr: term (('+'|'-') term)* -term: factor (('*'|'@'|'/'|'%'|'//') factor)* -factor: ('+'|'-'|'~') factor | power -power: atom_expr ['**' factor] -atom_expr: [AWAIT] atom trailer* -atom: ('(' [yield_expr|testlist_comp] ')' | - '[' [testlist_comp] ']' | - '{' [dictorsetmaker] '}' | - NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False') -testlist_comp: (namedexpr_test|star_expr) ( comp_for | (',' (namedexpr_test|star_expr))* [','] ) -trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME -subscriptlist: subscript (',' subscript)* [','] -subscript: test | [test] ':' [test] [sliceop] -sliceop: ':' [test] -exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] -testlist: test (',' test)* [','] -dictorsetmaker: ( ((test ':' test | '**' expr) - (comp_for | (',' (test ':' test | '**' expr))* [','])) | - ((test | star_expr) - (comp_for | (',' (test | star_expr))* [','])) ) - -classdef: 'class' NAME ['(' [arglist] ')'] ':' suite - -arglist: argument (',' argument)* [','] - -# The reason that keywords are test nodes instead of NAME is that using NAME -# results in an ambiguity. ast.c makes sure it's a NAME. -# "test '=' test" is really "keyword '=' test", but we have no such token. -# These need to be in a single rule to avoid grammar that is ambiguous -# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, -# we explicitly match '*' here, too, to give it proper precedence. -# Illegal combinations and orderings are blocked in ast.c: -# multiple (test comp_for) arguments are blocked; keyword unpackings -# that precede iterable unpackings are blocked; etc. -argument: ( test [comp_for] | - test ':=' test | - test '=' test | - '**' test | - '*' test ) - -comp_iter: comp_for | comp_if -sync_comp_for: 'for' exprlist 'in' or_test [comp_iter] -comp_for: [ASYNC] sync_comp_for -comp_if: 'if' test_nocond [comp_iter] - -# not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME - -yield_expr: 'yield' [yield_arg] -yield_arg: 'from' test | testlist_star_expr - -# the TYPE_COMMENT in suites is only parsed for funcdefs, -# but can't go elsewhere due to ambiguity -func_body_suite: simple_stmt | NEWLINE [TYPE_COMMENT NEWLINE] INDENT stmt+ DEDENT - -func_type_input: func_type NEWLINE* ENDMARKER -func_type: '(' [typelist] ')' '->' test -# typelist is a modified typedargslist (see above) -typelist: (test (',' test)* [',' - ['*' [test] (',' test)* [',' '**' test] | '**' test]] - | '*' [test] (',' test)* [',' '**' test] | '**' test) From 13aa70d62179797fa722e5ccbbc3e39efc1bde8a Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Mon, 27 Jul 2020 10:20:17 -0700 Subject: [PATCH 6/8] More conservative suppression of lookaheads --- Doc/tools/extensions/peg_highlight.py | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/Doc/tools/extensions/peg_highlight.py b/Doc/tools/extensions/peg_highlight.py index 12f99b9e25dfa2..f02515d3919cf2 100644 --- a/Doc/tools/extensions/peg_highlight.py +++ b/Doc/tools/extensions/peg_highlight.py @@ -27,14 +27,10 @@ class PEGLexer(RegexLexer): tokens = { "ws": [(r"\n", Text), (r"\s+", Text), (r"#.*$", Comment.Singleline),], "lookaheads": [ - (r"(&\w+\s?)", bygroups(None)), - (r"(&'.+'\s?)", bygroups(None)), - (r'(&".+"\s?)', bygroups(None)), - (r"(&\(.+\)\s?)", bygroups(None)), - (r"(!\w+\s?)", bygroups(None)), - (r"(!'.+'\s?)", bygroups(None)), - (r'(!".+"\s?)', bygroups(None)), - (r"(!\(.+\)\s?)", bygroups(None)), + (r"(?<=\|\s)(&\w+\s?)", bygroups(None)), + (r"(?<=\|\s)(&'.+'\s?)", bygroups(None)), + (r'(?<=\|\s)(&".+"\s?)', bygroups(None)), + (r"(?<=\|\s)(&\(.+\)\s?)", bygroups(None)), ], "metas": [ (r"(@\w+ '''(.|\n)+?''')", bygroups(None)), From 7705e02abd6bebb34729b475e523b9c1623c0214 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Mon, 27 Jul 2020 10:20:39 -0700 Subject: [PATCH 7/8] Lengthen intro for grammar.rst --- Doc/reference/grammar.rst | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/Doc/reference/grammar.rst b/Doc/reference/grammar.rst index da4f2ca83a8d55..d2039edb37c0c5 100644 --- a/Doc/reference/grammar.rst +++ b/Doc/reference/grammar.rst @@ -3,6 +3,17 @@ Full Grammar specification This is the full Python grammar, derived directly from the grammar used to generate the CPython parser (see :source:`Grammar/python.gram`). +The version here omits details related to code generation and +error recovery. + +The notation is a mixture of `EBNF +`_ +and `PEG `_. +In particular, ``&`` followed by a symbol, token or parenthesized +group indicates a positive lookahead (i.e., is required to match but +not consumed) while ``!`` indicates a negative lookahead (i.e., it +required _not_ to match). We use the ``|`` separator to mean PEG's +"ordered choice" (written as ``/`` in traditional PEG grammars). .. literalinclude:: ../../Grammar/python.gram :language: peg From bac89716b39097af89ce6eca03196511e4db2e06 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Mon, 27 Jul 2020 10:36:08 -0700 Subject: [PATCH 8/8] Fix typo and comma --- Doc/reference/grammar.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Doc/reference/grammar.rst b/Doc/reference/grammar.rst index d2039edb37c0c5..acf83765b5796c 100644 --- a/Doc/reference/grammar.rst +++ b/Doc/reference/grammar.rst @@ -11,7 +11,7 @@ The notation is a mixture of `EBNF and `PEG `_. In particular, ``&`` followed by a symbol, token or parenthesized group indicates a positive lookahead (i.e., is required to match but -not consumed) while ``!`` indicates a negative lookahead (i.e., it +not consumed), while ``!`` indicates a negative lookahead (i.e., is required _not_ to match). We use the ``|`` separator to mean PEG's "ordered choice" (written as ``/`` in traditional PEG grammars).