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 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 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))
