将自顶向下语法规则转换为 BNF答案

【问题标题】：Convert top down grammar rule to BNF将自顶向下语法规则转换为 BNF
【发布时间】：2013-12-15 13:50:08
【问题描述】：

我继承了一个 ANTLR 语法，现在我需要编写一个好的、旧的、类似 YACC/BISON 的解析器（具体来说，我将 PLY 用于 python）。有许多奇怪的规则，我现在正在努力解决以下问题：

factor : ('(' expr ')' | procedure | variable) ('.' variable | call)* '!'?

目前，我只有第一部分的规则，即

factor :  '(' expr ')' 
       | procedure 
       | variable

PLY 规则：

def p_factor_1(self, p):                                                                                                                                                                                       
    """ factor : LPAREN expr RPAREN """                                                                                                                                                                        
    p[0] = p[2]                                                                                                                                                                                                

def p_factor_2(self, p):                                                                                                                                                                                       
    """ factor : variable                                                                                                                                                                                      
               | procedure_definition                                                                                                                                                                          
    """                                                                                                                                                                                                        
    p[0] = p[1]

我怎样才能把那件上衣变成真正适合 PLY 的东西？我需要合理的规则，这样我就可以为单个 expr、过程、变量构建一个 AST 节点，然后还可以为变量访问和链式调用的链接构建一些节点。更糟糕的是还有“！” .原始语法的创建者这样做是为了给予最高优先级的因式分解，但对于转换，这完全是痛苦的。

【问题讨论】：

Grako 有一个 ANTLR 到 Grako 的翻译器，并提供简单的 Python 解析器构造。

标签： python parsing grammar context-free-grammar ply

【解决方案1】：

只要有条不紊地去做：)

           V → ω X             V → V X                V → ω 
V → ω X? ⇒            V → X* ⇒            V → ω | ζ ⇒ 
           V → ω               V →                    V → ζ

当然，如果您必须在单个生产中执行以上操作中的一项以上，则需要引入新的非终端。

所以：

factor : ('(' expr ')' | procedure | variable) ('.' variable | call)* '!'?

A.引入新的非终端：

factor          : factor-prefix factor-suffix '!'?
factor-prefix   : '(' expr ')' | procedure | variable
factor-suffix   : factor-continue*
factor-continue : '.' variable | call

B.按以上规则替换

  factor          : factor-prefix factor-suffix '!'?
⇒
  factor          : factor-prefix factor-suffix '!'
  factor          : factor-prefix factor-suffix

  factor-prefix   : '(' expr ')' | procedure | variable
⇒
  factor-prefix   : '(' expr ')'
  factor-prefix   : procedure
  factor-prefix   : variable

  factor-suffix   : factor-continue*
⇒
  factor-suffix   : factor-suffix factor-continue
  factor-suffix   :

  factor-continue : '.' variable | call
⇒
  factor-continue : '.' variable
  factor-continue : call

【讨论】：