def test_letrec(self):
f, k, function = il.Var('f'), il.Var('k'), il.Var('function')
result = cps(letrec([(f, lamda((), f()))], f()))
expect = il.Clamda(v, il.Assign(f, v), v)(il.Lamda(
(k, ),
il.Clamda(function, function(k))(f)))
eq_(result, expect)
def test_findall2(self):
cut_or_cont = il.Var('cut_or_cont')
x, y = Var('x'), Var('y')
findall_result = il.Var('findall_result')
result = cps(findall(or_(1, 2), x, y))
expect = 1
eq_(result, expect)
def test_function2(self):
x = il.Var('x')
f = il.Var('f')
result = optimize(
il.Begin((il.Assign(f, il.Lamda(
(x, ), f(il.Integer(1)))), il.Apply(f, (il.Integer(3), )))))
expect = il.Begin((il.Assign(f, il.Lamda(
(x, ), f(il.Integer(1)))), il.Apply(f, (il.Integer(3), ))))
eq_(result, expect)
def test_function(self):
x = il.Var('x')
f = il.Var('f')
result = optimize(
il.Apply(
il.Function(
f, (x, ),
il.If(il.Eq(x, il.Integer(1)), il.Integer(1),
f(il.sub(x, il.Integer(1))))), (il.Integer(3), )))
expect = f(il.Integer(2))
eq_(result, expect)
def test_if_assign1(self):
x = il.Var('x')
y = il.Var('y')
exp = il.begin(il.Assign(x, il.Integer(1)),
il.if_(y, il.Assign(x, il.Integer(2)), x))
result = optimize(exp)
expect = il.begin(il.Assign(x, il.Integer(1)),
il.if_(y, il.Assign(x, il.Integer(2)), 1))
eq_(result, expect)
eq_(result.statements[0]._removed, il.unknown)
eq_(result.statements[0].removed(), True)
def test_if_assign5(self):
x = il.Var('x')
y = il.Var('y')
exp = il.begin(
il.Assign(x, il.Integer(1)),
il.if_(y, il.Assign(x, il.Integer(2)), il.Assign(x,
il.Integer(3))),
il.Prin(x))
result = optimize(exp)
expect = exp
eq_(result, expect)
eq_(result.statements[0].removed(), True)
eq_(result.statements[1].then.removed(), False)
def test_repeat(self):
function = il.Var('function')
result = cps(repeat)
expect = il.begin(il.SetFailCont(function),
il.CFunction(function, v,
done()(v)))
eq_(result, expect)
def between(compiler, cont, lower, upper, mid):
lower1 = compiler.new_var(il.ConstLocalVar('lower'))
upper1 = compiler.new_var(il.ConstLocalVar('upper'))
mid1 = compiler.new_var(il.ConstLocalVar('mid'))
fc = compiler.new_var(il.ConstLocalVar('fc'))
i = compiler.new_var(il.Var('i'))
v = compiler.new_var(il.ConstLocalVar('v'))
return lower.cps(compiler, il.clamda(lower1,
upper.cps(compiler, il.clamda(upper1,
mid.cps(compiler, il.clamda(mid1,
il.If(il.IsLogicVar(mid1),
il.begin(
il.Assign(i, lower1),
il.Assign(fc, il.failcont),
il.SetFailCont(il.clamda(v,
il.If(il.Eq(i, upper1),
il.Begin((
il.Assign(il.failcont, fc),
fc(il.FALSE))),
il.Begin((
il.AddAssign(i, il.Integer(1)),
il.SetBinding(mid1, i),
cont(il.TRUE)))))),
il.SetBinding(mid1, lower1),
cont(il.TRUE)),
il.If(il.Cle(lower1, mid1, upper1),
cont(il.TRUE),
il.failcont(il.FALSE)))))
))))
def test_assign2(self):
x = il.Var('x')
exp = il.begin(il.Assign(x, il.Integer(1)),
il.Assign(x, il.Integer(2)))
result = optimize(exp)
expect = exp
eq_(result, expect)
eq_(result.statements[0]._removed, True)
eq_(result.statements[0].removed(), True)
def greedy_some2(compiler, cont, item, template, result):
template = template.interlang()
result = result.interlang()
item_matched = compiler.new_var(il.Var('item_matched'))
v = compiler.new_var(il.ConstLocalVar('v'))
v2 = compiler.new_var(il.ConstLocalVar('v'))
fc = compiler.new_var(il.ConstLocalVar('old_failcont'))
greedy_some_fcont = compiler.new_var(il.ConstLocalVar('greedy_some_fcont'))
greedy_some_cont = compiler.new_var(il.ConstLocalVar('greedy_some_cont'))
append_result_cont = il.clamda(
v2, il.ListAppend(result, il.GetValue(template)),
greedy_some_cont(il.TRUE))
return il.begin(
il.Assign(result, il.empty_list), il.Assign(fc, il.failcont),
il.cfunction(greedy_some_fcont, v, il.SetFailCont(fc), cont(il.TRUE)),
il.cfunction(greedy_some_cont, v, il.SetFailCont(greedy_some_fcont),
item.cps(compiler, append_result_cont)),
item.cps(compiler, append_result_cont))
def times1(compiler, cont, item, expect_times):
expect_times = expect_times.interlang()
i = compiler.new_var(il.Var('i'))
times_cont = compiler.new_var(il.ConstLocalVar('times_cont'))
v = compiler.new_var(il.ConstLocalVar('v'))
return il.begin(
il.Assert(
il.And(il.Isinstance(expect_times, il.Int),
il.Gt(expect_times, il.Integer(0)))),
il.Assign(i, il.Integer(0)),
il.cfunction(
times_cont, v,
item.cps(
compiler,
il.clamda(
v, il.AddAssign(i, il.Integer(1)),
il.If(il.Eq(i, expect_times), cont(v),
times_cont(il.TRUE)))))(il.TRUE))
def times2(compiler, cont, item, expect_times, template, result):
expect_times = expect_times.interlang()
template = template.interlang()
result = result.interlang()
i = compiler.new_var(il.Var('i'))
times_cont = compiler.new_var(il.ConstLocalVar('times_cont'))
v = compiler.new_var(il.ConstLocalVar('v'))
return il.begin(
il.Assert(
il.And(il.Isinstance(expect_times, il.Int),
il.Gt(expect_times, il.Integer(0)))),
il.Assign(result, il.empty_list), il.Assign(i, il.Integer(0)),
il.cfunction(
times_cont, v,
item.cps(
compiler,
il.clamda(
v, il.AddAssign(i, il.Integer(1)),
il.ListAppend(result, il.GetValue(template)),
il.If(il.Eq(i, expect_times), cont(v),
times_cont(il.TRUE)))))(il.TRUE))
def test_any(self):
any_cont = il.Var('any_cont')
result = cps(any(1, nongreedy))
expect = 1
eq_(result, expect)
def test_char2(self):
x = Var('x')
text, pos = il.Var('text'), il.Var('pos')
result = cps(char(x))
expect = 2
eq_(result, expect)
def test_char(self):
text, pos = il.Var('text'), il.Var('pos')
result = cps(char('a'))
expect = 1
eq_(result, expect)
def test_eoi(self):
x = il.Var('x')
result = cps(eoi)
expect = 1
eq_(result, expect)
def test_if_3(self):
x = il.Var('x')
result = optimize(il.if_(x, il.if_(x, 2, 3), il.if_(x, 4, 5)))
expect = il.if_(x, 2, 5)
eq_(result, expect)
def test_assign1(self):
x = il.Var('x')
result = optimize(il.Assign(x, il.Integer(1)))
expect = il.Assign(x, il.Integer(1))
eq_(result, expect)
# -*- coding: utf-8 -*-
from nose.tools import eq_, ok_, assert_raises
import dao
from dao.compilebase import Compiler, Environment, VariableNotBound
from dao.builtins import begin, quote, assign, if_, let, letrec
from dao.builtins import add
from dao.builtins import fail, succeed, or_, unify, repeat, any, nongreedy, LogicVar
from dao.builtins import lamda, add
from dao.command import Var
from dao import interlang as il
v, fc = il.Var('v'), il.Var('fc')
a0, a1, a2, a3, a4 = tuple(il.Var('a' + repr(i)) for i in range(5))
class Done(il.Clamda):
def __repr__(self):
return 'done()'
def done():
return Done(v, v)
def cps(exp):
return il.element(exp).cps(Compiler(), done())
def interlang(self): return il.Var(self.name)
def test_or(self):
cut_or_cont = il.Var('cut_or_cont')
result = cps(or_(1, 2))
expect = 1
eq_(result, expect)
def test_simple(self):
eq_(generate_code(1), '1')
eq_(generate_code(il.Var('a')), 'a')
eq_(generate_code('a'), "'a'")
eq_(generate_code(il.Assign(v, il.Integer(1))), "v = 1")
eq_(generate_code(il.add(v, il.Integer(1))), "(v)+(1)")
def test_lambda_apply2(self):
v1 = il.Var('v1')
result = optimize(il.Clamda(v1, v1)(v))
expect = v
eq_(result, expect)
def test_any2(self):
text, pos = il.Var('text'), il.Var('pos')
any_cont = il.Var('any_cont')
result = cps(any(char('1')))
expect = 1
eq_(result, expect)
def test_let(self):
x, y, k = il.Var('x'), il.Var('y'), il.Var('k')
result = cps(let(((x, 1), ), x))
expect = il.Clamda(x, done()(x))(1)
eq_(result, expect)
def test_lambda(self):
x, y, k = Var('x'), Var('y'), il.Var('k')
result = cps(lamda((x, y), 1))
expect = done()(lamda((x, y, k), k(1)))
eq_(result, expect)
def test_if_2(self):
x = il.Var('x')
result = optimize(il.if_(x, 2, il.if_(x, 3, 4)))
expect = il.if_(x, 2, 4)
eq_(result, expect)
def test_unify3(self):
x = il.Var('x')
result = cps(unify(x, 2))
expect = 1
eq_(result, expect)
def test_or(self):
cut_or_cont = il.Var('cut_or_cont')
v1 = il.Var('v1')
result = compile_optimize(or_(1, 2))
expect = 1
eq_(result, expect)
