Index: ObjectFactory.py =================================================================== RCS file: /cvsroot/jython/jython/Tools/jythonc/ObjectFactory.py,v retrieving revision 2.8 diff -u -5 -r2.8 ObjectFactory.py --- ObjectFactory.py 2001/05/27 18:50:56 2.8 +++ ObjectFactory.py 2001/06/27 14:22:50 @@ -189,10 +189,27 @@ if clos: args.append(PyObjectArray(clos)) return jast.InvokeStatic("Py", "makeClass", args) + # proper logic for retrieving superproxy name + def _takeSupername(self,cls,mod,modname = None): + if modname is None: + modname = "" + if mod.package: modname = mod.package+'.' + modname += mod.name + self.javaclasses.extend(cls.javaclasses) + self.proxyname = self.name + self.supername = None + self.issuperproxy = 1 + full_py = modname + '.' + cls.name + if cls.name != mod.name: + self.pySupername = self.supername = full_py + else: + self.pySupername = full_py + self.supername = modname + def isSuperclassJava(self): if hasattr(self, 'javaclasses'): return len(self.javaclasses) self.javaclasses = [] @@ -202,43 +219,35 @@ import compile for base in self.bases: if hasattr(base, "javaclass"): self.javaclasses.append(base.javaclass) self.proxyname = self.name - self.supername = base.javaclass.__name__ + self.pySupername = self.supername = base.javaclass.__name__ continue base = base.value if hasattr(base, "name"): jc = compile.getJavaClass(base.name) if jc is not None: self.javaclasses.append(jc) self.proxyname = self.name if not jc.isInterface(): - self.supername = jc.__name__ + self.pySupername = self.supername = jc.__name__ continue if isinstance(base, PyClass): if base.isSuperclassJava(): - self.javaclasses.extend(base.javaclasses) - self.proxyname = self.name - self.supername = base.name - self.issuperproxy = 1 + self._takeSupername(base,base.def_compiler.module) continue if isinstance(base, PyNamespace): names = base.name.split('.') if len(names) >= 2: modname = '.'.join(names[:-1]) mod = compile.Compiler.allmodules.get(modname, None) if mod: cls = mod.classes.get(names[-1], None) if cls: if cls.value.isSuperclassJava(): - self.javaclasses.extend(cls.value.javaclasses) - self.proxyname = self.name - self.supername = cls.value.name - self.issuperproxy = 1 - if cls.value.name != mod.name: - self.supername = mod.name + '.' + self.supername + self._takeSupername(cls.value,mod,modname = modname) continue if len(self.javaclasses) and self.supername == None: self.supername = "java.lang.Object" self.proxyname = self.name Index: compile.py =================================================================== RCS file: /cvsroot/jython/jython/Tools/jythonc/compile.py,v retrieving revision 2.18 diff -u -5 -r2.18 compile.py --- compile.py 2001/05/27 18:50:56 2.18 +++ compile.py 2001/06/27 14:22:50 @@ -146,11 +146,11 @@ else: sig = getsig(v.doc, args, constructor=0) methods.append( (name, args, sig) ) supername = None if pyc.isSuperclassJava(): - return proxies.JavaProxy(pyc.name, pyc.supername, + return proxies.JavaProxy(pyc.name, (pyc.supername,pyc.pySupername), pyc.javaclasses, methods, module, pyc.issuperproxy) return None @@ -314,11 +314,11 @@ continue if prefixes.has_key(name): del self.packages[name] - def processModule(self, mod, outdir): + def preprocessModule(self, mod): self.write(' %s module' % mod.name) proxyClasses = [] mainProxy = None for name, pyc in mod.classes.items(): proxy = makeJavaProxy(mod, pyc.value) @@ -351,10 +351,11 @@ specialClasses[mod.name+'.'+proxy.name] = \ pkg+mod.name+'$'+proxy.name mod.specialClasses = specialClasses + def processModule(self,mod,outdir): self.javasources.append(mod.dump(outdir)) if self.options.bean is not None: mod.javaclasses[0] = mod.javaclasses[0], {'Java-Bean':'True'} self.javaclasses.extend(mod.javaclasses) @@ -382,12 +383,17 @@ self.makeAdapter(outdir, adapter) self.write('\nCreating .java files:') for filename, mod in self.modules.items(): mod.modules = Compiler.allmodules - self.processModule(mod, outdir) + self.preprocessModule(mod) + self.write('\n...') + + for filename, mod in self.modules.items(): + self.processModule(mod,outdir) + self.java2class(outdir) def java2class(self, outdir): if self.options.compiler == "NONE": self.write('\nLeaving .java files, no compiler specified') Index: proxies.py =================================================================== RCS file: /cvsroot/jython/jython/Tools/jythonc/proxies.py,v retrieving revision 2.11 diff -u -5 -r2.11 proxies.py --- proxies.py 2001/05/07 19:21:21 2.11 +++ proxies.py 2001/06/27 14:22:51 @@ -114,11 +114,11 @@ class JavaProxy: def __init__(self, name, supername, bases, methods, module=None, issuperproxy = 1): self.bases = bases self.name = name - self.supername = supername + self.supername, self.pySupername = supername self.methods = methods self.issuperproxy = 0 #issuperproxy self.packages = self.properties = jast.Null self.modname = "foo" @@ -158,10 +158,55 @@ self.jconstructors = [] self.addConstructors(self.superclass) self.innerClasses = [] + # gather info about methods, and methods requiring a super__foo counterpart + self.superproxy = self + self.myCandSupermethods = [] + self.candSupermethods = None + self.methodsMemo = [] + self.prepMethods() + + def __repr__(self): return "" % (self.modname,self.name) + + def getSuperproxy(self): + if self.superproxy is not self: + return self.superproxy + supername = self.pySupername + modules = self.module.modules + parts = supername.split('.') + modname = '.'.join(parts[0:-1]) + dmodname = parts[-2] + supername = parts[-1] + superproxy = None + if modules.has_key(modname): + mod = modules[modname] + if dmodname == supername: + superproxy = getattr(mod,'javaproxy',None) + else: + for px in getattr(mod,'innerClasses',[]): + if isinstance(px,JavaProxy) and px.name == supername: + superproxy = px + break + self.superproxy = superproxy + return superproxy + + def getCandSupermethods(self,incl): + if incl and self.candSupermethods is not None: + return self.candSupermethods + px = self.getSuperproxy() + if px is not None: + cands = px.getCandSupermethods(incl = 1)[:] + else: + cands = [] + if incl: + cands.extend(self.myCandSupermethods) + self.candSupermethods = cands + return cands + + def dumpAll(self): self.statements = [] self.dumpInnerClasses() self.dumpMethods() self.dumpConstructors() @@ -171,14 +216,14 @@ def dumpInnerClasses(self): for ic in self.innerClasses: self.statements.append(ic) - def dumpMethods(self): + def prepMethods(self): names = self.jmethods.keys() names.sort() - #print 'adding methods', self.name, names + #print 'preparing adding methods', self.name, names pymethods = {} for name, args, sigs in self.methods: pymethods[name] = 1 #print name, args, sig if sigs is not None: @@ -186,40 +231,54 @@ self.initsigs = sigs continue #print sigs for access, ret, sig, throws in sigs: - self.callMethod(name, access, ret, sig, throws, 0) + dosuper = 0 if self.jmethods.has_key(name): x = filter(lambda c: isinstance(c, TupleType), sig) x = tuple(map(lambda c: c[0], x)) - if self.jmethods[name].has_key(x): - del self.jmethods[name][x] + dosuper = self.jmethods[name].has_key(x) + self.methodsMemo.append(('n',name, access, ret, sig, throws, + dosuper)) + if dosuper: + self.myCandSupermethods.append(name) + del self.jmethods[name][x] + for name in names: for sig, (access, ret, throws) in self.jmethods[name].items(): #print name, access, isProtected(access), isFinal(access) if isProtected(access): supername = name if isFinal(access): access = access & ~FINAL access = access & ~PROTECTED | PUBLIC - self.callSuperMethod(name, "super__" + name, - access, ret, sig, throws) + self.methodsMemo.append(('s',name, "super__" + name, + access, ret, sig, throws)) continue elif isFinal(access): continue if isAbstract(access): access = access & ~PROTECTED | PUBLIC - self.callMethod(name, access, ret, sig, throws, 0) + self.methodsMemo.append(('n',name, access, ret, sig, throws, + 0)) elif pymethods.has_key(name): access = access & ~PROTECTED | PUBLIC - self.callMethod(name, access, ret, sig, throws, 1) + self.methodsMemo.append(('n',name, access, ret, sig, throws, + 1)) + self.myCandSupermethods.append(name) elif isProtected(access): access = access & ~PROTECTED | PUBLIC - self.callSuperMethod(name, name, access, ret, sig, throws) + self.methodsMemo.append(('s',name, name, + access, ret, sig, throws)) + + def dumpMethods(self): # use info gathered by prepMethods + dispatch = { 's': self.callSuperMethod, 'n': self.callMethod } + for m in self.methodsMemo: + apply(dispatch[m[0]],m[1:]) def dumpConstructors(self): if self.initsigs is not None: #print self.initsigs for access, ret, sig, throws in self.initsigs: @@ -361,11 +420,11 @@ supercall = jast.Invoke(jast.Identifier("super"), name, argids) if ret != Void.TYPE: supercall = jast.Return(supercall) supermethod = None - if not self.issuperproxy: + 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: