自然语言式parsing

          got NUM(1)
Is NUM(1) an expr?
 Is NUM(1) a term?
  Is NUM(1) a number?
         is_term got -(-)
         -(-) was back
         is_expr got -(-)
         is_expr got NUM(2)
 Is NUM(2) an expr?
  Is NUM(2) a term?
   Is NUM(2) a number?
         is_term got *(*)
         is_term got NUM(33)
   Is NUM(33) a term?
    Is NUM(33) a number?
         is_term got None
         is_expr got None

import ply.lex as lex # pip install ply
tokens = ('NUM',); t_NUM = r'\d+'; literals = ['+', '-', '*', '/']
t_ignore  = ' \t'
def t_error(t): raise SyntaxError()
lexer = lex.lex()
prev_tk = None
def get_tk(who):
    global prev_tk
    if prev_tk != None: tk = prev_tk; prev_tk = None
    else: tk = lexer.token()
    if tk == None: print('\t', who + ' got None')
    else: print('\t', who + ' got ' + tk.type + '(' + tk.value + ')')
    return tk
def put_token_back(tk):
    global prev_tk
    prev_tk = tk
    print('\t', tk.type + '(' + tk.value + ') was back')
def print_token(tk, what, i): print(i * ' ', 'Is ' + tk.type + '(' + tk.value + ') ' + what + '?', sep='')
def Tk(fn, *args, **kwargs): fn(*args, **kwargs)
def is_NUM(tk, i):
    print_token(tk, 'a number', i)
    if tk.type != 'NUM': raise SyntaxError()
def is_term(tk, i):
    '''t : NUM | NUM '*' t | NUM '/' t'''
    print_token(tk, 'a term', i)
    Tk(is_NUM, tk, i + 1)
    tk = get_tk('is_term')
    if tk == None: return
    if tk.type == '*' or tk.type == '/': Tk(is_term, get_tk('is_term'), i + 1)
    else: put_token_back(tk)
def is_expr(tk, i):
    '''e : t | t '+' e | t '-' e'''
    if tk == None:
        if i == 0: return
        raise SyntaxError()
    print_token(tk, 'an expr', i)
    Tk(is_term, tk, i + 1)
    tk = get_tk('is_expr')
    if tk == None: return
    t = tk.type
    if t == '+' or t == '-': Tk(is_expr, get_tk('is_expr'), i + 1)
lexer.input('1 - 2*33')
try: Tk(is_expr, get_tk(''), 0)
except SyntaxError: print('\nAbout what talking you are?')

产生式是一组规则。分析时不是根据规则产生语言去和输入比较，而是检查输入是否符合规则。所以我觉得函数名叫is_expr比expr好理解点。再如：Tom是主语吗？Tom是名词吗？it是代词吗？头一句：token 是 表达式。a)只看了头一个token; b)这个命题是真命题还是假命题，let's try 一 try. 我们并没有分析并生成机器码/中间代码/语法树。分析过程中函数的递归调用关系/顺序靠堆栈表达。它隐藏着一颗动态的、不完整的树。

import ply.lex as lex # pip install ply
import ply.yacc as yacc
from functools import reduce
tokens = ('NUM',); t_NUM = r'\d+'; literals = ['+', '-', '*', '/']
def t_error(t): t.lexer.skip(1)
precedence = (('left', '+', '-'), ('left', '*', '/'))
s = []
def p_1(p): "e : NUM";     s.append(p_1.__doc__); p[0] = int(p[1])
def p_2(p): "e : e '+' e"; s.append(p_2.__doc__); p[0] = p[1] + p[3]
def p_3(p): "e : e '-' e"; s.append(p_3.__doc__); p[0] = p[1] - p[3]
def p_4(p): "e : e '*' e"; s.append(p_4.__doc__); p[0] = p[1] * p[3]
def p_5(p): "e : e '/' e"; s.append(p_5.__doc__); p[0] = p[1] / p[3]
def p_error(p): raise Exception()
lexer = lex.lex()
istr = '3 + 2 * 5'
print(istr, '=', yacc.yacc().parse(istr))
s.reverse(); print(reduce(lambda x,y:x+'\n'+y, s, ''))

上面这样的语法能写出Top down的吗？左递归是什么？请看 https://files.cnblogs.com/files/blogs/714801/topdownparsing.zip search(top down operator precedence parsing)

import ply.lex as lex # pip install ply
import ply.yacc as yacc
from functools import reduce
tokens = ('NUM',); t_NUM = r'\d+'; literals = ['+', '-', '*', '/']
def t_error(t): t.lexer.skip(1)
s = []
def p_1(p): "e : t";       s.append(p_1.__doc__); p[0] = p[1]
def p_2(p): "e : t '+' e"; s.append(p_2.__doc__); p[0] = p[1] + p[3]
def p_3(p): "e : t '-' e"; s.append(p_3.__doc__); p[0] = p[1] - p[3]
def p_4(p): "t : NUM";     s.append(p_4.__doc__ + ' ' + p[1]); p[0] = int(p[1])
def p_5(p): "t : NUM '*' t"; s.append(p_5.__doc__); p[0] = int(p[1]) * p[3]
def p_6(p): "t : NUM '/' t"; s.append(p_6.__doc__); p[0] = int(p[1]) / p[3]
def p_error(p): raise Exception()
lexer = lex.lex()
istr = '1 + 2 * 3 - 4'
print(istr, '=', yacc.yacc().parse(istr))
s.reverse(); print(reduce(lambda x,y:x+'\n'+y, s, ''))