def parse(self, tokens, wrap=True): self.tokens = [token for token in tokens] self.position = 0 program = self.parse_block(False) if wrap: return model.FunctionCall(model.Function([], program), []) return program
def parse_def(self): self.ensure_token('def') function_name = self.parse_name() arguments = self.parse_arguments() body = self.parse_block() function = model.Function(arguments, body) return model.FunctionDefinition(function_name, function)
def test_function_definition(): name = "foo" scope = model.Scope() n = model.Number(10) f = model.Function([], [n]) d = model.FunctionDefinition(name, f) d.evaluate(scope) assert scope[name] is f
def test_function_call(): arg_name = "arg" f = model.Function([arg_name], [model.Reference(arg_name)]) scope = model.Scope() f_name = "foo" f_r = model.Reference(f_name) scope[f_name] = f n = model.Number(10) call = model.FunctionCall(f_r, [n]) assert call.evaluate(scope) is n
def mytest(): printer = PrettyPrinter() cond2 = model.Conditional(model.Number(30), [model.Number(10)], [model.Number(20)]) cond = model.Conditional( model.Number(42), [model.Number(1), cond2, model.Number(3)], [model.Number(4), model.Number(5)]) cond3 = model.Conditional(model.Number(228), [], []) func2 = model.Function(('p111', 'p222'), [ model.Reference("x"), model.Print(model.Reference("p111")), model.Read("myVar") ]) fd2 = model.FunctionDefinition("anotherPrettyFunc", func2) func = model.Function( (), [model.UnaryOperation("-", model.Number(100000000)), fd2, cond, cond3]) fd = model.FunctionDefinition("myPrettyFunc", func) printer.visit(fd) asd = model.BinaryOperation( model.BinaryOperation(model.Number(123), "+", model.Reference("xx")), "*", model.UnaryOperation( "-", model.BinaryOperation(model.Reference("xx"), "+", model.Reference("yy")))) printer.visit(asd) asd2 = model.BinaryOperation( model.BinaryOperation(model.Number(123), "/", model.Reference("xx")), "/", model.BinaryOperation( model.BinaryOperation(model.Reference("xx"), "/", model.Reference("yy")), "/", model.BinaryOperation(model.Number(123), "/", model.Reference("yy")))) printer.visit(asd2) printer.visit(model.FunctionCall(model.Reference("func"), [asd, asd2])) cond4 = model.Conditional(model.Number(228), []) printer.visit(cond4)
def test_scope(): f = model.Function([], [model.Number(0)]) ft = model.Number(42) t = model.Number(10) parent = model.Scope() parent["foo"] = f parent["bar"] = t assert parent["bar"] is t assert parent["foo"] is f scope = model.Scope(parent) assert scope["bar"] is t scope["bar"] = ft assert scope["bar"] is ft assert parent["bar"] is t
def test_function_definition(self): scope = model.Scope() function = model.Function(["a"], [ model.Print( model.BinaryOperation(model.Reference('a'), '-', model.Reference("a"))) ]) definition = model.FunctionDefinition("f", function) folder = ConstantFolder() tree = folder.visit(definition) assert (isinstance(tree, model.FunctionDefinition) and tree.name == "f" and len(tree.function.args) == 1 and len(tree.function.body) == 1 and isinstance(tree.function.body[0], model.Print) and isinstance(tree.function.body[0].expr, model.Number) and tree.function.body[0].expr.value == 0)
def test_function_with_body_args(self): parent = model.Scope() parent["f"] = model.Function(("a", "b"), [ model.Print( model.BinaryOperation(model.Reference("a"), "+", model.Reference("b"))) ]) parent["x"] = model.Number(10) scope = model.Scope(parent) scope["y"] = model.Number(20) definition = model.FunctionDefinition("f", parent["f"]) printer = PrettyPrinter() result = printer.visit(definition) assert result == "def f(a, b) {\n\tprint (a) + (b);\n};\n" definition.evaluate(scope) call = model.FunctionCall( model.Reference("f"), [model.Number(5), model.UnaryOperation("-", model.Number(3))]) result = printer.visit(call) assert result == "f(5, -(3));\n"
def test_conditional(): scope = model.Scope() true = model.Number(1) false = model.Number(0) f = model.FunctionCall(model.Function([], [true]), []) cond = model.Conditional(true, None, None) cond.evaluate(scope) cond = model.Conditional(false, None, None) cond.evaluate(scope) cond = model.Conditional(true, [], None) cond.evaluate(scope) cond = model.Conditional(true, None, []) cond.evaluate(scope) cond = model.Conditional(false, [], None) cond.evaluate(scope) cond = model.Conditional(false, None, []) cond.evaluate(scope) cond = model.Conditional(true, [], []) cond.evaluate(scope) cond = model.Conditional(true, [], []) cond.evaluate(scope) cond = model.Conditional(true, [true], None) assert cond.evaluate(scope) is true cond = model.Conditional(false, None, [false]) assert cond.evaluate(scope) is false cond = model.Conditional(true, [f], None) assert cond.evaluate(scope) is true cond = model.Conditional(false, None, [f]) assert cond.evaluate(scope) is true # If one of the following assertions fail, it means that Conditional has # evaluated wrong branch. cond = model.Conditional(false, [true], None) assert cond.evaluate(scope) is not true cond = model.Conditional(false, [true], []) assert cond.evaluate(scope) is not true cond = model.Conditional(true, None, [false]) assert cond.evaluate(scope) is not false cond = model.Conditional(true, [], [false]) assert cond.evaluate(scope) is not false
def test_function_call(self): scope = model.Scope() scope["x"] = model.Number(10) function = model.Function(["a", "b", "c"], []) model.FunctionDefinition("f", function).evaluate(scope) call = model.FunctionCall(model.Reference("f"), [ model.BinaryOperation(model.Number(2), "*", model.Number(3)), model.BinaryOperation(model.Number(0), "*", model.Reference("x")), model.Reference("x") ]) folder = ConstantFolder() tree = folder.visit(call) assert (isinstance(tree, model.FunctionCall) and isinstance(tree.fun_expr, model.Reference) and tree.fun_expr.name == "f" and len(tree.args) == 3 and isinstance(tree.args[0], model.Number) and tree.args[0].value == 6 and isinstance(tree.args[1], model.Number) and tree.args[1].value == 0 and isinstance(tree.args[2], model.Reference) and tree.args[2].name == "x")
def main(): v = PrettyPrinter() v.visit(m.Print(m.Number(10))) v.visit(m.UnaryOperation('-', m.Number(10))) v.visit( m.BinaryOperation( m.BinaryOperation(m.Reference('foo'), '+', m.Number(7)), '*', m.Number(2))) v.visit(m.Read("read")) v.visit( m.Conditional( m.Number(5), [m.BinaryOperation(m.Reference('var'), '-', m.Number(-5))])) v.visit( m.FunctionDefinition( 'summer', m.Function(['a', 'b'], [ m.Print( m.BinaryOperation(m.Reference('a'), '+', m.Reference('b'))), m.BinaryOperation(m.Reference('a'), '+', m.Reference('b')) ]))) v.visit( m.FunctionCall( m.Reference('summer'), [m.Number(1), m.BinaryOperation(m.Number(2), '+', m.Number(3))])) v.visit( m.Print( m.Conditional(m.BinaryOperation(m.Number(4), '-', m.Number(4)), [], [ m.BinaryOperation(m.Number(9), '/', m.Number(3)), m.Reference('var') ]))) v.visit( m.FunctionDefinition( 'abs', m.Function(['a', 'b'], [ m.Conditional( m.BinaryOperation( m.BinaryOperation(m.Reference('a'), '-', m.Reference('b')), '>', m.Number(0)), [ m.Print( m.BinaryOperation(m.Reference('a'), '-', m.Reference('b'))) ], [ m.Print( m.BinaryOperation(m.Reference('b'), '-', m.Reference('a'))) ]) ]))) v.visit( m.FunctionCall( m.Reference('abs'), [m.Number(23), m.UnaryOperation('-', m.Number(-30))])) v.visit(m.FunctionDefinition('fu', m.Function([], []))) v.visit(m.FunctionCall(m.Reference('fu'), [])) v.visit(m.Print(m.BinaryOperation(m.Number(5), '&&', m.Number(6)))) v.visit(m.Print(m.BinaryOperation(m.Number(3), '<', m.Number(5)))) v.visit(m.Print(m.Conditional(m.Number(3), None, None))) v.visit(m.Print(m.BinaryOperation(m.Number(1), '||', m.Number(4))))
def test_empty_function_definition(self): function = model.Function([], []) definition = model.FunctionDefinition("foo", function) printer = PrettyPrinter() result = printer.visit(definition) assert result == "def foo() {\n};\n"
def visit_function_definition(self, func_def): return m.FunctionDefinition( func_def.name, m.Function(func_def.function.args, self.optimize_list(func_def.function.body)))
def test_function(): f = model.Function([], []) assert f.evaluate(model.Scope()) is f
def test_function(): n = model.Number(0) f = model.Function([], [n]) assert f.evaluate(model.Scope()) is n
def visit_function_definition(self, func_def): body = self.process_list(func_def.function.body) return model.FunctionDefinition( func_def.name, model.Function(func_def.function.args, body))