def unify_head_item2(compiler, cont, arg, head_item): # for call with rules variable. arg = arg.interlang() if not isinstance(head_item, Var): # arg should be Var if isinstance(head_item, Cons): v = compiler.new_var(il.ConstLocalVar("v")) return do_unify_head_item2( il.ConsHead(arg), head_item.head, compiler, il.clamda(v, do_unify_head_item2(il.ConsTail(arg), head_item.tail, compiler, cont)), ) else: head_item = head_item.interlang() arg1 = compiler.new_var(il.ConstLocalVar("arg")) return il.begin( il.Assign(arg1, il.Deref(arg)), il.If( il.IsLogicVar(arg1), il.begin( il.SetBinding(arg1, head_item), il.append_failcont(compiler, il.DelBinding(arg1)), cont(il.TRUE) ), il.If(il.Eq(arg1, head_item), cont(TRUE), il.failcont(TRUE)), ), ) else: if not isinstance(head_item, LogicVar): return il.begin(il.Assign(head_item.interlang(), arg), cont(il.TRUE)) else: raise CompileTypeError
def unify_head_item2(compiler, cont, arg, head_item): # for call with rules variable. arg = arg.interlang() if not isinstance(head_item, Var): # arg should be Var if isinstance(head_item, Cons): v = compiler.new_var(il.ConstLocalVar('v')) return do_unify_head_item2(il.ConsHead(arg), head_item.head, compiler, il.clamda(v, do_unify_head_item2(il.ConsTail(arg), head_item.tail, compiler, cont))) else: head_item = head_item.interlang() arg1 = compiler.new_var(il.ConstLocalVar('arg')) return il.begin( il.Assign(arg1, il.Deref(arg)), il.If(il.IsLogicVar(arg1), il.begin(il.SetBinding(arg1, head_item), il.append_failcont(compiler, il.DelBinding(arg1)), cont(il.TRUE)), il.If(il.Eq(arg1, head_item), cont(TRUE), il.failcont(TRUE)))) else: if not isinstance(head_item, LogicVar): return il.begin( il.Assign(head_item.interlang(), arg), cont(il.TRUE)) else: raise CompileTypeError
def or2_fun(compiler, cont, clause1, clause2): v = compiler.new_var(il.ConstLocalVar('v')) v1 = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) parse_state = compiler.new_var(il.ConstLocalVar('parse_state')) bindings = compiler.new_var(il.LocalVar('bindings')) fc = compiler.new_var(il.ConstLocalVar('old_failcont')) if has_cut_or(clause1) or has_cut_or(clause2): cut_or_cont = compiler.new_var(il.ConstLocalVar('cut_or_cont')) or_cont = il.clamda(v, il.SetCutOrCont(cut_or_cont), cont(v)) return il.begin( il.Assign(cut_or_cont, il.cut_or_cont), il.Assign(parse_state, il.parse_state), il.Assign(bindings, il.Copy(il.bindings)), il.Assign(fc, il.failcont), il.SetCutOrCont(il.clamda(v2, il.Assign(il.parse_state, parse_state), il.SetBindings(bindings), fc(il.FALSE))), il.SetFailCont(il.clamda(v1, il.SetFailCont(fc), clause2.cps(compiler, or_cont))), clause1.cps(compiler, or_cont)) else: return il.begin( il.Assign(fc, il.failcont), il.SetFailCont(il.clamda(v1, il.SetFailCont(fc), clause2.cps(compiler, cont))), clause1.cps(compiler, cont))
def eval_unify(compiler, cont, x, y): x1 = compiler.new_var(il.ConstLocalVar('x')) y1 = compiler.new_var(il.ConstLocalVar('y')) return x.cps( compiler, il.clamda( x1, y.cps( compiler, il.clamda( y1, il.If( il.IsLogicVar(x1), il.begin( il.SetBinding(x1, y1), il.append_failcont(compiler, il.DelBinding(x1)), cont(il.TRUE)), il.If( il.IsLogicVar(y1), il.begin( il.SetBinding(y1, x1), il.append_failcont(compiler, il.DelBinding(y1)), cont(il.TRUE)), il.If(il.Eq(x1, y1), cont(il.TRUE), il.failcont(il.TRUE))))))))
def integer(compiler, cont, arg): '''integer''' text = compiler.new_var(il.ConstLocalVar('text')) pos = compiler.new_var(il.ConstLocalVar('pos')) p = compiler.new_var(il.LocalVar('p')) length = compiler.new_var(il.ConstLocalVar('length')) if isinstance(arg, Var): arg = arg.interlang() x = compiler.new_var(il.ConstLocalVar('x')) return il.Begin(( il.AssignFromList(text, pos, il.parse_state), il.Assign(length, il.Len(text)), il.If(il.Ge(pos, length), il.failcont(il.FALSE), il.If(il.Not(il.Cle(il.String('0'), il.GetItem(text, pos), il.String('9'))), il.failcont(il.FALSE), il.Begin(( il.Assign(p, il.add(pos, il.Integer(1))), il.while_(il.And(il.Lt(p, length), il.Cle(il.String('0'),il.GetItem(text, p),il.String('9'))), il.AddAssign(p, il.Integer(1))), il.Assign(x, il.Deref(arg)), il.If(il.IsLogicVar(x), il.begin(il.SetParseState(il.Tuple(text, p)), il.SetBinding(x, il.GetItem(text, il.Slice2(pos, p))), il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos)), il.DelBinding(x)), cont(il.GetItem(text, pos))), il.If(il.Isinstance(x, il.String('str')), il.If(il.Eq(x, il.GetItem(text, il.Slice2(pos, p))), il.begin(il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos))), il.SetParseState(il.Tuple(text, p)), cont(il.GetItem(text, pos))), il.failcont(il.NONE)), il.RaiseTypeError(x))))))))) elif isinstance(arg, il.String): return il.Begin(( il.AssignFromList(text, pos, il.parse_state), il.Assign(length, il.Len(text)), il.If(il.Ge(pos, length), il.failcont(il.FALSE), il.If(il.Not(il.Cle(il.String('0'), il.GetItem(text, pos), il.String('9'))), il.failcont(il.FALSE), il.Begin(( il.Assign(p, il.add(pos, il.Integer(1))), il.while_(il.And(il.Lt(p, length), il.Cle(il.String('0'),il.GetItem(text, p),il.String('9'))), il.AddAssign(p, il.Integer(1))), il.If(il.Eq(arg, il.GetItem(text, il.Slice2(pos, p))), il.begin(il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos))), il.SetParseState(il.Tuple(text, p)), cont(arg)), il.failcont(il.NONE)))))))) else: raise CompileTypeError
def test_unify2(self): x = LogicVar('x') result = compile_optimize(unify(x, 2)) x1 = il.LogicVar('x') x2 = il.ConstLocalVar('x') expect = il.begin(il.Assign(x2, il.Deref(LogicVar(x1))), il.If(il.IsLogicVar(x2), il.begin(il.SetBinding(x2, il.Integer(2)), il.TRUE), il.If(il.Eq(x2, il.Integer(2)), il.TRUE, il.failcont(il.TRUE)))) 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 cps_convert_unify_one_var(x, y, compiler, cont): x = x.interlang() y = y.interlang() x1 = compiler.new_var(il.ConstLocalVar(x.name)) return il.begin( il.Assign(x1, il.Deref(x)), #for LogicVar, could be optimized when generate code. il.If(il.IsLogicVar(x1), il.begin(il.SetBinding(x1, y), il.append_failcont(compiler, il.DelBinding(x1)), cont(il.TRUE)), il.If(il.Unify(x1, y), cont(il.TRUE), il.failcont(il.TRUE))))
def test_unify2(self): x = LogicVar('x') result = compile_optimize(unify(x, 2)) x1 = il.LogicVar('x') x2 = il.ConstLocalVar('x') expect = il.begin( il.Assign(x2, il.Deref(LogicVar(x1))), il.If( il.IsLogicVar(x2), il.begin(il.SetBinding(x2, il.Integer(2)), il.TRUE), il.If(il.Eq(x2, il.Integer(2)), il.TRUE, il.failcont(il.TRUE)))) eq_(result, expect)
def eval_unify(compiler, cont, x, y): x1 = compiler.new_var(il.ConstLocalVar('x')) y1 = compiler.new_var(il.ConstLocalVar('y')) return x.cps(compiler, il.clamda(x1, y.cps(compiler, il.clamda(y1, il.If(il.IsLogicVar(x1), il.begin(il.SetBinding(x1, y1), il.append_failcont(compiler, il.DelBinding(x1)), cont(il.TRUE)), il.If(il.IsLogicVar(y1), il.begin(il.SetBinding(y1, x1), il.append_failcont(compiler, il.DelBinding(y1)), cont(il.TRUE)), il.If(il.Eq(x1, y1), cont(il.TRUE), il.failcont(il.TRUE))))))))
def string_on_predicate1(compiler, cont, test): '''return current char and step if @test succeed, where @test: a python function with one argument, which tests on one char and return True or False @test must be registered with register_function''' test = test.interlang() text = compiler.new_var(il.ConstLocalVar('text')) pos = compiler.new_var(il.ConstLocalVar('pos')) length = compiler.new_var(il.ConstLocalVar('length')) p = compiler.new_var(il.LocalVar('p')) if not isinstance(test, il.PyFunction): raise DaoCompileTypeError(test) return il.Begin(( il.AssignFromList(text, pos, il.parse_state), il.Assign(length, il.Len(text)), il.If(il.Ge(pos, length), il.failcont(il.FALSE), il.If(il.Call(test, il.GetItem(text, pos)), il.begin( il.Assign(p, il.add(pos, il.Integer(1))), il.While(il.And(il.Lt(p, length), il.Call(test, il.GetItem(text, p))), il.AddAssign(p, il.Integer(1))), il.SetParseState(il.Tuple(text, p)), il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos))), cont(il.GetItem(text, il.Slice2(pos, p)))), il.failcont(il.FALSE)))))
def follow(compiler, cont, item): parse_state = compiler.new_var(il.ConstLocalVar('parse_state')) v = compiler.new_var(il.ConstLocalVar('v')) return il.begin( il.Assign(parse_state, il.parse_state), item.cps(compiler, il.clamda(v, il.SetParseState(parse_state), cont(v))))
def set_sequence(compiler, cont, sequence): old_parse_state = compiler.new_var(il.ConstLocalVar('old_parse_state')) sequence = sequence.interlang() return il.begin(il.Assign(old_parse_state, il.parse_state), il.SetParseState(il.Tuple(sequence, il.Integer(0))), il.append_failcont(compiler, il.SetParseState(old_parse_state)), cont(TRUE))
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_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 compile_to_python(exp, env, done=None): '''assemble steps from dao expression to python code''' original_exp = exp compiler = Compiler() if done is None: done = il.Done(compiler.new_var(il.ConstLocalVar('v'))) compiler.exit_block_cont_map = {} compiler.continue_block_cont_map = {} compiler.protect_cont = done if env is None: env = Environment() exp = element(exp) exp = exp.alpha(env, compiler) exp = exp.cps(compiler, done) exp.analyse(compiler) env = Environment() exp = exp.optimize(env, compiler) #exp = exp.tail_recursive_convert() function = compiler.new_var(il.ConstLocalVar('compiled_dao_function')) exp = il.Function(function, (), exp) exp = il.begin(*exp.pythonize(env, compiler)[0]) if isinstance(exp, il.Begin): exp = exp.statements[0] exp.body = exp.body.replace_return_with_yield() compiler = Compiler() result = exp.to_code(compiler) return prelude + result
def repeat(compiler, cont): v = compiler.new_var(il.ConstLocalVar('v')) function = compiler.new_var(il.ConstLocalVar('function')) return il.begin(il.cfunction(function, v, cont(v)), il.PrintLn(il.String('repeat')), il.SetFailCont(function), function(NONE))
def once(compiler, cont, exp): v = compiler.new_var(il.ConstLocalVar('v')) fc = compiler.new_var(il.ConstLocalVar('fc')) return il.begin( il.Assign(fc, il.failcont), exp.cps(compiler, il.clamda(v, il.SetFailCont(fc), cont(v))))
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 getvalue_default(compiler, cont, item, default=None): if default is None: default = NONE v = compiler.new_var(il.ConstLocalVar('v')) return il.begin( il.Assign(v, il.GetValue(item.interlang())), il.If(il.IsLogicVar(v), default.cps(compiler,cont), cont(v)))
def first_(compiler, cont, clause1, clause2): v = compiler.new_var(il.ConstLocalVar('v')) fc = compiler.new_var(il.ConstLocalVar('fc')) first_cont = il.clamda(v, il.SetFailCont(fc), cont(v)) return il.begin( il.Assign(fc, il.failcont), il.append_failcont(compiler, clause2.cps(compiler, first_cont)), clause1.cps(compiler, first_cont))
def literal(compiler, cont, arg): '''any given instance string''' text = compiler.new_var(il.ConstLocalVar('text')) pos = compiler.new_var(il.ConstLocalVar('pos')) p = compiler.new_var(il.LocalVar('p')) i = compiler.new_var(il.LocalVar('i')) x = compiler.new_var(il.ConstLocalVar('x')) length = compiler.new_var(il.ConstLocalVar('length')) length2 = compiler.new_var(il.ConstLocalVar('length2')) if isinstance(arg, Var): return il.Begin(( il.Assign(x, il.Deref(arg)), il.AssignFromList(text, pos, il.parse_state), il.Assign(length, il.Len(text)), il.Assign(length, il.Len(x)), il.Assign(i, il.Integer(0)), il.Assign(p, pos), il.while_(il.and_(il.Lt(i, length2), il.Lt(p, length), il.Eq(il.GetItem(text, p), il.GetItem(x, i))), il.AddAssign(p, il.Integer(1))), il.If(il.Lt(i, length2), il.failcont(il.NONE), il.begin(il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos))), il.SetParseState(il.Tuple(text, p)), cont(arg))))) elif isinstance(arg, String): arg = arg.interlang() return il.Begin(( il.AssignFromList(text, pos, il.parse_state), il.Assign(length, il.Len(text)), il.Assign(length2, il.Len(arg)), il.Assign(i, il.Integer(0)), il.Assign(p, pos), il.while_(il.and_(il.Lt(i, length2), il.Lt(p, length), il.Eq(il.GetItem(text, p), il.GetItem(arg, i))), il.AddAssign(p, il.Integer(1)), il.AddAssign(i, il.Integer(1)), ), il.If(il.Lt(i, length2), il.failcont(il.NONE), il.begin(il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos))), il.SetParseState(il.Tuple(text, p)), cont(arg))))) else: raise CompileTypeError
def char(compiler, cont, argument): text = compiler.new_var(il.ConstLocalVar('text')) pos = compiler.new_var(il.ConstLocalVar('pos')) if isinstance(argument, String): argument = argument.interlang() return il.Begin(( il.AssignFromList(text, pos, il.parse_state), il.If(il.Ge(pos, il.Len(text)), il.failcont(il.NONE), il.If(il.Eq(argument, il.GetItem(text, pos)), il.begin(il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos))), il.SetParseState(il.Tuple(text, il.add(pos, il.Integer(1)))), cont(il.GetItem(text, pos))), il.failcont(il.NONE))))) elif isinstance(argument, Var): v = compiler.new_var(il.ConstLocalVar('v')) argument = argument.interlang() argument1 = compiler.new_var(il.ConstLocalVar('argument')) return il.Begin(( il.AssignFromList(text, pos, il.parse_state), il.If(il.Ge(pos,il.Len(text)), il.failcont(il.FALSE), il.Begin(( il.Assign(argument1, il.Deref(argument)), #il.Prin(text), il.Prin(pos), il.PrintLn(argument1), il.If(il.Isinstance(argument1, il.Symbol('str')), il.If(il.Eq(argument1, il.GetItem(text, pos)), il.begin(il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos))), il.SetParseState(il.Tuple(text, il.add(pos, il.Integer(1)))), cont(il.GetItem(text, pos))), il.failcont(il.NONE)), il.If(il.IsLogicVar(argument1), il.begin(il.SetParseState(il.Tuple(text, il.add(pos, il.Integer(1)))), il.SetBinding(argument1, il.GetItem(text, pos)), il.append_failcont(compiler, il.SetParseState(il.Tuple(text, pos)), il.DelBinding(argument1)), cont(il.GetItem(text, pos))), il.RaiseTypeError(argument1)))))))) # elif isinstance(argument, il.LogicVar) #how about this? It should be include above. else: raise CompileTypeError(argument)
def unify_macro_head_item2(compiler, cont, arg, head_item): if isinstance(head_item, Var): if not isinstance(head_item, LogicVar): return il.begin( il.Assign(head_item.interlang(), arg), cont(il.TRUE)) else: v = compiler.new_var(il.ConstLocalVar('v')) head_item = head_item.interlang() arg1 = compiler.new_var(il.ConstLocalVar('arg')) head1 = compiler.new_var(il.ConstLocalVar('head')) return il.begin( il.Assign(arg1, il.Deref(arg)), #for LogicVar, could be optimized when generate code. il.Assign(head1, il.Deref(head_item)), il.If(il.IsLogicVar(arg1), il.begin(il.SetBinding(arg1, head1), il.append_failcont(compiler, il.DelBinding(arg1)), cont(il.TRUE)), il.begin( il.If(il.IsLogicVar(head1), il.begin(il.SetBinding(head1, arg1), il.append_failcont(compiler, il.DelBinding(head1)), cont(il.TRUE)), il.If(il.Eq(arg1, head1), cont(il.TRUE), il.failcont(il.FALSE)))))) else: arg1 = compiler.new_var(il.ConstLocalVar('arg')) return il.begin( il.Assign(arg1, il.Deref(arg)), il.If(il.IsLogicVar(arg1), il.begin(il.SetBinding(arg1, head_item), il.append_failcont(compiler, il.DelBinding(arg1)), cont(il.TRUE)), il.If(il.Eq(arg1, head_item), cont(TRUE), il.failcont(TRUE))))
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 test_if_assign7(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.Assign(y, il.add(x, il.Integer(3))), il.Prin(y), ) result = optimize(exp) expect = il.begin(il.Assign(x, il.Integer(1)), il.if_(y, il.Assign(x, il.Integer(2)), il.Assign(x, il.Integer(3))), il.Assign(y, il.add(x, il.Integer(3))), il.Prin(y), ) eq_(result, expect) eq_(result.statements[0].removed(), True) eq_(result.statements[1].then.removed(), False)
def greedy_any1(compiler, cont, item): v = compiler.new_var(il.ConstLocalVar('v')) fc = compiler.new_var(il.ConstLocalVar('old_failcont')) greedy_any_fcont = compiler.new_var(il.ConstLocalVar('greedy_any_fcont')) greedy_any_cont = compiler.new_var(il.ConstLocalVar('greedy_any_cont')) return il.begin( il.Assign(fc, il.failcont), il.cfunction(greedy_any_fcont, v, il.SetFailCont(fc), cont(il.TRUE)), il.cfunction(greedy_any_cont, v, il.SetFailCont(greedy_any_fcont), item.cps(compiler, greedy_any_cont))(il.TRUE))
def parse(compiler, cont, predicate, parse_state): old_parse_state = compiler.new_var(il.ConstLocalVar('old_parse_state')) v = compiler.new_var(il.ConstLocalVar('v')) return il.begin(il.Assign(old_parse_state, il.parse_state), il.SetParseState(parse_state), il.append_failcont(compiler, il.SetParseState(old_parse_state)), predicate.cps(compiler, il.clamda(v, il.Assign(il.parse_state, old_parse_state), cont(v))))
def findall_1(compiler, cont, goal): v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) fc = compiler.new_var(il.ConstLocalVar('old_failcont')) return il.begin( il.Assign(fc, il.failcont), il.SetFailCont(il.clamda(v2, il.SetFailCont(fc), cont(v2))), goal.cps(compiler, il.Clamda(v, il.failcont(v))) )
def lazy_any1(compiler, cont, item): fc = compiler.new_var(il.ConstLocalVar('fc')) lazy_any_cont = compiler.new_var(il.ConstLocalVar('lazy_any_cont')) lazy_any_fcont = compiler.new_var(il.ConstLocalVar('lazy_any_fcont')) v = compiler.new_var(il.ConstLocalVar('v')) return il.begin( il.Assign(fc, il.failcont), il.cfunction(lazy_any_fcont, v, il.SetFailCont(fc), item.cps(compiler, lazy_any_cont)), il.cfunction(lazy_any_cont, v, il.SetFailCont(lazy_any_fcont), cont(il.TRUE))(il.TRUE))
def parse_sequence(compiler, cont, predicate, sequence): old_parse_state = compiler.new_var(il.ConstLocalVar('old_parse_state')) v = compiler.new_var(il.ConstLocalVar('v')) sequence = sequence.interlang() return il.begin(il.Assign(old_parse_state, il.parse_state), il.SetParseState(il.Tuple(sequence, il.Integer(0))), il.append_failcont(compiler, il.SetParseState(old_parse_state)), predicate.cps(compiler, il.clamda(v, il.SetParseState(old_parse_state), cont(v))))
def test_if_assign7(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.Assign(y, il.add(x, il.Integer(3))), il.Prin(y), ) result = optimize(exp) expect = il.begin( il.Assign(x, il.Integer(1)), il.if_(y, il.Assign(x, il.Integer(2)), il.Assign(x, il.Integer(3))), il.Assign(y, il.add(x, il.Integer(3))), il.Prin(y), ) eq_(result, expect) eq_(result.statements[0].removed(), True) eq_(result.statements[1].then.removed(), False)
def quasiquote(self, compiler, cont): result = compiler.new_var(il.LocalVar('result')) vars = tuple(compiler.new_var(il.ConstLocalVar('a'+repr(i))) for i in range(len(self.args))) body = (il.Assign(result, il.empty_list),)+tuple( il.If(il.Isinstance(var, il.Klass('UnquoteSplice')), il.AddAssign(result, il.Call(il.Symbol('list'), il.Attr(var, il.Symbol('item')))), il.ListAppend(result, var), ) for var in vars)+( cont(il.Call(il.Klass(self.__class__.__name__), il.QuoteItem(self.function), il.MakeTuple(result))),) fun = il.begin(*body) for var, arg in reversed(zip(vars, self.args)): fun = arg.quasiquote(compiler, il.clamda(var, fun)) return fun
def lazy_any1(compiler, cont, item): fc = compiler.new_var(il.ConstLocalVar('fc')) lazy_any_cont = compiler.new_var(il.ConstLocalVar('lazy_any_cont')) lazy_any_fcont = compiler.new_var(il.ConstLocalVar('lazy_any_fcont')) v = compiler.new_var(il.ConstLocalVar('v')) return il.begin( il.Assign(fc, il.failcont), il.cfunction(lazy_any_fcont, v, il.SetFailCont(fc), item.cps(compiler, lazy_any_cont)), il.cfunction(lazy_any_cont, v, il.SetFailCont(lazy_any_fcont), cont(il.TRUE)) (il.TRUE))
def test_if_assign3(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.Assign(x, il.Integer(4))) result = optimize(exp) expect = exp eq_(result, expect) eq_(result.statements[0].removed(), True) eq_(result.statements[1].then.removed(), True) eq_(result.statements[1].else_._removed, True) eq_(result.statements[1].else_.removed(), True)
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 test_if_assign3(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.Assign(x, il.Integer(4))) result = optimize(exp) expect = exp eq_(result, expect) eq_(result.statements[0].removed(), True) eq_(result.statements[1].then.removed(), True) eq_(result.statements[1].else_._removed, True) eq_(result.statements[1].else_.removed(), True)
def findall_2(compiler, cont, goal, template, bag): v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) fc = compiler.new_var(il.ConstLocalVar('old_failcont')) bag = bag.interlang() template = template.interlang() return il.begin( il.Assign(bag, il.empty_list), il.Assign(fc, il.failcont), il.SetFailCont(il.clamda(v2, il.SetFailCont(fc), cont(v2))), goal.cps(compiler, il.clamda(v, il.ListAppend(bag, il.GetValue(template)), il.failcont(v))))
def unify_parse_sequence(compiler, cont, sequence): x = compiler.new_var(il.ConstLocalVar('x')) try: sequence.cps_convert_unify except: sequence = sequence.interlang() return il.If(il.Eq(sequence, il.GetItem(il.parse_state, il.Integer(0))), cont(TRUE), il.failcont(il.TRUE)) return il.Begin(( il.Assign(x, il.Deref(sequence.interlang())), il.If(il.IsLogicVar(x), il.begin(il.SetBinding(x, il.GetItem(il.parse_state, il.Integer(0))), il.append_failcont(compiler, il.DelBinding(x)), cont(il.TRUE)), il.If(il.Eq(x, il.GetItem(il.parse_state, il.Integer(0))), cont(TRUE), il.failcont(il.TRUE)))))