def dumpCodes(self): self.constants.append([ "PyFunctionTable", self.getFunctionTable(), jast.New(self.name, []) ]) for label, name, code, frame in self.codes: code = frame.toCellPrepend(code) funcid = self.addFunctionCode(name, code) arglist = keyworddict = jast. False if frame.args_arglist(): arglist = jast. True if frame.args_keyworddict(): keyworddict = jast. True names = jast.StringArray(frame.getnames()) cellnames = StringArrayOrNull(frame.getcellnames()) freenames = StringArrayOrNull(frame.getfreenames()) npurecell = frame.get_npurecell() cargs = [ jast.IntegerConstant(frame.args_count()), names, jast.StringConstant(self.filename), jast.StringConstant(name), arglist, keyworddict, self.getFunctionTable(), jast.IntegerConstant(funcid), cellnames, freenames, jast.IntegerConstant(npurecell), jast.IntegerConstant((frame.opt_globals and CO_OPTIMIZED) | ( frame.scope.nested_scopes and CO_NESTED)) ] newcode = jast.InvokeStatic("Py", "newCode", cargs) self.constants.append(("PyCode", jast.Identifier(label), newcode))
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 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 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 makeClosure(self,nested_scope): freenames = nested_scope.freevars if len(freenames) == 0: return None clos = [] factory = self.compiler.factory for free in freenames: i = self.scope.tbl.get(free).env_index code = jast.Invoke(self.frame, "getclosure", [jast.IntegerConstant(i)]) clos.append(factory.makePyObject(code)) return clos
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 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 nullReturn(ret): if ret == Void.TYPE: return jast.Return() if Class.isPrimitive(ret): if ret.__name__ == 'boolean': value = jast. False elif ret.__name__ == 'char': value = jast.CharacterConstant('x') else: value = jast.IntegerConstant(0) else: value = jast.Null return jast.Return(value)
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 getIntegerConstant(self, value): code = jast.InvokeStatic("Py", "newInteger", [jast.IntegerConstant(value)]) return self.getConstant(value, code, "i")
def setCode(self,method,ref,value): if type(ref) is type(""): args = (jast.StringConstant(ref),value.asAny()) else: args = (jast.IntegerConstant(ref),value.asAny()) return jast.Invoke(self.frame,method,args)
def delCode(self,method,ref): if type(ref) is type(""): ref = (jast.StringConstant(ref),) else: ref = (jast.IntegerConstant(ref),) return jast.Invoke(self.frame,method,ref)
class Object: def __init__(self, code, istypes, astypes): self.code = code self.istypes = istypes self.astypes = astypes def isa(self, type): if type in self.istypes: return self.code def asa(self, type): if type in self.istypes: return self.code for astype, ascode in self.astypes: if astype == type: return ascode one = Object(jast.IntegerConstant(1), [java.lang.Integer.TYPE], [(org.python.core.PyObject, jast.Identifier("one"))]) foo = Object( jast.Identifier("foo"), [org.python.core.PyObject], [(java.lang.Integer.TYPE, jast.InvokeStatic("Py", "toint", [jast.Identifier("foo")]))]) print f.invoke(foo, [one]) print f.invoke(foo, [foo]) print call(org.python.core.Py.py2int, [one])
def igetitem(self, code, index): return self.domethod(code, "__getitem__", Object(jast.IntegerConstant(index), IntType))
ret = JavaString() elif type == org.python.core.PyObject: ret = PyObject() elif type == org.python.core.PyString: ret = PyObject() else: ret = JavaObject(type) types[type] = ret return ret Generic = findType(org.python.core.PyObject) IntType = findType(java.lang.Integer.TYPE) StringType = findType(java.lang.String) if __name__ == '__main__': foo = Object(jast.Identifier("foo"), Generic) one = Object(jast.IntegerConstant(1), IntType) hello = Object(jast.StringConstant("hello"), StringType) print foo, one, hello print foo.binop("add", foo) print foo.binop("add", one) print foo.binop("add", hello) print foo.nonzero() print foo.getitem(foo) print foo.getitem(one) print foo.call([one, hello]) print foo.call([one, hello, foo])