def label_str(prefix=""): parts = [] if len(prefix) > 0: parts.append(prefix) parts.append("label_") return pyc_gen_name.new("_".join(parts) )
def visit_ClassDef(self, cd): if cd == self.root: return Seq(body=[pyc_vis.visit(self, n) for n in cd.body]) else: tmpname = pyc_gen_name.new(self.refname + "_classattr") return Seq(body=[vis_cd(self.parent, cd, tmpname, self.scope), self.sattr(cd.name, var_ref(tmpname))])
def visit_Lambda(self, node, mappy, scope): name = pyc_gen_name.new(Localizer.scope_fmt(scope, "l")) (new_args, new_body) = self.localize_lambda(node, mappy, name) return ast.Lambda( args = new_args, body = new_body[0] )
def visit_Bloc(self, node): bname = pyc_gen_name.new("bloc") new_bd = BlocDef( name = bname, body = node.body, params = [var_ref("fvs")] + node.args.args ) pyc_lineage.bequeath_lineage(node, new_bd, self.__class__.__name__) (def_node, d) = pyc_vis.visit( self, new_bd ) self.log(self.depth_fmt("bloc vars: %r" % d["bloc_vars"])) locals = pyc_localize.locals(node) self.log(self.depth_fmt("locals: %r" % locals)) #note: the params which were heapified will have their normal #name in this params set, and their heapified versions are initialized #as a local to the value of the non-heap param params = set(pyc_astvisitor.names(node.args)) | set(["fvs"]) self.log(self.depth_fmt("params: %r" % params)) d["free_vars"] = (d["free_vars"] | d["bloc_vars"]) - locals - params self.log(self.depth_fmt("free vars: %r" % d["free_vars"])) def_node.fvs = list(d["free_vars"]) fvs_inits = [] for i in range(0, len(def_node.fvs)): assign = make_assign( var_set(def_node.fvs[i]), #is it ok to use a canonical name for fvs? make_subn("fvs", ast.Load, i) ) pyc_lineage.bequeath_lineage(node, assign, self.__class__.__name__) fvs_inits.append(pyc_ir.txform( assign, tracer=self.tracer )) def_node.body = fvs_inits + def_node.body d["defs"].append(def_node) d["bloc_vars"] = set([]) return ( InjectFromBig(arg=CreateClosure( name = bname, #dont set tracer in this txform b.c. self.tracer will run on this tree free_vars = pyc_ir.txform( ast.List( elts = [var_ref(x) for x in def_node.fvs], ctx = ast.Load() ) ) )), d )
def ClassRef(bases): assert_pyobj(bases) assert_big(bases.value) parents = [x.value.value for x in bases.value.value] + [object] name = pyc_gen_name.new("pyrun_class") return BigObj(type( name, tuple(parents), {} ))
def vis_cd(visitor, node, name, scope): if not isinstance(name, str): raise Exception("name must be a string") tmpname = pyc_gen_name.new("0class") bt = BodyTxformer(node, visitor, tmpname, scope) bt.tracer = visitor.tracer bt.log = lambda s: log("BodyTxformer : %s" % s) return Seq( body=( [ make_assign( var_set(tmpname), ClassRef(bases=ast.List(elts=[pyc_vis.visit(visitor, b) for b in node.bases], ctx=ast.Load())), ) ] + pyc_vis.visit(bt, node).body + [make_assign(var_set(name), var_ref(tmpname))] ) )
def visit_UserCall(self, node): (func_node, d) = pyc_vis.visit(self, node.func) arg_nodes = [] for a in node.args: output = pyc_vis.visit(self, a) (a_node, d) = self.default_accumulate(d, output) arg_nodes.append(a_node) lname = pyc_gen_name.new("closurecall") return ( Let( name = var_set(lname), rhs = func_node, body = ClosureCall( var = var_ref(lname), args = [ClosureFVS(var = var_ref(lname))] + arg_nodes ) ), d )
def visit_FunctionDef(self, node): tmpname = pyc_gen_name.new(self.refname + "_defattr") return Seq(body=[vis_fn(self.parent, node, tmpname, self.scope), self.sattr(node.name, var_ref(tmpname))])
def gen_name(self): return pyc_gen_name.new("ir_")
def __init__(self, value): AsmNode.__init__(self) self.value = value if GlobalString.cache.get(value, None) is None: GlobalString.cache[value] = pyc_gen_name.new("global_str_")
def gen_name(): return pyc_gen_name.new("temp_op")