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 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 any2(compiler, cont, item, template, result): template = template.interlang() result = result.interlang() any_cont = compiler.new_var(il.ConstLocalVar('any_cont')) fc = compiler.new_var(il.ConstLocalVar('old_fail_cont')) v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) v3 = compiler.new_var(il.ConstLocalVar('v')) return il.Begin( (il.Assign(result, il.empty_list), il.cfunction( any_cont, v, il.Assign(fc, il.failcont), il.SetFailCont( il.clamda( v, il.SetFailCont( il.clamda( v3, il.if2(result, il.DelListItem(result, il.Integer(-1))), fc(v3))), cont(v))), item.cps( compiler, il.clamda(v2, il.ListAppend(result, il.GetValue(template)), any_cont(v2))))(il.NONE)))
def catch(compiler, cont, tag, *form): v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) k = compiler.new_var(il.LocalVar('cont')) return tag.cps(compiler, il.clamda(v, il.Assign(k, il.clamda(v2, cont(v2))), il.PushCatchCont(v, k), begin(*form).cps(compiler, cont)))
def catch(compiler, cont, tag, *form): v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) k = compiler.new_var(il.LocalVar('cont')) return tag.cps( compiler, il.clamda(v, il.Assign(k, il.clamda(v2, cont(v2))), il.PushCatchCont(v, k), begin(*form).cps(compiler, cont)))
def throw(compiler, cont, tag, form): v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) return tag.cps(compiler, il.clamda(v, form.cps(compiler, il.clamda(v2, compiler.protect_cont(NONE), il.FindCatchCont(v)(v2)))))
def cps(self, compiler, cont): # use cfunction, continue_block means recursive call. # tail recursive cfunction can be used to transform to while 1/break/continue. v = compiler.new_var(il.ConstLocalVar('v')) v1 = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) block_fun = compiler.new_var(il.ConstLocalVar('block_'+self.label.name)) compiler.exit_block_cont_map[self.label.name] = il.clamda(v1, cont(v1)) compiler.continue_block_cont_map[self.label.name] = il.clamda(v2, block_fun(v2)) return il.cfunction(block_fun, v, self.body.cps(compiler, cont))(il.NONE)
def cps_call(self, compiler, cont, args): #function = compiler.new_var(il.ConstLocalVar('function')) function = self.interlang() vars = tuple(compiler.new_var(il.ConstLocalVar('a'+repr(i))) for i in range(len(args))) body = il.Apply(function, (cont,)+vars) for var, item in reversed(zip(vars, args)): body = item.cps(compiler, il.clamda(var, body)) v = compiler.new_var(il.ConstLocalVar('v')) return self.cps(compiler, il.clamda(function,body))
def throw(compiler, cont, tag, form): v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) return tag.cps( compiler, il.clamda( v, form.cps( compiler, il.clamda(v2, compiler.protect_cont(NONE), il.FindCatchCont(v)(v2)))))
def unwind_protect(compiler, cont, form, *cleanup): v = compiler.new_var(il.ConstLocalVar('v')) v1 = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) old_protect_cont = compiler.protect_cont compiler.protect_cont = il.clamda(v, NONE) cleanup_protect = begin(*cleanup).cps(compiler, old_protect_cont) compiler.protect_cont.body = cleanup_protect cleanup_cont = il.clamda(v1, begin(*cleanup).cps(compiler, il.clamda(v2, cont(v1)))) result = form.cps(compiler, cleanup_cont) compiler.protect_cont = old_protect_cont return result
def contain(compiler, cont, container, member): container1 = compiler.new_var(il.ConstLocalVar('container')) container2 = compiler.new_var(il.ConstLocalVar('container')) member1 = compiler.new_var(il.ConstLocalVar('member')) member2 = compiler.new_var(il.ConstLocalVar('member')) return container.cps(compiler, il.clamda(container1, il.Assign(container2, il.GetValue(container1)), member.cps(compiler, il.clamda(member1, il.Assign(member2, il.GetValue(member1)), il.If(il.In(member2, container2), cont(il.TRUE), il.failcont(il.FALSE))))))
def cps(self, compiler, cont): # use cfunction, continue_block means recursive call. # tail recursive cfunction can be used to transform to while 1/break/continue. v = compiler.new_var(il.ConstLocalVar('v')) v1 = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) block_fun = compiler.new_var( il.ConstLocalVar('block_' + self.label.name)) compiler.exit_block_cont_map[self.label.name] = il.clamda(v1, cont(v1)) compiler.continue_block_cont_map[self.label.name] = il.clamda( v2, block_fun(v2)) return il.cfunction(block_fun, v, self.body.cps(compiler, cont))(il.NONE)
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 unwind_protect(compiler, cont, form, *cleanup): v = compiler.new_var(il.ConstLocalVar('v')) v1 = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) old_protect_cont = compiler.protect_cont compiler.protect_cont = il.clamda(v, NONE) cleanup_protect = begin(*cleanup).cps(compiler, old_protect_cont) compiler.protect_cont.body = cleanup_protect cleanup_cont = il.clamda( v1, begin(*cleanup).cps(compiler, il.clamda(v2, cont(v1)))) result = form.cps(compiler, cleanup_cont) compiler.protect_cont = old_protect_cont return result
def contain(compiler, cont, container, member): container1 = compiler.new_var(il.ConstLocalVar('container')) container2 = compiler.new_var(il.ConstLocalVar('container')) member1 = compiler.new_var(il.ConstLocalVar('member')) member2 = compiler.new_var(il.ConstLocalVar('member')) return container.cps( compiler, il.clamda( container1, il.Assign(container2, il.GetValue(container1)), member.cps( compiler, il.clamda( member1, il.Assign(member2, il.GetValue(member1)), il.If(il.In(member2, container2), cont(il.TRUE), 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 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 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 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 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 wrap_cut(compiler, cont, exp): cut_cont = il.ConstLocalVar("cut_cont") v = 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")) return il.begin( il.Assign(cut_cont, il.cut_cont), il.Assign(parse_state, il.parse_state), il.Assign(bindings, il.Copy(il.bindings)), il.Assign(fc, il.failcont), il.SetCutCont(il.clamda(v2, il.Assign(il.parse_state, parse_state), il.SetBindings(bindings), fc(il.FALSE))), il.SetFailCont(il.clamda(v1, il.SetFailCont(fc), il.Assign(il.cut_cont, cut_cont), fc(il.FALSE))), exp.cps(compiler, il.clamda(v, il.Assign(il.cut_cont, cut_cont), cont(v))), )
def any1(compiler, cont, item): any_cont = compiler.new_var(il.ConstLocalVar('any_cont')) fc = compiler.new_var(il.ConstLocalVar('old_fail_cont')) v = compiler.new_var(il.ConstLocalVar('v')) return il.cfunction( any_cont, v, il.Assign(fc, il.failcont), il.SetFailCont(il.clamda(v, il.SetFailCont(fc), cont(v))), item.cps(compiler, any_cont))(il.TRUE)
def cps_call(self, compiler, cont, args): function = self.interlang() k = compiler.new_var(il.ConstLocalVar('cont')) v = compiler.new_var(il.ConstLocalVar('v')) #macro_args = tuple(il.Lamda((), arg.cps(compiler, il.clamda(v, v))) #for arg in args) macro_args = tuple(il.Lamda((k,), arg.cps(compiler, k)) for arg in args) return self.cps(compiler, il.clamda(function, il.Apply(function, (cont,)+macro_args)))
def some1(compiler, cont, item): some_cont = compiler.new_var(il.ConstLocalVar('some_cont')) fc = compiler.new_var(il.ConstLocalVar('old_fail_cont')) v = compiler.new_var(il.ConstLocalVar('v')) some_cont = il.cfunction( some_cont, v, il.Assign(fc, il.failcont), il.SetFailCont(il.clamda(v, il.SetFailCont(fc), cont(v))), item.cps(compiler, some_cont)) return item.cps(compiler, some_cont)
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 any1(compiler, cont, item): any_cont = compiler.new_var(il.ConstLocalVar('any_cont')) fc = compiler.new_var(il.ConstLocalVar('old_fail_cont')) v = compiler.new_var(il.ConstLocalVar('v')) return il.cfunction(any_cont, v, il.Assign(fc, il.failcont), il.SetFailCont(il.clamda(v, il.SetFailCont(fc), cont(v))), item.cps(compiler, any_cont))(il.TRUE)
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 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 any2(compiler, cont, item, template, result): template = template.interlang() result = result.interlang() any_cont = compiler.new_var(il.ConstLocalVar('any_cont')) fc = compiler.new_var(il.ConstLocalVar('old_fail_cont')) v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) v3 = compiler.new_var(il.ConstLocalVar('v')) return il.Begin(( il.Assign(result, il.empty_list), il.cfunction(any_cont, v, il.Assign(fc, il.failcont), il.SetFailCont(il.clamda(v, il.SetFailCont(il.clamda(v3, il.if2(result, il.DelListItem(result, il.Integer(-1))), fc(v3))), cont(v))), item.cps(compiler, il.clamda(v2, il.ListAppend(result, il.GetValue(template)), any_cont(v2))))(il.NONE)))
def some1(compiler, cont, item): some_cont = compiler.new_var(il.ConstLocalVar('some_cont')) fc = compiler.new_var(il.ConstLocalVar('old_fail_cont')) v = compiler.new_var(il.ConstLocalVar('v')) some_cont = il.cfunction(some_cont, v, il.Assign(fc, il.failcont), il.SetFailCont(il.clamda(v, il.SetFailCont(fc), cont(v))), item.cps(compiler, some_cont)) return item.cps(compiler, some_cont)
def cps_call(self, compiler, cont, args): # see The 90 minute Scheme to C compiler by Marc Feeley raise CompileTypeError(self) function = compiler.new_var(il.ConstLocalVar('function')) vars = tuple(compiler.new_var(il.ConstLocalVar('a'+repr(i))) for i in range(len(args))) body = il.Apply(function, (cont,)+vars) for var, item in reversed(zip(vars, args)): body = item.cps(compiler, il.clamda(var, body)) v = compiler.new_var(il.ConstLocalVar('v')) macro_args1 = tuple(il.ExpressionWithCode(arg, il.Lamda((), arg.cps(compiler, il.clamda(v, v)))) for arg in args) macro_args2 = il.macro_args(macro_args1) return self.cps(compiler, il.clamda(function, il.If(il.IsMacro(function), il.If(il.IsMacroRules(function), il.Apply(function, (cont, macro_args2)), il.Apply(function, (cont,)+macro_args1)), body)))
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 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 lazy_some1(compiler, cont, item): fc = compiler.new_var(il.ConstLocalVar('fc')) lazy_some_cont = compiler.new_var(il.ConstLocalVar('lazy_some_cont')) lazy_some_fcont = compiler.new_var(il.ConstLocalVar('lazy_some_fcont')) v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) return il.begin( il.Assign(fc, il.failcont), il.cfunction(lazy_some_fcont, v, il.SetFailCont(fc), lazy_some_cont(il.TRUE)), il.cfunction(lazy_some_cont, v, item.cps(compiler, il.clamda(v2, il.SetFailCont(lazy_some_fcont), cont(il.TRUE))))(il.TRUE))
def wrap_cut(compiler, cont, exp): cut_cont = il.ConstLocalVar('cut_cont') v = 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')) return il.begin( il.Assign(cut_cont, il.cut_cont), il.Assign(parse_state, il.parse_state), il.Assign(bindings, il.Copy(il.bindings)), il.Assign(fc, il.failcont), il.SetCutCont(il.clamda(v2, il.Assign(il.parse_state, parse_state), il.SetBindings(bindings), fc(il.FALSE))), il.SetFailCont(il.clamda(v1, il.SetFailCont(fc), il.Assign(il.cut_cont, cut_cont), fc(il.FALSE))), exp.cps(compiler, il.clamda(v, il.Assign(il.cut_cont, cut_cont), cont(v))))
def lazy_some1(compiler, cont, item): fc = compiler.new_var(il.ConstLocalVar('fc')) lazy_some_cont = compiler.new_var(il.ConstLocalVar('lazy_some_cont')) lazy_some_fcont = compiler.new_var(il.ConstLocalVar('lazy_some_fcont')) v = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) return il.begin( il.Assign(fc, il.failcont), il.cfunction(lazy_some_fcont, v, il.SetFailCont(fc), lazy_some_cont(il.TRUE)), il.cfunction( lazy_some_cont, v, item.cps( compiler, il.clamda(v2, il.SetFailCont(lazy_some_fcont), cont(il.TRUE))))(il.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 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 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 cps_convert_unify(x, y, compiler, cont): if isinstance(x, Var): if isinstance(y, Var): return cps_convert_unify_two_var(x, y, compiler, cont) else: return cps_convert_unify_one_var(x, y, compiler, cont) else: if isinstance(y, Var): return cps_convert_unify_two_var(y, x, compiler, cont) else: if isinstance(x, Cons) and isinstance(y, Cons): v = compiler.new_var(il.ConstLocalVar('v')) return cps_convert_unify(x.head, y.head, compiler, il.clamda(v, cps_convert_unify(x.tail, y.tail, compiler, cont))) else: if x==y: return cont(il.TRUE) else: return il.failcont(il.FALSE)
def lazy_any2(compiler, cont, item, template, result): template = template.interlang() result = result.interlang() 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')) v1 = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) return il.begin( il.Assign(result, il.empty_list), il.Assign(fc, il.failcont), il.cfunction( lazy_any_fcont, v, il.SetFailCont(fc), item.cps( compiler, il.clamda(v2, il.ListAppend(result, il.GetValue(template)), lazy_any_cont(il.TRUE)))), il.cfunction(lazy_any_cont, v, il.SetFailCont(lazy_any_fcont), cont(il.TRUE))(il.TRUE))
def lazy_some2(compiler, cont, item, template, result): template = template.interlang() result = result.interlang() fc = compiler.new_var(il.ConstLocalVar('fc')) lazy_some_cont = compiler.new_var(il.ConstLocalVar('lazy_some_cont')) lazy_some_fcont = compiler.new_var(il.ConstLocalVar('lazy_some_fcont')) v = compiler.new_var(il.ConstLocalVar('v')) v1 = compiler.new_var(il.ConstLocalVar('v')) v2 = compiler.new_var(il.ConstLocalVar('v')) return il.begin( il.Assign(result, il.empty_list), il.Assign(fc, il.failcont), il.cfunction(lazy_some_fcont, v, il.SetFailCont(fc), lazy_some_cont(il.TRUE)), il.cfunction(lazy_some_cont, v, item.cps(compiler, il.clamda(v2, il.SetFailCont(lazy_some_fcont), il.ListAppend(result, il.GetValue(template)), cont(il.TRUE))))(il.TRUE))
def greedy_any2(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_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(result, il.empty_list), 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, il.clamda(v2, il.ListAppend(result, il.GetValue(template)), greedy_any_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))