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 visitImportFrom(self, node): modname = jast.StringConstant(node.module) module = self.get_module(node.module.split('.'), 0) if len(node.names) == 0: self.addModule(node.module, '*') self._loadNames(self._getnames(module), module) return jast.InvokeStatic("org.python.core.imp", "importAll", [modname, self.frame.frame]) topmodname = jast.StringConstant(node.module) modnames = [alias.name for alias in node.names] modnamesArray = jast.FilledArray( "String", map(lambda x: jast.StringConstant(x), modnames)) do_import = jast.InvokeStatic("org.python.core.imp", "importFrom", [topmodname, modnamesArray, self.frame.frame]) imp_accu = self.frame.gettemp('PyObject[]') stmts = [ jast.Set(imp_accu, do_import) ] for i in range(len(node.names)): modname = node.names[i].name asname = node.names[i].asname if asname is None: asname = modname code = jast.Subscript(imp_accu, i) stmts.append(self.set_name(asname, module.getattr(modname).makeReference(code))) stmts.append(jast.Set(imp_accu,jast.Null)) self.frame.freetemp(imp_accu) return stmts
def do_comp(self, x, compares, tmps): False = jast.GetStaticAttribute("Py", "Zero") op, other = compares[0] y = self.visit(other) if len(compares) > 1: ytmp = self.frame.gettemp("PyObject") tmps.append(ytmp) gety = self.factory.makePyObject(jast.Set(ytmp, y.asAny())) else: gety = y ops = { ast.Compare.Eq: "_eq", ast.Compare.NotEq: "_ne", ast.Compare.Lt: "_lt", ast.Compare.LtE: "_le", ast.Compare.Gt: "_gt", ast.Compare.GtE: "_ge", ast.Compare.Is: "_is", ast.Compare.IsNot: "_isnot", ast.Compare.In: "_in", ast.Compare.NotIn: "_notin", } test = x.compop(ops[op], gety) if len(compares) == 1: return test.asAny() rest = self.do_comp(self.factory.makePyObject(ytmp), compares[1:], tmps) return jast.TriTest(test.nonzero(), rest, False)
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 importfrom_stmt(self, top, names): module = self.get_module(top, 0) if names == '*': return self.importall_stmt(module) #print 'import * from', module #names = module.dir() modnames = [] asnames = [] for modname, asname in names: if asname is None: asname = modname asnames.append(asname) modnames.append(modname) topmodname = jast.StringConstant(".".join(top)) modnamesArray = jast.FilledArray( "String", map(lambda x: jast.StringConstant(x), modnames)) do_import = jast.InvokeStatic( "org.python.core.imp", "importFrom", [topmodname, modnamesArray, self.frame.frame]) if not self.imp_accu: imp_accu = self.imp_accu = jast.Identifier("imp_accu") self.makeFreeDecl("PyObject[]", imp_accu) else: imp_accu = self.imp_accu stmts = [jast.Set(imp_accu, do_import)] for i in range(len(asnames)): asname = asnames[i] modname = modnames[i] code = jast.Subscript(imp_accu, i) stmts.append( self.set_name(asname, module.getattr(modname).makeReference(code))) stmts.append(jast.Set(imp_accu, jast.Null)) return stmts
def bool_op(self, x, y, swap=0): tmp = self.frame.gettemp("PyObject") test = jast.Invoke(jast.Set(tmp, self.visit(x).asAny()), "__nonzero__", []) yes, no = tmp, self.visit(y).asAny() if swap: yes, no = no, yes op = self.factory.makePyObject(jast.TriTest(test, yes, no)) self.frame.freetemp(tmp) return op
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 bool_op(self, x, y, op): tmp = self.frame.gettemp("PyObject") test = jast.Invoke(jast.Set(tmp, x.asAny()), "__nonzero__", []) if op == ast.BoolOp.Or: yes, no = tmp, y.asAny() else: no, yes = tmp, y.asAny() op = self.factory.makePyObject(jast.TriTest(test, yes, no)) self.frame.freetemp(tmp) return op
def seqSet(self, elts): n = len(elts) unpacked = jast.InvokeStatic("org.python.core.Py", "unpackSequence", [self.temporary.asAny(), jast.IntegerConstant(n)]) tmp = self.frame.gettemp('PyObject[]') stmts = [ jast.Set(tmp, unpacked) ] for i in range(n): code = jast.Subscript(tmp, i) stmts.append(self.set(elts[i], self.factory.makePyObject(code))) self.frame.freetemp(tmp) return stmts
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 set_list(self, seq, value): if hasattr(self, 'AUG'): raise SyntaxError, "augmented assign to tuple not possible" if len(seq) > 0 and seq[-1].id == JJTCOMMA: del seq[-1] n = len(seq) unpacked = jast.InvokeStatic( "org.python.core.Py", "unpackSequence", [value.asAny(), jast.IntegerConstant(n)]) tmp = self.frame.gettemp('PyObject[]') stmts = [jast.Set(tmp, unpacked)] for i in range(n): code = jast.Subscript(tmp, i) stmts.append(self.set(seq[i], self.factory.makePyObject(code))) self.frame.freetemp(tmp) return stmts
def do_comp(self, x, compares, tmps): False = jast.GetStaticAttribute("Py", "Zero") op, other = compares[0] y = self.visit(other) if len(compares) > 1: ytmp = self.frame.gettemp("PyObject") tmps.append(ytmp) gety = self.factory.makePyObject(jast.Set(ytmp, y.asAny())) else: gety = y test = x.compop(op, gety) if len(compares) == 1: return test.asAny() rest = self.do_comp(self.factory.makePyObject(ytmp), compares[1:], tmps) return jast.TriTest(test.nonzero(), rest, False)
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 visitTryExcept(self, node): if node.orelse is not None: elseBool = self.frame.gettemp("boolean") jbody = jast.Block(self.suite(node.body)) tests = [] ifelse = None tname = jast.Identifier("x$%d" % self.nthrowables) self.nthrowables = self.nthrowables + 1 exctmp = self.frame.gettemp("PyException") setexc = jast.Set(exctmp, jast.InvokeStatic("Py", "setException", [tname, self.frame.frame])) for exchandler in node.handlers: if exchandler.type is None: ifelse = jast.Block(self.suite(exchandler.body)) continue type = self.visit(exchandler.type) t = jast.InvokeStatic("Py", "matchException", [exctmp, type.asAny()]) newbody = [] if exchandler.name is not None: exceptionValue = self.factory.makePyObject( jast.GetInstanceAttribute(exctmp, "value")) newbody.append(self.set(exchandler.name, exceptionValue)) #print self.visit(ebody) newbody.append(self.suite(exchandler.body)) #print newbody #print jast.Block(newbody) tests.append( (t, jast.Block(newbody)) ) if ifelse is None: ifelse = jast.Throw(exctmp) if len(tests) == 0: catchBody = ifelse else: catchBody = jast.MultiIf(tests, ifelse) catchBody = [setexc, catchBody] if node.orelse is not None: catchBody = [jast.Set(elseBool, jast.False), catchBody] catchBody = jast.Block([catchBody]) self.frame.freetemp(exctmp) ret = jast.TryCatch(jbody, "Throwable", tname, catchBody) if node.orelse is not None: ret = jast.Block([jast.Set(elseBool, jast.True), ret, jast.If(elseBool, jast.Block(self.suite(node.orelse)))]) self.frame.freetemp(elseBool) return ret
def makeTemp(self, value): tmp = self.frame.gettemp('PyObject') setit = jast.Set(tmp, value.asAny()) return self.factory.makePyObject(tmp), setit
def makeTemp(self, frame): return PyObject(jast.Set(frame.gettemp(self.type), self.asAny()), self.parent)