使用70行Python代码实现一个递归下降解析器的教程

token_map = {'+':'ADD', '-':'ADD',
       '*':'MUL', '/':'MUL',
       '(':'LPAR', ')':'RPAR'}
 
Token = namedtuple('Token', ['name', 'value'])

split_expr = re.findall('[\d.]+|[%s]' % ''.join(token_map), expr)
tokens = [Token(token_map.get(x, 'NUM'), x) for x in split_expr]

'1.2 / ( 11+3)' --> ['1.2', '/', '(', '11', '+', '3', ')']

['1.2', '/', '(', '11', '+', '3', ')']
->
[Token(name='NUM', value='1.2'), Token(name='MUL', value='/'), Token(name='LPAR', value='('), Token(name='NUM', value='11'), Token(name='ADD', value='+'), Token(name='NUM', value='3'), Token(name='RPAR', value=')')]

add: add ADD mul | mul;
mul: mul MUL atom | atom;
atom: NUM | '(' add ')' | neg;
neg: '-' atom;

rule_map = {
  'add' : ['mul ADD add', 'mul'],
  'mul' : ['atom MUL mul', 'atom'],
  'atom': ['NUM', 'LPAR add RPAR', 'neg'],
  'neg' : ['ADD atom'],
}

RuleMatch = namedtuple('RuleMatch', ['name', 'matched'])
 
def match(rule_name, tokens):
  if tokens and rule_name == tokens[0].name:   # 是否匹配标识"htmlcode">

> tokens = [Token(name='NUM', value='1.2'), Token(name='MUL', value='/'), Token(name='LPAR', value='('), Token (name='NUM', value='11'), Token(name='ADD', value='+'), Token(name='NUM', value='3'), Token(name='RPAR', value=')')]
 
> match('add', tokens)
 
(RuleMatch(name='add', matched=[RuleMatch(name='mul', matched=[RuleMatch(name='atom', matched=[Token(name='NUM', value='1.2')]), Token(name='MUL', value='/'), RuleMatch(name='mul', matched=[RuleMatch(name='atom', matched=[Token(name='LPAR', value='('), RuleMatch(name='add', matched=[RuleMatch(name='mul', matched=[RuleMatch(name='atom', matched=[Token(name='NUM', value='11')])]), Token(name='ADD', value='+'), RuleMatch(name='add', matched=[RuleMatch(name='mul', matched=[RuleMatch(name='atom', matched=[Token(name='NUM', value='3')])])])]), Token(name='RPAR', value=')')])])])]), [])



结果是一个tuple，当然我们并没有看到有剩下的标识。匹配结果并不易于阅读，所以让我吧结果画成一个图：

 




add
  mul
    atom
      NUM '1.2'
    MUL '/'
    mul
      atom
        LPAR  '('
        add
          mul
            atom
              NUM '11'
          ADD '+'
          add
            mul
              atom
                NUM '3'
        RPAR  ')'



这就是概念上的AST。通过你思维逻辑，或者在纸上描绘，想象解析器是如何运作的，这样是个很好的锻炼。我不敢说这样是必须的，除非你想神交。你可以通过AST来帮助你实现正确的算法。
到目前为止，我们已经完成了可以处理二进制运算，一元运算，括号和操作符优先权的解析器。
现在只剩下一个错误待解决，下面的步骤我们将解决这个错误。


第四步：后续处理
我的解析器并非在任何场合管用。最重要的一点是，它并不能处理左递归，迫使我把代码写成右递归方式。这样导致，解析 8/4/2 这个表达式的时候，AST结果如下：

 




add
  mul
    atom
      NUM 8
    MUL '/'
    mul
      atom
        NUM 4
      MUL '/'
      mul
        atom
          NUM 2



如果我们尝试通过AST计算结果，我们将会优先计算4/2，这当然是错误的。一些LL解析器选择修正树里面的关联性。这样需要编写多行代码;)。这个不采纳，我们需要使它扁平化。算法很简单：对于AST里面的每个规则 1)需要修正 2)是一个二进制运算 （拥有sub-rules）3) 右边的操作符同样的规则：使后者扁平成前者。通过“扁平”，我意思是在其父节点的上下文中，通过节点的儿子代替这个节点。因为我们的穿越是DFS是后序的，意味着它从树的边缘开始，并一直到达树根，效果将会累加。如下是代码：

 




fix_assoc_rules = 'add', 'mul'
 
def _recurse_tree(tree, func):
  return map(func, tree.matched) if tree.name in rule_map else tree[1]
 
def flatten_right_associativity(tree):
  new = _recurse_tree(tree, flatten_right_associativity)
  if tree.name in fix_assoc_rules and len(new)==3 and new[2].name==tree.name:
    new[-1:] = new[-1].matched
  return RuleMatch(tree.name, new)



这段代码可以让任何结构的加法或乘法表达式变成一个平面列表（不会混淆）。括号会破坏顺序，当然，它们不会受到影响。
基于以上的这些，我可以把代码重构成左关联：

 




def build_left_associativity(tree):
  new_nodes = _recurse_tree(tree, build_left_associativity)
  if tree.name in fix_assoc_rules:
    while len(new_nodes)>3:
      new_nodes[:3] = [RuleMatch(tree.name, new_nodes[:3])]
  return RuleMatch(tree.name, new_nodes)



但是，我并不会这样做。我需要更少的代码，并且把计算代码换成处理列表会比重构整棵树需要更少的代码。
第五步：运算器
对树的运算非常简单。只需用与后处理的代码相似的方式对树进行遍历（即 DFS 后序），并按照其中的每条规则进行运算。对于运算器，因为我们使用了递归算法，所以每条规则必须只包含数字和操作符。代码如下：

 




bin_calc_map = {'*':mul, '/':div, '+':add, '-':sub}
def calc_binary(x):
  while len(x) > 1:
    x[:3] = [ bin_calc_map[x[1]](x[0], x[2]) ]
  return x[0]
 
calc_map = {
  'NUM' : float,
  'atom': lambda x: x[len(x)!=1],
  'neg' : lambda (op,num): (num,-num)[op=='-'],
  'mul' : calc_binary,
  'add' : calc_binary,
}
 
def evaluate(tree):
  solutions = _recurse_tree(tree, evaluate)
  return calc_map.get(tree.name, lambda x:x)(solutions)



我使用 calc_binary 函数进行加法和减法运算（以及它们的同阶运算）。它以左结合的方式计算列表中的这些运算，这使得我们的 LL语法不太容易获取结果。
第六步：REPL
最朴实的REPL：

 




if __name__ == '__main__':
  while True:
    print( calc(raw_input('> ')) )



不要让我解释它 :)

附录：将它们合并：一个70行的计算器

 




'''A Calculator Implemented With A Top-Down, Recursive-Descent Parser'''
# Author: Erez Shinan, Dec 2012
 
import re, collections
from operator import add,sub,mul,div
 
Token = collections.namedtuple('Token', ['name', 'value'])
RuleMatch = collections.namedtuple('RuleMatch', ['name', 'matched'])
 
token_map = {'+':'ADD', '-':'ADD', '*':'MUL', '/':'MUL', '(':'LPAR', ')':'RPAR'}
rule_map = {
  'add' : ['mul ADD add', 'mul'],
  'mul' : ['atom MUL mul', 'atom'],
  'atom': ['NUM', 'LPAR add RPAR', 'neg'],
  'neg' : ['ADD atom'],
}
fix_assoc_rules = 'add', 'mul'
 
bin_calc_map = {'*':mul, '/':div, '+':add, '-':sub}
def calc_binary(x):
  while len(x) > 1:
    x[:3] = [ bin_calc_map[x[1]](x[0], x[2]) ]
  return x[0]
 
calc_map = {
  'NUM' : float,
  'atom': lambda x: x[len(x)!=1],
  'neg' : lambda (op,num): (num,-num)[op=='-'],
  'mul' : calc_binary,
  'add' : calc_binary,
}
 
def match(rule_name, tokens):
  if tokens and rule_name == tokens[0].name:   # Match a token?
    return tokens[0], tokens[1:]
  for expansion in rule_map.get(rule_name, ()):  # Match a rule?
    remaining_tokens = tokens
    matched_subrules = []
    for subrule in expansion.split():
      matched, remaining_tokens = match(subrule, remaining_tokens)
      if not matched:
        break  # no such luck. next expansion!
      matched_subrules.append(matched)
    else:
      return RuleMatch(rule_name, matched_subrules), remaining_tokens
  return None, None  # match not found
 
def _recurse_tree(tree, func):
  return map(func, tree.matched) if tree.name in rule_map else tree[1]
 
def flatten_right_associativity(tree):
  new = _recurse_tree(tree, flatten_right_associativity)
  if tree.name in fix_assoc_rules and len(new)==3 and new[2].name==tree.name:
    new[-1:] = new[-1].matched
  return RuleMatch(tree.name, new)
 
def evaluate(tree):
  solutions = _recurse_tree(tree, evaluate)
  return calc_map.get(tree.name, lambda x:x)(solutions)
 
def calc(expr):
  split_expr = re.findall('[\d.]+|[%s]' % ''.join(token_map), expr)
  tokens = [Token(token_map.get(x, 'NUM'), x) for x in split_expr]
  tree = match('add', tokens)[0]
  tree = flatten_right_associativity( tree )
  return evaluate(tree)
 
if __name__ == '__main__':
  while True:
    print( calc(raw_input('> ')) )