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