@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):
