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)