def for_stmt(self, index, sequence, body, else_body=None):
counter = self.frame.gettemp('int')
item = self.factory.makePyObject(self.frame.gettemp("PyObject"))
seq = self.frame.gettemp("PyObject")
init = []
init.append(jast.Set(counter, jast.IntegerConstant(0)))
init.append(jast.Set(seq, self.visit(sequence).asAny()))
counter_inc = jast.PostOperation(counter, '++')
test = jast.Set(item.asAny(),
jast.Invoke(seq, "__finditem__", [counter_inc]))
test = jast.Operation('!=', test, jast.Identifier('null'))
suite = []
suite.append(self.set(index, item))
suite.append(self.visit(body))
suite = jast.Block(suite)
if else_body is not None:
else_body = jast.Block(self.visit(else_body))
wtmp = self.frame.gettemp('boolean')
ret = [init, jast.WhileElse(test, suite, else_body, wtmp)]
self.frame.freetemp(wtmp)
return ret
else:
return [init, jast.While(test, suite)]
def while_stmt(self, test, body, else_body=None):
stest = self.visit(test).nonzero()
sbody = jast.Block(self.visit(body))
if else_body is not None:
else_body = jast.Block(self.visit(else_body))
wtmp = self.frame.gettemp('boolean')
ret = jast.WhileElse(stest, sbody, else_body, wtmp)
self.frame.freetemp(wtmp)
return ret
else:
return jast.While(stest, sbody)
def visitWhile(self, node):
stest = self.visit(node.test).nonzero()
sbody = jast.Block(self.suite(node.body))
if node.orelse is not None:
orelse = jast.Block(self.suite(node.orelse))
wtmp = self.frame.gettemp('boolean')
ret = jast.WhileElse(stest, sbody, orelse, wtmp)
self.frame.freetemp(wtmp)
return ret
else:
return jast.While(stest, sbody)
def callSuperMethod(self, name, supername, access, ret, sig, throws=[]):
if self.issuperproxy:
return
self.supermethods[supername] = supername
args = [typeName(ret)]
argids = []
throws = filterThrows(throws)
for c in sig:
if isinstance(c, TupleType):
argname = c[1]
c = c[0]
else:
argname = "arg" + str(len(argids))
args.append((typeName(c), argname))
argid = jast.Identifier(argname)
argids.append(argid)
supercall = jast.Invoke(jast.Identifier("super"), name, argids)
if ret != Void.TYPE:
supercall = jast.Return(supercall)
supermethod = jast.Method(supername,
jast.Modifier.ModifierString(access), args,
jast.Block([supercall]), throws)
self.statements.append(supermethod)
return
def clean(node):
if not hasattr(node, 'exits'):
print node
if node.exits():
return node
return jast.Block(
[node, jast.Return(jast.GetStaticAttribute('Py', 'None'))])
def dumpFuncs(self):
meths = []
cases = []
args = ["PyObject", ("PyFrame", "frame")]
access = "private static"
callargs = [jast.Identifier("frame")]
for name, funcid, code in self.funccodes:
funcname = self.uniquename(name)
meths.append(jast.Method(funcname, access, args, clean(code)))
body = jast.Return(jast.InvokeStatic(self.name, funcname,
callargs))
cases.append(
[jast.IntegerConstant(funcid),
jast.FreeBlock([body])])
defaultCase = jast.FreeBlock([jast.Return(jast.Null)])
switch = jast.Block(
[jast.Switch(jast.Identifier('index'), cases, defaultCase)])
meths.insert(
0,
jast.Method("call_function", "public",
["PyObject", ("int", "index"),
("PyFrame", "frame")], switch))
self.superclass = "PyFunctionTable"
return meths
def visitIf(self, node):
test = self.visit(node.test).nonzero()
body = jast.Block(self.suite(node.body))
orelse = None
if node.orelse is not None:
orelse = jast.Block(self.suite(node.orelse))
if isinstance(node.test, ast.Name):
tname = self.getName(node.test.id)
if tname is not None and self.isAlwaysFalse(tname):
if node.orelse is None:
return jast.SimpleComment("if "+tname)
else:
return orelse
return jast.If(test, body, orelse)
def addPyProxyInterface(self):
self.statements.append(
jast.Declare('private PyInstance', jast.Identifier('__proxy')))
code = jast.Set(jast.Identifier("__proxy"), jast.Identifier("inst"))
code = jast.Block([code])
self.statements.append(
jast.Method("_setPyInstance", "public",
["void", ("PyInstance", "inst")], code))
code = jast.Block([jast.Return(jast.Identifier("__proxy"))])
self.statements.append(
jast.Method("_getPyInstance", "public", ["PyInstance"], code))
self.statements.append(
jast.Declare('private PySystemState',
jast.Identifier('__sysstate')))
code = jast.Set(jast.Identifier("__sysstate"), jast.Identifier("inst"))
code = jast.Block([code])
self.statements.append(
jast.Method("_setPySystemState", "public",
["void", ("PySystemState", "inst")], code))
code = jast.Block([jast.Return(jast.Identifier("__sysstate"))])
self.statements.append(
jast.Method("_getPySystemState", "public", ["PySystemState"],
code))
frozen = self.module.getFrozen()
this = jast.Identifier("this")
initargs = [
this,
jast.StringConstant(self.modname),
jast.StringConstant(self.name),
jast.Identifier("args"), self.packages, self.properties, frozen,
jast.StringArray(self.modules)
]
initproxy = jast.InvokeStatic("Py", "initProxy", initargs)
code = jast.Block([initproxy])
self.statements.append(
jast.Method("__initProxy__", "public",
["void", ("Object[]", "args")], code))
self.interfaces.append(org.python.core.PyProxy)
def toCellPrepend(self,code):
scope = self.scope
pre = []
for parmcell in scope.jy_paramcells:
syminf = scope.tbl.get(parmcell)
args = [jast.IntegerConstant(syminf.locals_index),
jast.IntegerConstant(syminf.env_index)]
pre.append(jast.Invoke(self.frame, "to_cell", args))
if not pre: return code
pre.append(jast.BlankLine())
return jast.Block(jast.flatten([pre,code]))
def makeCode(self):
comp = self.factory.getCompiler(self.def_compiler,
SrcGenCompiler.ClassFrame, self.scope,
self.name)
code = jast.Block([comp.parse(ast.Suite(self.body)),
jast.Return(jast.Invoke(comp.frame.frame,
"getf_locals", []))])
self.frame = comp.frame
self.pycode = self.def_compiler.top_compiler.module.getCodeConstant(
self.name, code, comp.frame)
return self.pycode
def makeClass(self):
mycode = self.dumpAll()
supername = self.superclass.__name__
if self.javaproxy is not None:
mycode = [mycode, self.javaproxy.dumpAll()]
self.superclass = self.javaproxy.superclass
self.interfaces = self.interfaces + self.javaproxy.interfaces
supername = self.javaproxy.supername
body = jast.Block(mycode)
return jast.Class(self.name, self.modifier, supername,
map(lambda i: i.__name__, self.interfaces), body)
def dumpConstants(self):
self.dumpCodes()
stmts = []
decls = []
for type, label, value in self.constants:
decls.append(jast.Declare("private static " + type, label))
stmts.append(jast.Set(label, value))
setconstants = jast.Method("initConstants", "private static", ["void"],
jast.Block(stmts))
decls.append(setconstants)
return decls
def wrapThrows(stmt, throws, retType):
if len(throws) == 0: return stmt
catches = []
throwableFound = 0
for i in range(len(throws)):
throw = throws[i]
exctype = throw
excname = jast.Identifier("exc%d" % i)
body = jast.Block([jast.Throw(excname)])
catches.append((exctype, excname, body))
if throw == "java.lang.Throwable":
throwableFound = 1
if not throwableFound:
body = jast.Block([
jast.Invoke(jast.Identifier("inst"), "_jthrow",
[jast.Identifier("t")]),
nullReturn(retType)
])
catches.append(("java.lang.Throwable", jast.Identifier("t"), body))
return jast.TryCatches(jast.Block([stmt]), catches)
def addClassDictInit(self):
self.interfaces.append(org.python.core.ClassDictInit)
namelist = jast.InvokeStatic(
"Py", "java2py", [jast.StringArray(self.supermethods.keys())])
code = jast.Invoke(jast.Identifier("dict"), "__setitem__",
[jast.StringConstant("__supernames__"), namelist])
code = jast.Block([code])
self.statements.append(
jast.Method("classDictInit", "static public",
["void", ("PyObject", "dict")], code))
def dumpMain(self):
if not hasattr(self, 'mainCode'):
return []
meths = []
self.interfaces.append("PyRunnable")
getmain = jast.Block([
jast.If(jast.Operation("==", self.mainCode, jast.Null),
jast.InvokeStatic(self.name, "initConstants", [])),
jast.Return(self.mainCode)
])
meths.append(jast.Method("getMain", "public", ["PyCode"], getmain))
return meths
def visitListComp(self, node):
# Since this code generated here is placed in its own
# java method, we need a new set of temp vrbls.
oldtmps = self.frame.temporaries
self.frame.temporaries = {}
lst = self.factory.makeList([])
lsttmp, lstcode = self.makeTemp(lst)
append = self.factory.makePyObject(jast.Invoke(lsttmp.asAny(),
"__getattr__", [jast.StringConstant("append")]))
appendtmp, appendcode = self.makeTemp(append)
self.list_comprehension_count += 1
tmp_append = "_[%d]" % self.list_comprehension_count
#tmp_append = "_[1]"
n = ast.Expr(ast.Call(ast.Name(tmp_append, ast.Name.Load, node),
[ node.elt ], [], None, None, node),
node);
for lc in node.generators[::-1]:
for ifs in lc.ifs[::-1]:
n = ast.If(ifs, [ n ], None, ifs);
n = ast.For(lc.target, lc.iter, [ n ], None, lc);
#visit(new Delete(new exprType[] { new Name(tmp_append, Name.Del) }));
stmts = [ lstcode ]
stmts.append(self.set_name(tmp_append, append))
#stmts.append(appendcode)
stmts.append(self.visit(n))
stmts.append(jast.Return(lsttmp.asAny()))
decs = self.frame.getDeclarations()
if len(decs) != 0:
stmts.insert(0, decs)
idx = self.module.addFunctionCode("__listcomprehension",
jast.Block(stmts))
self.freeTemp(lsttmp)
self.freeTemp(appendtmp)
self.frame.temporaries = oldtmps
return self.factory.makePyObject(
jast.InvokeLocal("__listcomprehension$%d" % (idx+1),
[jast.Identifier("frame")]))
def if_stmt(self, tests, else_body=None):
jtests = []
for test, body in tests:
tname = self.getName(test)
if tname is not None and self.isAlwaysFalse(tname):
continue
test = self.visit(test).nonzero()
body = jast.Block(self.visit(body))
jtests.append((test, body))
if else_body is not None:
else_body = jast.Block(self.visit(else_body))
if len(jtests) == 0:
if else_body is None:
return jast.SimpleComment("if " + tname)
else:
return else_body
if len(jtests) == 1:
return jast.If(jtests[0][0], jtests[0][1], else_body)
else:
return jast.MultiIf(jtests, else_body)
def visitFor(self, node):
iter = self.frame.gettemp('PyObject')
item = self.factory.makePyObject(self.frame.gettemp("PyObject"))
seq = self.visit(node.iter).asAny()
init = []
init.append(jast.Set(iter, jast.Invoke(seq, "__iter__", [])))
test = jast.Set(item.asAny(), jast.Invoke(iter, "__iternext__", []))
test = jast.Operation('!=', test, jast.Identifier('null'))
suite = []
suite.append(self.set(node.target, item))
suite.append(self.suite(node.body))
suite = jast.Block(suite)
if node.orelse is not None:
orelse = jast.Block(self.suite(node.orelse))
wtmp = self.frame.gettemp('boolean')
ret = [init, jast.WhileElse(test, suite, orelse, wtmp)]
self.frame.freetemp(wtmp)
return ret
else:
return [init, jast.While(test, suite)]
def makeCode(self): # now handles a,b style args too
# Add args to funcframe
ac = self.scope.ac
# Parse the body
comp = self.factory.getCompiler(self.def_compiler,
SrcGenCompiler.FunctionFrame, self.scope,
self.def_compiler.className)
for argname in ac.names:
comp.frame.setname(argname, self.factory.makePyObject(None))
tree = ast.Suite(self.body)
ac.appendInitCode(tree)
code = jast.Block([comp.parse(tree)])
# Set up a code object
self.pycode = self.def_compiler.top_compiler.module.getCodeConstant(
self.name, code, comp.frame)
self.frame = comp.frame
return self.pycode
def callConstructor(self, access, sig, throws=[], dosuper=1):
args = []
argids = []
objects = []
throws = filterThrows(throws)
for c in sig:
if isinstance(c, TupleType):
argname = c[1]
c = c[0]
else:
argname = "arg" + str(len(argids))
args.append((typeName(c), argname))
argid = jast.Identifier(argname)
argids.append(argid)
objects.append(makeObject(argid, c))
objects = jast.FilledArray("Object", objects)
stmts = []
this = jast.Identifier("this")
if dosuper:
supercall = jast.InvokeLocal("super", argids)
else:
supercall = jast.InvokeLocal("super", [])
## for saccess, ssig in self.jconstructors:
## if len(ssig) == len(sig):
## supercall = jast.InvokeLocal("super", argids)
## break
## else:
## supercall = jast.InvokeLocal("super", [])
frozen = self.module.getFrozen()
initargs = [objects]
initproxy = jast.InvokeLocal("__initProxy__", initargs)
code = jast.Block([supercall, initproxy])
self.statements.append(
jast.Constructor(self.name, jast.Modifier.ModifierString(access),
args, code, throws))
def dumpInitModule(self):
meths = []
dict = jast.Identifier("dict")
sargs = [
jast.StringConstant("__name__"),
jast.New("PyString", [jast.StringConstant(self.name)])
]
rargs = [
jast.Invoke(jast.New("_PyInner", []), "getMain", []), dict, dict
]
code = jast.Block([
jast.Invoke(dict, "__setitem__", sargs),
jast.InvokeStatic("Py", "runCode", rargs)
])
meths.append(
jast.Method("moduleDictInit", "public static",
["void", ("PyObject", "dict")], code))
return meths
def list_comprehension(self, node):
# Since this code generated here is placed in its own
# java method, we need a new set of temp vrbls.
oldtmps = self.frame.temporaries
self.frame.temporaries = {}
expr = node.getChild(0)
suite = node.getChild(1)
lst = self.factory.makeList([])
lsttmp, lstcode = self.makeTemp(lst)
append = self.factory.makePyObject(
jast.Invoke(lsttmp.asAny(), "__getattr__",
[jast.StringConstant("append")]))
appendtmp, appendcode = self.makeTemp(append)
self.listComprehensionStack.append((appendtmp, expr))
stmts = [lstcode, appendcode]
stmts.append(self.visit(suite))
stmts.append(jast.Return(lsttmp.asAny()))
decs = self.frame.getDeclarations()
if len(decs) != 0:
stmts.insert(0, decs)
self.listComprehensionStack.pop(-1)
idx = self.module.addFunctionCode("__listcomprehension",
jast.Block(stmts))
self.freeTemp(lsttmp)
self.freeTemp(appendtmp)
self.frame.temporaries = oldtmps
return self.factory.makePyObject(
jast.InvokeLocal("__listcomprehension$%d" % (idx + 1),
[jast.Identifier("frame")]))
def dumpMain(self):
meths = []
if self.javamain:
code = []
newargs = jast.Identifier("newargs")
code.append(
jast.Declare("String[]", newargs,
jast.NewArray("String", ["args.length+1"])))
code.append(
jast.Set(jast.Identifier("newargs[0]"),
jast.StringConstant(self.name)))
args = [
jast.Identifier('args'),
jast.IntegerConstant(0),
jast.Identifier('newargs'),
jast.IntegerConstant(1),
jast.Identifier('args.length')
]
code.append(
jast.InvokeStatic("java.lang.System", "arraycopy", args))
args = [
jast.GetStaticAttribute(
self.getclassname(self.name + '.' + self.pyinner.name),
"class"),
jast.Identifier('newargs'),
self.getPackages(qual=1),
self.getMainProperties(qual=1),
self.getFrozen(),
jast.StringArray(self.modules.keys())
]
code.append([jast.InvokeStatic("Py", "runMain", args)])
maincode = jast.Block(code)
meths.append(
jast.Method("main", "public static",
["void", ("String[]", "args")], maincode,
["java.lang.Exception"]))
return meths
def makeCode(self): # now handles a,b style args too
# Add args to funcframe
ac = self.scope.ac
# Parse the body
comp = self.factory.getCompiler(self.def_compiler,
SimpleCompiler.FunctionFrame,
self.scope,
self.def_compiler.className)
for argname in ac.names:
comp.frame.setname(argname, self.factory.makePyObject(None))
tree = self.body
if ac.init_code.numChildren > 0:
ac.init_code.jjtAddChild(tree, ac.init_code.numChildren)
tree = ac.init_code
code = jast.Block([comp.parse(tree)])
# Set up a code object
self.pycode = self.def_compiler.top_compiler.module.getCodeConstant(
self.name, code, comp.frame)
self.frame = comp.frame
return self.pycode
def compile(self, data, filename, name):
if self.javapackage is not None:
name = self.javapackage + '.' + name
data = data + '\n\n'
mod = PythonModule(name, filename, frozen=self.deep)
fact = ObjectFactory()
pi = SrcGenCompiler(mod, fact, options=self.options)
fact.parent = pi
code = pi.execstring(data)
# __file__
code.insert(
0,
jast.Invoke(jast.Identifier('frame'), "setglobal", [
jast.StringConstant('__file__'),
mod.getStringConstant(filename)
]))
code.insert(1, jast.BlankLine())
code = jast.Block(code)
mod.addMain(code, pi)
self.addDependencies(mod)
return mod
for i in [1,2,3]:
print i
def bar(x):
print x*10
y = x+2
print y
bar(42)
class Baz:
def eggs(self, x, y, z):
return x, y, z
b = Baz()
print b.eggs(1,2,3)
"""
if __name__ == '__main__':
mod = SrcGenCompiler.BasicModule("foo")
fact = ObjectFactory()
pi = SrcGenCompiler.SrcGenCompiler(mod, fact)
fact.parent = pi
code = jast.Block(pi.execstring(data))
mod.addMain(code, pi)
print mod.attributes.keys()
print mod.imports.keys()
print mod
mod.dump("c:\\jython\\tools\\jythonc2\\test")
def makeClass(self):
body = jast.Block(self.dumpAll())
return jast.Class(self.name, self.modifier, self.superclass,
self.interfaces, body)
[jast.StringConstant("__supernames__"), namelist])
code = jast.Block([code])
self.statements.append(
jast.Method("classDictInit", "static public",
["void", ("PyObject", "dict")], code))
def makeClass(self):
mycode = self.dumpAll()
body = jast.Block(mycode)
return jast.Class(self.name, self.modifier, self.supername,
map(lambda i: i.__name__, self.interfaces), body)
def getDescription(self):
COMMASPACE = ', '
ret = self.name + ' extends ' + self.supername
if len(self.interfaces) > 0:
ret = ret + ' implements ' + \
COMMASPACE.join(map(lambda i: i.__name__, self.interfaces))
return ret
if __name__ == '__main__':
import java
methods = [("init", None, None),
("enable", None, ("public", Void.TYPE, [(java.awt.Event,
'event')]))]
jp = JavaProxy("Foo", [java.util.Random],
methods) #applet.Applet], methods)
print jast.Block(jp.dumpAll())
def callMethod(self, name, access, ret, sig, throws=[], dosuper=1):
args = [typeName(ret)]
argids = []
objects = []
throws = filterThrows(throws)
for c in sig:
if isinstance(c, TupleType):
argname = c[1]
c = c[0]
else:
argname = "arg" + str(len(argids))
args.append((typeName(c), argname))
argid = jast.Identifier(argname)
argids.append(argid)
objects.append(makeObject(argid, c))
objects = jast.FilledArray("Object", objects)
stmts = []
this = jast.Identifier("this")
if isinstance(access, IntType) and isAbstract(access):
dosuper = 0
access = access & ~ABSTRACT
if not dosuper and not self.isAdapter:
getattr = jast.InvokeStatic("Py", "jgetattr",
[this, jast.StringConstant(name)])
else:
getattr = jast.InvokeStatic("Py", "jfindattr",
[this, jast.StringConstant(name)])
inst = jast.Identifier("inst")
if len(throws) == 0:
jcall = "_jcall"
else:
jcall = "_jcallexc"
jcall = makeReturn(jast.Invoke(inst, jcall, [objects]), ret)
jcall = wrapThrows(jcall, throws, ret)
if dosuper:
supercall = jast.Invoke(jast.Identifier("super"), name, argids)
if ret != Void.TYPE:
supercall = jast.Return(supercall)
supermethod = None
if not self.issuperproxy and name not in self.getCandSupermethods(
incl=0):
supermethod = jast.Method("super__" + name,
jast.Modifier.ModifierString(access),
args, jast.Block([supercall]),
throws)
self.supermethods["super__" + name] = "super__" + name
else:
if self.isAdapter:
supercall = nullReturn(ret)
else:
supercall = None
supermethod = None
if not dosuper and not self.isAdapter:
test = jcall
else:
test = jast.If(jast.Operation("!=", inst, jast.Null), jcall,
supercall)
code = jast.Block([jast.Declare("PyObject", inst, getattr), test])
meth = jast.Method(name, jast.Modifier.ModifierString(access), args,
code, throws)
if supermethod is not None:
self.statements.append(supermethod)
self.statements.append(meth)
def makeClass(self):
mycode = self.dumpAll()
body = jast.Block(mycode)
return jast.Class(self.name, self.modifier, self.supername,
map(lambda i: i.__name__, self.interfaces), body)
