def visitIntUnarySub(self, n, needs_to_be_simple):
(expr,ss) = self.dispatch(n.expr, True)
if needs_to_be_simple:
tmp = generate_name('usubtmp')
return (Name(tmp), ss + [make_assign(tmp, IntUnarySub(expr))])
else:
return (IntUnarySub(expr), ss)
def visitSLambda(self, n):
# Creat New Label
label_name = 'Q' + generate_name("SLambda")
# Recurse on code body
slambdas = []
(code, rslambdas) = self.dispatch(n.code, False)
slambdas += rslambdas
# Setup fvs list
fvs_n = generate_name("fvs")
fvs = []
# Setup each free variable
stmts = []
cnt = 0
for var in n.free_vars:
fvs += [Name(var)]
stmt = make_assign(var, Subscript(Name(fvs_n),
[InjectFrom(INT_t, Const(cnt))]))
stmts += [stmt]
cnt += 1
# Setup list of stmts
stmts += code.nodes
# Setup params, appending fvs
params = []
params += [fvs_n]
params += n.params
#Create SLambdaLabel
label = SLambdaLabel(label_name, len(params))
# Create new closed slambda
slambdas += [SLambda(params, StmtList(stmts), label_name)]
# Return Call and list of SLambdas
return (InjectFrom(BIG_t, CallCREATECLOSURE([label, List(fvs)])), slambdas)
def visitIntCmp(self, n, needs_to_be_simple):
(left, ss1) = self.dispatch(n.left, True)
(right, ss2) = self.dispatch(n.right, True)
if needs_to_be_simple:
tmp = generate_name('intequaltmp')
return (Name(tmp), ss1 + ss2 + [make_assign(tmp, IntCmp(n.op, (left, right)))])
else:
return (IntCmp(n.op, (left, right)), ss1 + ss2)
def visitCallFunc(self, n, needs_to_be_simple):
if isinstance(n.node, Name):
args_sss = [self.dispatch(arg, True) for arg in n.args]
args = [arg for (arg,ss) in args_sss]
ss = reduce(lambda a,b: a + b, [ss for (arg,ss) in args_sss], [])
if needs_to_be_simple:
tmp = generate_name('callfunctmp')
return (Name(tmp), ss + [make_assign(tmp, CallFunc(n.node, args))])
else:
return (CallFunc(n.node, args), ss)
else:
raise Exception('flatten: only calls to named functions allowed,'
'tried to call %s:%s' % (n.node, n.node.__class__))
def visitIndirectCallFunc(self, n, needs_to_be_simple):
if isinstance(n.node, CallFunc):
args_sss = [self.dispatch(arg, True) for arg in n.args]
args = [arg for (arg,ss) in args_sss]
ss = reduce(lambda a,b: a + b, [ss for (arg,ss) in args_sss], [])
(expr, sss) = self.dispatch(n.node, True)
ss += sss
if needs_to_be_simple:
tmp = generate_name('indirectcallfunctmp')
return (Name(tmp), ss + [make_assign(tmp, IndirectCallFunc(expr, args))])
else:
return (IndirectCallFunc(expr, args), ss)
else:
raise Exception('flatten: only indirectcalls to closure converted functions allowed')
def visitIfExp(self, n, needs_to_be_simple):
(teste, testss) = self.dispatch(n.test, True)
(thene, thenss) = self.dispatch(n.then, True)
(elsee, elsess) = self.dispatch(n.else_, True)
simple = IfExpFlat(teste,
InstrSeq(StmtList(thenss), thene),
InstrSeq(StmtList(elsess), elsee))
if needs_to_be_simple:
tmp = generate_name('ifexptmp')
myexpr = (Name(tmp))
myss = [make_assign(tmp, simple)]
else:
myexpr = simple
myss = []
return (myexpr, testss + myss)
def visitLet(self, n, needs_to_be_simple):
(rhs, ss1) = self.dispatch(n.rhs, True)
(body, ss2) = self.dispatch(n.body, True)
return (body, ss1 + [make_assign(n.var.name, rhs)] + ss2)
