@rule def expr(expr, MUL, expr_1): return expr * expr_1 @rule def expr(expr, POW, expr_1): return expr**expr_1 from pprint import pprint # pprint(lex) # pprint(rule) # table = {} calc.interpret('x = 8') calc.interpret('y = x - 6 ') calc.interpret('z = x ** y ') import unittest class Test(unittest.TestCase): def test(self): self.assertEqual(table, dict(x=8, y=2, z=64)) if __name__ == '__main__': unittest.main()
| input line ; line: '\n' | exp '\n' { printf ("\t%.10g\n", $1); } ; exp: NUM { $$ = $1; } | exp exp '+' { $$ = $1 + $2; } | exp exp '-' { $$ = $1 - $2; } | exp exp '*' { $$ = $1 * $2; } | exp exp '/' { $$ = $1 / $2; } /* Exponentiation */ | exp exp '^' { $$ = pow ($1, $2); } /* Unary minus */ | exp '-' { $$ = -$1; } ; """ # pprint([*YACC.tokenize(eg, True)]) yacc = LALR(YACC) tr = yacc.parse(eg) res = yacc.interpret(eg) # pprint(yacc.grammar.lexers) # pprint(yacc) # pprint(tr) print() print(res)
def E(E, mns, E_1): return '({} - {})'.format(E, E_1) def E(E, mul, E_1): return '({} * {})'.format(E, E_1) def E(E, div, E_1): return '({} / {})'.format(E, E_1) def E(E, pow, E_1): return '({} ** {})'.format(E, E_1) def E(num): return num def E(l, E, r): return E import pprint as pp # pp.pprint(E.parse_many('3 + 2 * 7')) # pp.pprint(E.parse_many('3 + 2 * 7 + 1')) # pp.pprint(E.interpret_many('3 + 2 * 7 + 1')) print(E) pp.pprint(E.precedence) psr = LALR(E) # print(psr.table.__len__()) # pp.pprint([*zip(psr.Ks, psr.ACTION)]) # print(psr.interpret('3 + 2 * 7')) # print(psr.interpret('3 * 2 + 7')) print(psr.interpret('3 + 2 * 7 / 5 - 1')) print(psr.interpret('3 + 2 * 7 ** 2 * 5'))
def expr(NUM): return int(NUM) @rule def expr(expr_1, ADD, expr_2): return expr_1 + expr_2 @rule def expr(expr, MUL, expr_1): return expr * expr_1 @rule def expr(expr, POW, expr_1): return expr**expr_1 # Complete making the parser after collecting things! pCalc.make() context = {} pCalc.interpret("x = 3") pCalc.interpret("y = x ^ 2") pCalc.interpret("z = x + y + 1") from pprint import pprint print(context) print(pCalc.precedence)
def expr(expr_1, ADD, expr_2): # With TeX-subscripts, meaning (expr → expr₁ + expr₂) return expr_1 + expr_2 def expr(expr, MUL, expr_1): # Can ignore one of the subscripts. return expr * expr_1 def expr(expr, POW, expr_1): return expr ** expr_1 from metaparse import cfg pCalc = LALR(G_Calc) # parse and tree t = pCalc.parse("x = 1 + 4 * 3 ** 2 + 5") print(t) # interpretation of tree print(t.translate()) print(table) assert table == {'x': 42} # direct interpretation # pCalc.interpret("x = 1 + 4 * 3 ** 2 + 5") pCalc.interpret("y = 5 + x * 2") pCalc.interpret("z = 99") print(table)
# fd.decorator_list = [] # ctx = {} # co = compile(ast.Module([fd]), '<ast>', 'exec') # exec(co, globals(), ctx) # pprint(ctx) pprint(E) p = LALR(E) # print(p.parse('3 + 2 * (5 + 1)')) # print(p.interpret('3 + 2 * (5 + 1)')) (p.parse('3 + 2 * (5 + 1)')) (p.interpret('3 + 2 * (5 + 1)')) s1 = dedent(getsource(E.semans[3])) pprint(s1) import dis # dis.dis(E.semans[3].__code__) def _fake_lex(*a): def dec(func): return func return dec def _fake_rule(func): return func
from pprint import pprint # pprint(p.grammar) # p.inspect_ACTION # t = p.parse('123') # pprint(t) tkns = (p.lexer.tokenize('123 + 8')) q = p.prepare() next(q) q.send(next(tkns)) q.send(next(tkns)) q.send(next(tkns)) t = q.send(END_TOKEN) assert t == mp.Just(131) t = p.parse('123 + 8') assert p.interpret('123 + 8') == 131 t = p.parse('123 + 2 * 1') assert p.interpret('123 + 2 * 1') == 125 assert p.interpret('123 + 2 * (1 + 2)') == 129 tough = ' + '.join(['(2 * (1 + (1)) + 2 * 2 + (3))'] * 100) assert p.interpret(tough) == eval(tough) # if replication is 10000 # %timeit p.interpret(tough) # 1 loops, best of 3: 346 ms per loop p_sexp = LALR() with p_sexp as (lex, rule):