def testCalculator(self): # simplified syntax, no expression, no relop class SimpleExpression(NTE): def calc(self): val = self.items[0].calc() for rep in self.items[1:]: val = rep.items[0].calc(val, rep.items[1].calc()) return val class Term(NTE): def calc(self): val = self.items[0].calc() for rep in self.items[1:]: val = rep.items[0].calc(val, rep.items[1].calc()) return val class Factor(NTE):pass class NumberFactor(Factor): def calc(self): return int(self.items[0].value) class ExpressionFactor(Factor): def calc(self): return self.items[1].calc() class AdditionOperator(TE): expression = r"\+|-" def calc(self, left, right): return { "+" : lambda: left+right, "-" : lambda: left-right }[self.value]() class MultiplicationOperator(TE): expression = r"\*|/|mod" def calc(self, left, right): return { "*" : lambda: left*right, "/" : lambda: left/right, "mod": lambda: left%right}[self.value]() class Number(TE): expression = r"\d+" class Sign(TE): expression = r"-|\+" class SignOpt(NTE):pass class Rep2(NTE):pass class Rep3(NTE):pass add_rule(SignOpt, (Sign,)) add_rule(SignOpt, ()) add_rule(Rep2, (AdditionOperator, Term )) add_rule(Rep3, (MultiplicationOperator, Factor)) add_rule(SimpleExpression, [ Term, [Rep2] ]) add_rule(Term, [ Factor, [Rep3] ]) add_rule(NumberFactor, [ Number ]) add_rule(ExpressionFactor, [ "(", SimpleExpression, ")" ]) self.assertEquals(parse("5+4", SimpleExpression).calc(), 5+4) self.assertEquals(parse("5+4+9+9+8+7", SimpleExpression).calc(), 5+4+9+9+8+7) self.assertEquals(parse("1*2+(5*3)+(10/2)", SimpleExpression).calc(), 1*2+(5*3)+(10/2)) self.assertEquals(parse("10/9*(10*(10))+1-1", SimpleExpression).calc(), 10/9*(10*(10))+1-1) dump_ruledb()
#! /usr/bin/env python2.6 from dynparser import parse, add_rule, reset_rules, NTE, TE from dynparser.namespace import dump_namespace from dynparser.ruledb import dump_ruledb from modBase import Program import logging logging.basicConfig(level=logging.DEBUG) parse_tree = parse(open("test.hla", "rt").read(), Program) logging.info("parsed: " + parse_tree.dump()) assert type(parse_tree) == Program open("output/main.c", "wt").write(parse_tree.render()) dump_namespace() dump_ruledb()
def testCalculator(self): # simplified syntax, no expression, no relop class SimpleExpression(NTE): def calc(self): val = self.items[0].calc() for rep in self.items[1:]: val = rep.items[0].calc(val, rep.items[1].calc()) return val class Term(NTE): def calc(self): val = self.items[0].calc() for rep in self.items[1:]: val = rep.items[0].calc(val, rep.items[1].calc()) return val class Factor(NTE): pass class NumberFactor(Factor): def calc(self): return int(self.items[0].value) class ExpressionFactor(Factor): def calc(self): return self.items[1].calc() class AdditionOperator(TE): expression = r"\+|-" def calc(self, left, right): return { "+": lambda: left + right, "-": lambda: left - right }[self.value]() class MultiplicationOperator(TE): expression = r"\*|/|mod" def calc(self, left, right): return { "*": lambda: left * right, "/": lambda: left / right, "mod": lambda: left % right }[self.value]() class Number(TE): expression = r"\d+" class Sign(TE): expression = r"-|\+" class SignOpt(NTE): pass class Rep2(NTE): pass class Rep3(NTE): pass add_rule(SignOpt, (Sign, )) add_rule(SignOpt, ()) add_rule(Rep2, (AdditionOperator, Term)) add_rule(Rep3, (MultiplicationOperator, Factor)) add_rule(SimpleExpression, [Term, [Rep2]]) add_rule(Term, [Factor, [Rep3]]) add_rule(NumberFactor, [Number]) add_rule(ExpressionFactor, ["(", SimpleExpression, ")"]) self.assertEquals(parse("5+4", SimpleExpression).calc(), 5 + 4) self.assertEquals( parse("5+4+9+9+8+7", SimpleExpression).calc(), 5 + 4 + 9 + 9 + 8 + 7) self.assertEquals( parse("1*2+(5*3)+(10/2)", SimpleExpression).calc(), 1 * 2 + (5 * 3) + (10 / 2)) self.assertEquals( parse("10/9*(10*(10))+1-1", SimpleExpression).calc(), 10 / 9 * (10 * (10)) + 1 - 1) dump_ruledb()