From: <fwi...@us...> - 2006-05-19 19:02:01
|
Revision: 2739 Author: fwierzbicki Date: 2006-05-19 12:01:57 -0700 (Fri, 19 May 2006) ViewCVS: http://svn.sourceforge.net/jython/?rev=2739&view=rev Log Message: ----------- cleanup of new-style class support. Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2006-05-19 19:01:32 UTC (rev 2738) +++ trunk/jython/src/org/python/core/PyType.java 2006-05-19 19:01:57 UTC (rev 2739) @@ -14,6 +14,7 @@ * */ public class PyType extends PyObject implements Serializable { + //~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py /* type info */ public static final String exposed_name = "type"; @@ -277,6 +278,7 @@ }); } + //~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py public static PyObject type_new(PyObject new_, boolean init, PyType subtype, PyObject[] args, String[] keywords) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <fwi...@us...> - 2006-06-07 20:16:40
|
Revision: 2800 Author: fwierzbicki Date: 2006-06-06 18:20:14 -0700 (Tue, 06 Jun 2006) ViewCVS: http://svn.sourceforge.net/jython/?rev=2800&view=rev Log Message: ----------- exposed __mro__ Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2006-06-06 19:40:56 UTC (rev 2799) +++ trunk/jython/src/org/python/core/PyType.java 2006-06-07 01:20:14 UTC (rev 2800) @@ -17,17 +17,14 @@ //~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py /* type info */ - public static final String exposed_name = "type"; + public static final String exposed_name="type"; - public static void typeSetup(PyObject dict, PyType.Newstyle marker) { - dict.__setitem__("__dict__", new PyGetSetDescr("__dict__", - PyType.class, "getDict", null)); - dict.__setitem__("__name__", new PyGetSetDescr("__name__", - PyType.class, "fastGetName", null)); - dict.__setitem__("__base__", new PyGetSetDescr("__base__", - PyType.class, "getBase", null)); - dict.__setitem__("__bases__", new PyGetSetDescr("__bases__", - PyType.class, "getBases", null)); + public static void typeSetup(PyObject dict,PyType.Newstyle marker) { + dict.__setitem__("__dict__",new PyGetSetDescr("__dict__",PyType.class,"getDict",null)); + dict.__setitem__("__name__",new PyGetSetDescr("__name__",PyType.class,"fastGetName",null)); + dict.__setitem__("__base__",new PyGetSetDescr("__base__",PyType.class,"getBase",null)); + dict.__setitem__("__bases__",new PyGetSetDescr("__bases__",PyType.class,"getBases",null)); + dict.__setitem__("__mro__",new PyGetSetDescr("__mro__",PyType.class,"getMro",null)); class exposed___getattribute__ extends PyBuiltinFunctionNarrow { private PyType self; @@ -36,60 +33,58 @@ return self; } - exposed___getattribute__(PyType self, PyBuiltinFunction.Info info) { + exposed___getattribute__(PyType self,PyBuiltinFunction.Info info) { super(info); - this.self = self; + this.self=self; } public PyBuiltinFunction makeBound(PyObject self) { - return new exposed___getattribute__((PyType) self, info); + return new exposed___getattribute__((PyType)self,info); } public PyObject __call__(PyObject arg0) { try { - String name = (arg0.asName(0)); - PyObject ret = self.type___findattr__(name); - if (ret == null) + String name=(arg0.asName(0)); + PyObject ret=self.type___findattr__(name); + if (ret==null) self.noAttributeError(name); return ret; } catch (PyObject.ConversionException e) { String msg; switch (e.index) { case 0: - msg = "attribute name must be string"; + msg="attribute name must be a string"; break; default: - msg = "xxx"; + msg="xxx"; } throw Py.TypeError(msg); } } - public PyObject inst_call(PyObject gself, PyObject arg0) { - PyType self = (PyType) gself; + public PyObject inst_call(PyObject gself,PyObject arg0) { + PyType self=(PyType)gself; try { - String name = (arg0.asName(0)); - PyObject ret = self.type___findattr__(name); - if (ret == null) + String name=(arg0.asName(0)); + PyObject ret=self.type___findattr__(name); + if (ret==null) self.noAttributeError(name); return ret; } catch (PyObject.ConversionException e) { String msg; switch (e.index) { case 0: - msg = "attribute name must be string"; + msg="attribute name must be a string"; break; default: - msg = "xxx"; + msg="xxx"; } throw Py.TypeError(msg); } } } - dict.__setitem__("__getattribute__", new PyMethodDescr( - "__getattribute__", PyType.class, 1, 1, - new exposed___getattribute__(null, null))); + dict.__setitem__("__getattribute__",new PyMethodDescr("__getattribute__",PyType.class,1,1,new exposed___getattribute__(null,null))); class exposed___setattr__ extends PyBuiltinFunctionNarrow { private PyType self; @@ -98,54 +93,52 @@ return self; } - exposed___setattr__(PyType self, PyBuiltinFunction.Info info) { + exposed___setattr__(PyType self,PyBuiltinFunction.Info info) { super(info); - this.self = self; + this.self=self; } public PyBuiltinFunction makeBound(PyObject self) { - return new exposed___setattr__((PyType) self, info); + return new exposed___setattr__((PyType)self,info); } - public PyObject __call__(PyObject arg0, PyObject arg1) { + public PyObject __call__(PyObject arg0,PyObject arg1) { try { - self.type___setattr__(arg0.asName(0), arg1); + self.type___setattr__(arg0.asName(0),arg1); return Py.None; } catch (PyObject.ConversionException e) { String msg; switch (e.index) { case 0: - msg = "attribute name must be string"; + msg="attribute name must be a string"; break; default: - msg = "xxx"; + msg="xxx"; } throw Py.TypeError(msg); } } - public PyObject inst_call(PyObject gself, PyObject arg0, - PyObject arg1) { - PyType self = (PyType) gself; + public PyObject inst_call(PyObject gself,PyObject arg0,PyObject arg1) { + PyType self=(PyType)gself; try { - self.type___setattr__(arg0.asName(0), arg1); + self.type___setattr__(arg0.asName(0),arg1); return Py.None; } catch (PyObject.ConversionException e) { String msg; switch (e.index) { case 0: - msg = "attribute name must be string"; + msg="attribute name must be a string"; break; default: - msg = "xxx"; + msg="xxx"; } throw Py.TypeError(msg); } } } - dict.__setitem__("__setattr__", new PyMethodDescr("__setattr__", - PyType.class, 2, 2, new exposed___setattr__(null, null))); + dict.__setitem__("__setattr__",new PyMethodDescr("__setattr__",PyType.class,2,2,new exposed___setattr__(null,null))); class exposed___delattr__ extends PyBuiltinFunctionNarrow { private PyType self; @@ -154,13 +147,13 @@ return self; } - exposed___delattr__(PyType self, PyBuiltinFunction.Info info) { + exposed___delattr__(PyType self,PyBuiltinFunction.Info info) { super(info); - this.self = self; + this.self=self; } public PyBuiltinFunction makeBound(PyObject self) { - return new exposed___delattr__((PyType) self, info); + return new exposed___delattr__((PyType)self,info); } public PyObject __call__(PyObject arg0) { @@ -171,17 +164,17 @@ String msg; switch (e.index) { case 0: - msg = "attribute name must be string"; + msg="attribute name must be a string"; break; default: - msg = "xxx"; + msg="xxx"; } throw Py.TypeError(msg); } } - public PyObject inst_call(PyObject gself, PyObject arg0) { - PyType self = (PyType) gself; + public PyObject inst_call(PyObject gself,PyObject arg0) { + PyType self=(PyType)gself; try { self.type___delattr__(arg0.asName(0)); return Py.None; @@ -189,18 +182,17 @@ String msg; switch (e.index) { case 0: - msg = "attribute name must be string"; + msg="attribute name must be a string"; break; default: - msg = "xxx"; + msg="xxx"; } throw Py.TypeError(msg); } } } - dict.__setitem__("__delattr__", new PyMethodDescr("__delattr__", - PyType.class, 1, 1, new exposed___delattr__(null, null))); + dict.__setitem__("__delattr__",new PyMethodDescr("__delattr__",PyType.class,1,1,new exposed___delattr__(null,null))); class exposed___subclasses__ extends PyBuiltinFunctionNarrow { private PyType self; @@ -209,13 +201,13 @@ return self; } - exposed___subclasses__(PyType self, PyBuiltinFunction.Info info) { + exposed___subclasses__(PyType self,PyBuiltinFunction.Info info) { super(info); - this.self = self; + this.self=self; } public PyBuiltinFunction makeBound(PyObject self) { - return new exposed___subclasses__((PyType) self, info); + return new exposed___subclasses__((PyType)self,info); } public PyObject __call__() { @@ -223,13 +215,12 @@ } public PyObject inst_call(PyObject gself) { - PyType self = (PyType) gself; + PyType self=(PyType)gself; return self.type_getSubclasses(); } } - dict.__setitem__("__subclasses__", new PyMethodDescr("__subclasses__", - PyType.class, 0, 0, new exposed___subclasses__(null, null))); + dict.__setitem__("__subclasses__",new PyMethodDescr("__subclasses__",PyType.class,0,0,new exposed___subclasses__(null,null))); class exposed___call__ extends PyBuiltinFunctionWide { private PyType self; @@ -238,45 +229,41 @@ return self; } - exposed___call__(PyType self, PyBuiltinFunction.Info info) { + exposed___call__(PyType self,PyBuiltinFunction.Info info) { super(info); - this.self = self; + this.self=self; } public PyBuiltinFunction makeBound(PyObject self) { - return new exposed___call__((PyType) self, info); + return new exposed___call__((PyType)self,info); } - public PyObject inst_call(PyObject self, PyObject[] args) { - return inst_call(self, args, Py.NoKeywords); + public PyObject inst_call(PyObject self,PyObject[]args) { + return inst_call(self,args,Py.NoKeywords); } - public PyObject __call__(PyObject[] args) { - return __call__(args, Py.NoKeywords); + public PyObject __call__(PyObject[]args) { + return __call__(args,Py.NoKeywords); } - public PyObject __call__(PyObject[] args, String[] keywords) { - return self.type___call__(args, keywords); + public PyObject __call__(PyObject[]args,String[]keywords) { + return self.type___call__(args,keywords); } - public PyObject inst_call(PyObject gself, PyObject[] args, - String[] keywords) { - PyType self = (PyType) gself; - return self.type___call__(args, keywords); + public PyObject inst_call(PyObject gself,PyObject[]args,String[]keywords) { + PyType self=(PyType)gself; + return self.type___call__(args,keywords); } } - dict.__setitem__("__call__", new PyMethodDescr("__call__", - PyType.class, -1, -1, new exposed___call__(null, null))); - dict.__setitem__("__new__", new PyNewWrapper(PyType.class, "__new__", - -1, -1) { + dict.__setitem__("__call__",new PyMethodDescr("__call__",PyType.class,-1,-1,new exposed___call__(null,null))); + dict.__setitem__("__new__",new PyNewWrapper(PyType.class,"__new__",-1,-1) { - public PyObject new_impl(boolean init, PyType subtype, - PyObject[] args, String[] keywords) { - return type_new(this, init, subtype, args, keywords); - } + public PyObject new_impl(boolean init,PyType subtype,PyObject[]args,String[]keywords) { + return type_new(this,init,subtype,args,keywords); + } - }); + }); } //~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py @@ -383,6 +370,10 @@ } } + public PyTuple getMro() { + return new PyTuple(mro); + } + public synchronized final PyObject type_getSubclasses() { PyList result = new PyList(); cleanup_subclasses(); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <cg...@us...> - 2006-11-22 05:26:57
|
Revision: 2985 http://svn.sourceforge.net/jython/?rev=2985&view=rev Author: cgroves Date: 2006-11-21 21:26:56 -0800 (Tue, 21 Nov 2006) Log Message: ----------- handle str assigned to slots Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2006-11-21 10:37:15 UTC (rev 2984) +++ trunk/jython/src/org/python/core/PyType.java 2006-11-22 05:26:56 UTC (rev 2985) @@ -394,10 +394,8 @@ boolean has_set, has_delete; private boolean needs_finalizer; - private int numSlots; - private PyObject userslots; - private boolean needs_userdict; + private boolean needs_userdict = true; private java.lang.ref.ReferenceQueue subclasses_refq = new java.lang.ref.ReferenceQueue(); private java.util.HashSet subclasses = new java.util.HashSet(); @@ -694,47 +692,38 @@ } else { newtype = new PyTypeDerived(metatype); } + newtype.dict = dict; + newtype.numSlots = base.numSlots; + newtype.name = name; + newtype.base = base; + newtype.bases = bases_list; - int nuserslots = base.numSlots; PyObject slots = dict.__finditem__("__slots__"); - boolean needs_userdict = true; if(slots != null) { - needs_userdict = false; - PyObject iter = slots.__iter__(); - PyObject slotname; - for(; (slotname = iter.__iternext__()) != null;) { - confirmIdentifier(slotname); - String slotstring = mangleName(name, slotname.toString()); - if(slotstring.equals("__dict__")) { - needs_userdict = true; - } else { - dict.__setitem__(slotstring, new PySlot(newtype, - slotstring, - nuserslots)); - nuserslots += 1; + newtype.needs_userdict = false; + if(slots instanceof PyString) { + addSlot(newtype, slots); + } else { + PyObject iter = slots.__iter__(); + PyObject slotname; + for(; (slotname = iter.__iternext__()) != null;) { + addSlot(newtype, slotname); } } } - if(!needs_userdict) { + if(!newtype.needs_userdict) { for(int i = 0; i < bases_list.length; i++) { PyObject cur = bases_list[i]; if((cur instanceof PyType && ((PyType)cur).needs_userdict) || cur instanceof PyClass) { - needs_userdict = true; + newtype.needs_userdict = true; break; } } } - newtype.name = name; - newtype.base = base; - newtype.bases = bases_list; - newtype.needs_userdict = needs_userdict; - newtype.numSlots = nuserslots; - newtype.dict = dict; - // special case __new__, if function => static method PyObject tmp = dict.__finditem__("__new__"); if (tmp != null && tmp instanceof PyFunction) { // xxx java functions? @@ -756,7 +745,7 @@ newtype.mro = newmro; // __dict__ descriptor - if (needs_userdict && newtype.lookup("__dict__")==null) { + if (newtype.needs_userdict && newtype.lookup("__dict__")==null) { dict.__setitem__("__dict__",new PyGetSetDescr(newtype,"__dict__",PyObject.class,"getDict",null)); } @@ -773,7 +762,19 @@ return newtype; } + private static void addSlot(PyType newtype, PyObject slotname) { + confirmIdentifier(slotname); + String slotstring = mangleName(newtype.name, slotname.toString()); + if(slotstring.equals("__dict__")) { + newtype.needs_userdict = true; + } else { + newtype.dict.__setitem__(slotstring, new PySlot(newtype, + slotstring, + newtype.numSlots++)); + } + } + public String fastGetName() { return name; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <cg...@us...> - 2006-11-26 21:48:23
|
Revision: 2992 http://svn.sourceforge.net/jython/?rev=2992&view=rev Author: cgroves Date: 2006-11-26 13:48:20 -0800 (Sun, 26 Nov 2006) Log Message: ----------- * intern mangled slot names * pass derived metatype up to PyObject so it'll be used in lookup * type.mro is a classmethod so it always computes the mro for a given class instead of returning a cached value * only add userdict to slotted type if a base type requires it in its slots Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2006-11-26 21:42:52 UTC (rev 2991) +++ trunk/jython/src/org/python/core/PyType.java 2006-11-26 21:48:20 UTC (rev 2992) @@ -506,22 +506,13 @@ } - final PyTuple type_mro() { - return getMro(); + final PyList type_mro() { + return new PyList(compute_mro()); + } - final PyTuple type_mro(PyObject o) { - //FIXME: PyMethDescr should be gaurding against args that are not the - // correct type in the generated code, but that is not working. - // fix and delete this instanceof check. - if (!(o instanceof PyType)) { - throw Py.TypeError( - "descriptor 'mro' requires a 'type' object but received a '" - + o.getType().fastGetName() - + "'"); - } - PyType type = (PyType)o; - return type.type_mro(); + final PyList type_mro(PyObject o) { + return ((PyType)o).type_mro(); } final PyObject[] compute_mro() { @@ -709,18 +700,20 @@ for(; (slotname = iter.__iternext__()) != null;) { addSlot(newtype, slotname); } + } } if(!newtype.needs_userdict) { for(int i = 0; i < bases_list.length; i++) { PyObject cur = bases_list[i]; - if((cur instanceof PyType && ((PyType)cur).needs_userdict) + if((cur instanceof PyType && ((PyType)cur).needs_userdict && ((PyType)cur).numSlots > 0) || cur instanceof PyClass) { newtype.needs_userdict = true; break; } } } + @@ -729,21 +722,14 @@ if (tmp != null && tmp instanceof PyFunction) { // xxx java functions? dict.__setitem__("__new__",new PyStaticMethod(tmp)); } - - PyObject mro_meth = null; - PyObject[] newmro; - - if (metatype.underlying_class != PyType.class) - mro_meth = metatype.lookup("mro"); - - if (mro_meth == null) { - newmro = newtype.compute_mro(); - } else { - newmro = Py.make_array(mro_meth.__get__(newtype,metatype).__call__()); + newtype.mro = newtype.compute_mro(); + if(metatype.underlying_class != PyType.class + && metatype.lookup("mro") != null) { + newtype.mro = Py.make_array(metatype.lookup("mro") + .__get__(newtype, metatype) + .__call__()); } - - newtype.mro = newmro; - + // __dict__ descriptor if (newtype.needs_userdict && newtype.lookup("__dict__")==null) { dict.__setitem__("__dict__",new PyGetSetDescr(newtype,"__dict__",PyObject.class,"getDict",null)); @@ -834,7 +820,7 @@ } PyType(PyType subtype) { - super(true); + super(subtype); } private static String decapitalize(String s) { @@ -1147,15 +1133,14 @@ } catch (Exception e) { throw error(e); } - if (newstyle) { // newstyle - base = (Class) exposed_decl_get_object(c, "base"); - name = (String) exposed_decl_get_object(c, "name"); - if (base == null) { + if(newstyle) { // newstyle + base = (Class)exposed_decl_get_object(c, "base"); + name = (String)exposed_decl_get_object(c, "name"); + if(base == null) { Class cur = c; - while (cur != PyObject.class) { - Class exposed_as = - (Class) exposed_decl_get_object(cur, "as"); - if (exposed_as != null) { + while(cur != PyObject.class) { + Class exposed_as = (Class)exposed_decl_get_object(cur, "as"); + if(exposed_as != null) { PyType exposed_as_type = fromClass(exposed_as); class_to_type.put(c, exposed_as_type); return exposed_as_type; @@ -1437,7 +1422,7 @@ int i = 0; while (classname.charAt(i) == '_') i++; - return "_"+classname.substring(i)+methodname; + return ("_"+classname.substring(i)+methodname).intern(); } return methodname; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ped...@us...> - 2006-12-21 23:34:54
|
Revision: 3026 http://svn.sourceforge.net/jython/?rev=3026&view=rev Author: pedronis Date: 2006-12-21 15:34:53 -0800 (Thu, 21 Dec 2006) Log Message: ----------- move the check class_to_type cache check as late as possible, to cope with reentrance with the same c. The original check is just an optimisation now. See http://sourceforge.net/mailarchive/forum.php?thread_id=31282636&forum_id=5587 and subsequent messages. Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2006-12-19 23:14:36 UTC (rev 3025) +++ trunk/jython/src/org/python/core/PyType.java 2006-12-21 23:34:53 UTC (rev 3026) @@ -1312,9 +1312,12 @@ if (exposed_methods == null) exposed_methods = EMPTY; } - PyType newtype = c == PyType.class ? new PyType(true) : new PyType(); - class_to_type.put(c, newtype); - fillFromClass(newtype, name, c, base, newstyle, setup, exposed_methods); + PyType newtype = (PyType)class_to_type.get(c); + if (newtype == null) { + newtype = c == PyType.class ? new PyType(true) : new PyType(); + class_to_type.put(c, newtype); + fillFromClass(newtype, name, c, base, newstyle, setup, exposed_methods); + } return newtype; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <ped...@us...> - 2007-03-09 22:56:03
|
Revision: 3140 http://svn.sourceforge.net/jython/?rev=3140&view=rev Author: pedronis Date: 2007-03-09 14:55:54 -0800 (Fri, 09 Mar 2007) Log Message: ----------- This is the same special casing as done by CPython for type(x). Now this works fine: >>> class T(type): ... def __init__(self, name, bases, dct): ... pass ... >>> class X(object): ... __metaclass__ = T ... >>> x=X() >>> type(x) <__main__.T object 1> Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2007-03-09 18:35:34 UTC (rev 3139) +++ trunk/jython/src/org/python/core/PyType.java 2007-03-09 22:55:54 UTC (rev 3140) @@ -1198,6 +1198,8 @@ return newtype; } + static PyType TypeType = fromClass(PyType.class); + /* * considers: * if c implements Newstyle => c and all subclasses @@ -1417,6 +1419,10 @@ type_prepended[0] = type; newobj = new_.__get__(null, type).__call__(type_prepended, keywords); } + /* special case type(x) */ + if (type == TypeType && args.length==1 && keywords.length==0) { + return newobj; + } newobj.dispatch__init__(type,args,keywords); return newobj; } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pj...@us...> - 2008-02-06 03:26:53
|
Revision: 4103 http://jython.svn.sourceforge.net/jython/?rev=4103&view=rev Author: pjenvey Date: 2008-02-05 19:26:51 -0800 (Tue, 05 Feb 2008) Log Message: ----------- make addBuilder do more to fully accomplish what add/fillFromClass do, for types initialized before their builders are Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-02-05 06:29:37 UTC (rev 4102) +++ trunk/jython/src/org/python/core/PyType.java 2008-02-06 03:26:51 UTC (rev 4103) @@ -804,21 +804,8 @@ newtype.name = name; newtype.underlying_class = c; newtype.builtin = true; - boolean top = false; // basic mro, base, bases - PyType[] mro; - if(base == Object.class) { - mro = new PyType[] {newtype}; - top = true; - } else { - PyType basetype = fromClass(base); - mro = new PyType[basetype.mro.length + 1]; - System.arraycopy(basetype.mro, 0, mro, 1, basetype.mro.length); - mro[0] = newtype; - newtype.base = basetype; - newtype.bases = new PyObject[] {basetype}; - } - newtype.mro = mro; + fillInMRO(newtype, base); PyObject dict; if(tb != null) { dict = tb.getDict(newtype); @@ -833,7 +820,7 @@ if(newstyle) { newtype.non_instantiable = dict.__finditem__("__new__") == null; } - if(!top) { + if(base != Object.class) { if(get_descr_method(c, "__set__", OO) != null || /* backw comp */ get_descr_method(c, "_doset", OO) != null) { newtype.has_set = true; @@ -996,6 +983,21 @@ } } + private static void fillInMRO(PyType type, Class base) { + PyType[] mro; + if (base == Object.class) { + mro = new PyType[] {type}; + } else { + PyType baseType = fromClass(base); + mro = new PyType[baseType.mro.length + 1]; + System.arraycopy(baseType.mro, 0, mro, 1, baseType.mro.length); + mro[0] = type; + type.base = baseType; + type.bases = new PyObject[] {baseType}; + } + type.mro = mro; + } + private static HashMap<Class, PyType> class_to_type; private static HashMap<Class, TypeBuilder> classToBuilder; @@ -1010,11 +1012,19 @@ classToBuilder.put(forClass, builder); if(class_to_type.containsKey(forClass)) { - // PyObject and PyType are loaded as part of creating their - // builders, so they need to be bootstrapped + // Workaround the fact that some types are initialized + // before their builders (namely PyObject and PyType, but + // others too). Essentially do the work of addFromClass & + // fillFromClass after the fact PyType objType = fromClass(builder.getTypeClass()); objType.name = builder.getName(); objType.dict = builder.getDict(objType); + Class base = builder.getBase(); + if (base == Object.class) { + base = forClass.getSuperclass(); + } + fillInMRO(objType, base); + objType.non_instantiable = objType.dict.__finditem__("__new__") == null; } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <cg...@us...> - 2008-02-10 08:46:21
|
Revision: 4125 http://jython.svn.sourceforge.net/jython/?rev=4125&view=rev Author: cgroves Date: 2008-02-10 00:46:19 -0800 (Sun, 10 Feb 2008) Log Message: ----------- Clear out the gexpose newstyle setup Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-02-10 08:34:03 UTC (rev 4124) +++ trunk/jython/src/org/python/core/PyType.java 2008-02-10 08:46:19 UTC (rev 4125) @@ -359,10 +359,6 @@ return Py.TypeError(msg.toString()); } - private static void debug(PyObject[] objs) { - System.out.println(new PyList(objs).toString()); - } - @ExposedMethod(defaults = "null") final PyList type_mro(PyObject o) { if(o == null) { @@ -742,30 +738,16 @@ return name.intern(); } - private static Object exposed_decl_get_object(Class c, String name) { - try { - return c.getDeclaredField("exposed_" + name).get(null); - } catch (NoSuchFieldException e) { - return null; - } catch (Exception e) { - throw error(e); - } - } - private static PyException error(Exception e) { return Py.JavaError(e); } - private static Method get_non_static_method( - Class c, - String name, - Class[] parmtypes) { + private static Method get_non_static_method(Class<?> c, String name, Class[] parmtypes) { try { Method meth = c.getMethod(name, parmtypes); if (!Modifier.isStatic(meth.getModifiers())) return meth; - } catch (NoSuchMethodException e) { - } + } catch (NoSuchMethodException e) {} return null; } @@ -794,8 +776,6 @@ String name, Class c, Class base, - boolean newstyle, - Method setup, TypeBuilder tb) { if(base == null) { @@ -821,34 +801,28 @@ // basic mro, base, bases fillInMRO(newtype, base); PyObject dict; - if(tb != null) { + if (tb != null) { dict = tb.getDict(newtype); + newtype.non_instantiable = dict.__finditem__("__new__") == null; } else { dict = new PyStringMap(); - if(newstyle) { - fillInNewstyle(newtype, setup, dict); - } else { - fillInClassic(c, base, dict); + fillInClassic(c, base, dict); + if (base != Object.class) { + if (get_descr_method(c, "__set__", OO) != null || /* backw comp */ + get_descr_method(c, "_doset", OO) != null) { + newtype.has_set = true; + } + if (get_descr_method(c, "__delete__", O) != null || /* backw comp */ + get_descr_method(c, "_dodel", O) != null) { + newtype.has_delete = true; + } } } - if(newstyle) { - newtype.non_instantiable = dict.__finditem__("__new__") == null; - } - if(base != Object.class) { - if(get_descr_method(c, "__set__", OO) != null || /* backw comp */ - get_descr_method(c, "_doset", OO) != null) { - newtype.has_set = true; - } - if(get_descr_method(c, "__delete__", O) != null || /* backw comp */ - get_descr_method(c, "_dodel", O) != null) { - newtype.has_delete = true; - } - } newtype.dict = dict; } - private static void fillInClassic(Class c, Class base, PyObject dict) { - HashMap propnames = new HashMap(); + private static void fillInClassic(Class c, Class<?> base, PyObject dict) { + HashMap<String, Object> propnames = new HashMap<String, Object>(); Method[] methods = c.getMethods(); for(int i = 0; i < methods.length; i++) { Method meth = methods[i]; @@ -975,8 +949,8 @@ } if(ClassDictInit.class.isAssignableFrom(c) && c != ClassDictInit.class) { try { - Method m = c.getMethod("classDictInit", - new Class[] {PyObject.class}); + @SuppressWarnings("unchecked") + Method m = c.getMethod("classDictInit", PyObject.class); m.invoke(null, new Object[] {dict}); } catch(Exception exc) { throw error(exc); @@ -984,19 +958,6 @@ } } - private static void fillInNewstyle(PyType newtype, - Method setup, - PyObject dict) { - if(setup != null) { - try { - setup.invoke(null, new Object[] {dict, null}); - } catch(Exception e) { - e.printStackTrace(); - throw error(e); - } - } - } - private static void fillInMRO(PyType type, Class base) { PyType[] mro; if (base == Object.class) { @@ -1043,61 +1004,31 @@ } private static PyType addFromClass(Class c) { - if(ExposeAsSuperclass.class.isAssignableFrom(c)) { + if (ExposeAsSuperclass.class.isAssignableFrom(c)) { PyType exposedAs = fromClass(c.getSuperclass()); class_to_type.put(c, exposedAs); return exposedAs; } - Method setup = null; - boolean newstyle = Newstyle.class.isAssignableFrom(c); Class base = null; String name = null; TypeBuilder tb = classToBuilder == null ? null : classToBuilder.get(c); - if(tb != null) { + if (tb != null) { name = tb.getName(); - if(!tb.getBase().equals(Object.class)) { - base = tb.getBase(); + if (!tb.getBase().equals(Object.class)) { + base = tb.getBase(); } - newstyle = true; - } else { - try { - setup = c.getDeclaredMethod("typeSetup", new Class[] {PyObject.class, - Newstyle.class}); - newstyle = true; - } catch(NoSuchMethodException e) {} catch(Exception e) { - throw error(e); - } - if(newstyle) { // newstyle - base = (Class)exposed_decl_get_object(c, "base"); - name = (String)exposed_decl_get_object(c, "name"); - } } PyType newtype = class_to_type.get(c); if (newtype == null) { newtype = c == PyType.class ? new PyType(true) : new PyType(); class_to_type.put(c, newtype); - fillFromClass(newtype, name, c, base, newstyle, setup, tb); + fillFromClass(newtype, name, c, base, tb); } return newtype; } public static PyType TYPE = fromClass(PyType.class); - /* - * considers: - * if c implements Newstyle => c and all subclasses - * are considered newstyle - * - * if c has static typeSetup(PyObject dict, Newstyle marker) - * => c is considired newstyle, subclasses are not automatically; - * typeSetup is invoked to populate dict which will become - * type's __dict__ - * - * Class exposed_base - * String exposed_name - * - */ - public static synchronized PyType fromClass(Class c) { if (class_to_type == null) { class_to_type = new HashMap<Class, PyType>(); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <cg...@us...> - 2008-03-18 16:42:04
|
Revision: 4218 http://jython.svn.sourceforge.net/jython/?rev=4218&view=rev Author: cgroves Date: 2008-03-18 09:42:02 -0700 (Tue, 18 Mar 2008) Log Message: ----------- Patch from njriley to disallow setting and deleting fields on builtin types. Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-03-17 23:13:50 UTC (rev 4217) +++ trunk/jython/src/org/python/core/PyType.java 2008-03-18 16:42:02 UTC (rev 4218) @@ -1106,6 +1106,9 @@ } final void type___setattr__(String name, PyObject value) { + if (builtin) { + throw Py.TypeError("can't set attributes of built-in type '" + this.name + "'"); + } super.__setattr__(name, value); if (name == "__set__") { if (!has_set && lookup("__set__") != null) { @@ -1137,6 +1140,9 @@ } final void type___delattr__(String name) { + if (builtin) { + throw Py.TypeError("can't delete attributes of built-in type '" + this.name + "'"); + } super.__delattr__(name); if (name == "__set__") { if (has_set && lookup("__set__") == null) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pj...@us...> - 2008-03-19 19:44:04
|
Revision: 4227 http://jython.svn.sourceforge.net/jython/?rev=4227&view=rev Author: pjenvey Date: 2008-03-19 12:43:50 -0700 (Wed, 19 Mar 2008) Log Message: ----------- use the builtin variable instead of underlying_class. a builtin type may potentially lack an underlying java class (e.g. new style class Exceptions) Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-03-19 19:40:06 UTC (rev 4226) +++ trunk/jython/src/org/python/core/PyType.java 2008-03-19 19:43:50 UTC (rev 4227) @@ -658,7 +658,7 @@ @ExposedGet(name = "__name__") public String getName() { - if (underlying_class == null) { + if (!builtin) { return name; } int lastDot = name.lastIndexOf('.'); @@ -1215,7 +1215,7 @@ @ExposedGet(name = "__module__") public PyObject getModule() { - if (underlying_class == null) { + if (!builtin) { return dict.__finditem__("__module__"); } int lastDot = name.lastIndexOf('.'); @@ -1231,7 +1231,7 @@ public String toString() { String kind; - if (underlying_class == null) { + if (!builtin) { kind = "class"; } else { kind = "type"; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pj...@us...> - 2008-04-02 00:32:11
|
Revision: 4265 http://jython.svn.sourceforge.net/jython/?rev=4265&view=rev Author: pjenvey Date: 2008-04-01 17:32:10 -0700 (Tue, 01 Apr 2008) Log Message: ----------- some cleanup: coding standards, whitespace Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-04-02 00:10:30 UTC (rev 4264) +++ trunk/jython/src/org/python/core/PyType.java 2008-04-02 00:32:10 UTC (rev 4265) @@ -24,62 +24,420 @@ import org.python.expose.TypeBuilder; /** - * first-class Python type. + * The Python Type object implementation. * */ @ExposedType(name = "type") public class PyType extends PyObject implements Serializable { + public static PyType TYPE = fromClass(PyType.class); + + /** The type's name. builtin types include their fully qualified + * name, e.g.: time.struct_time. */ + private String name; + + /** __base__, the direct base type or null. */ + private PyType base; + + /** __bases__, the base classes. */ + private PyObject[] bases = new PyObject[0]; + + /** __dict__. */ + private PyObject dict; + + /** __mro__, the method resolution. order */ + private PyObject[] mro = new PyObject[0]; + + /** __flags__, the type's options. */ + private long tp_flags; + + /** The underlying java class or null. */ + private Class underlying_class; + + /** Whether it's a builtin type. */ + boolean builtin = false; + + /** Whether new instances of this type can be instantiated */ + private boolean non_instantiable = false; + + /** Whether this type has set/delete descriptors */ + boolean has_set; + boolean has_delete; + + /** Whether finalization is required for this type's instances + * (implements __del__). */ + private boolean needs_finalizer; + + /** Whether this type's instances require a __dict__. */ + private boolean needs_userdict = true; + + /** The number of __slots__ defined. */ + private int numSlots; + + private ReferenceQueue<PyType> subclasses_refq = new ReferenceQueue<PyType>(); + private HashSet<WeakReference<PyType>> subclasses = new HashSet<WeakReference<PyType>>(); + + private final static Class[] O = {PyObject.class}; + private final static Class[] OO = {PyObject.class, PyObject.class}; + + /** Mapping of Java classes to their PyTypes. */ + private static HashMap<Class, PyType> class_to_type; + + /** Mapping of Java classes to their TypeBuilders. */ + private static HashMap<Class, TypeBuilder> classToBuilder; + + private PyType() { + } + + private PyType(boolean dummy) { + super(true); + } + + PyType(PyType subtype) { + super(subtype); + } + @ExposedNew - public static PyObject type_new(PyNewWrapper new_, boolean init, - PyType subtype, PyObject[] args, String[] keywords) { + public static PyObject type___new__(PyNewWrapper new_, boolean init, PyType subtype, + PyObject[] args, String[] keywords) { if (args.length == 1 && keywords.length == 0) { return args[0].getType(); } - if (args.length + keywords.length != 3) + if (args.length + keywords.length != 3) { throw Py.TypeError("type() takes exactly 1 or 3 arguments"); - ArgParser ap = new ArgParser("type()", args, keywords, "name", "bases", - "dict"); + } + + ArgParser ap = new ArgParser("type()", args, keywords, "name", "bases", "dict"); String name = ap.getString(0); PyObject bases = ap.getPyObject(1); - if (!(bases instanceof PyTuple)) + + if (!(bases instanceof PyTuple)) { throw Py.TypeError("type(): bases must be tuple"); + } PyObject dict = ap.getPyObject(2); - if (!(dict instanceof PyDictionary || dict instanceof PyStringMap)) + if (!(dict instanceof PyDictionary || dict instanceof PyStringMap)) { throw Py.TypeError("type(): dict must be dict"); + } return newType(new_, subtype, name, (PyTuple) bases, dict); } - private Object writeReplace() { - //System.err.println("replace type"); - return new TypeResolver(underlying_class, getModule().toString(), name); + public static PyObject newType(PyNewWrapper new_, PyType metatype, String name, PyTuple bases, + PyObject dict) { + PyType object_type = fromClass(PyObject.class); + + PyObject[] bases_list = bases.getArray(); + PyType winner = findMostDerivedMetatype(bases_list, metatype); + if (winner != metatype) { + PyObject winner_new_ = winner.lookup("__new__"); + if (winner_new_ != null && winner_new_ != new_) { + return invoke_new_(new_, winner, false, + new PyObject[] {new PyString(name), bases, dict}, + Py.NoKeywords); + } + metatype = winner; + } + if (bases_list.length == 0) { + bases_list = new PyObject[] {object_type}; + } + + // XXX can be subclassed ? + if (dict.__finditem__("__module__") == null) { + PyFrame frame = Py.getFrame(); + if (frame != null) { + PyObject globals = frame.f_globals; + PyObject modname; + if ((modname = globals.__finditem__("__name__")) != null) { + dict.__setitem__("__module__", modname); + } + } + } + // XXX also __doc__ __module__ + + PyType newtype; + if (new_.for_type == metatype) { + newtype = new PyType(); // XXX set metatype + } else { + newtype = new PyTypeDerived(metatype); + } + newtype.dict = dict; + newtype.name = name; + newtype.base = best_base(bases_list); + newtype.numSlots = newtype.base.numSlots; + newtype.bases = bases_list; + + PyObject slots = dict.__finditem__("__slots__"); + if (slots != null) { + newtype.needs_userdict = false; + if (slots instanceof PyString) { + addSlot(newtype, slots); + } else { + for (PyObject slotname : slots.asIterable()) { + addSlot(newtype, slotname); + } + } + } + if (!newtype.needs_userdict) { + newtype.needs_userdict = necessitatesUserdict(bases_list); + } + + newtype.tp_flags = Py.TPFLAGS_HEAPTYPE; + + // special case __new__, if function => static method + PyObject tmp = dict.__finditem__("__new__"); + if (tmp != null && tmp instanceof PyFunction) { // xxx java functions? + dict.__setitem__("__new__",new PyStaticMethod(tmp)); + } + + newtype.mro_internal(); + // __dict__ descriptor + if (newtype.needs_userdict && newtype.lookup("__dict__") == null) { + dict.__setitem__("__dict__", new PyDataDescr(newtype, "__dict__", PyObject.class) { + + @Override + public Object invokeGet(PyObject obj) { + return obj.getDict(); + } + + @Override + public boolean implementsDescrSet() { + return true; + } + + @Override + public void invokeSet(PyObject obj, Object value) { + obj.setDict((PyObject)value); + } + + @Override + public boolean implementsDescrDelete() { + return true; + } + + @Override + public void invokeDelete(PyObject obj) { + obj.delDict(); + } + }); + } + + newtype.has_set = newtype.lookup("__set__") != null; + newtype.has_delete = newtype.lookup("__delete__") != null; + newtype.needs_finalizer = newtype.lookup("__del__") != null; + + for (int i = 0; i < bases_list.length; i++) { + PyObject cur = bases_list[i]; + if (cur instanceof PyType) + ((PyType)cur).attachSubclass(newtype); + } + return newtype; } - - static class TypeResolver implements Serializable { - private Class underlying_class; - private String module; - private String name; - - TypeResolver(Class underlying_class, String module, String name) { - this.underlying_class = underlying_class; - this.module = module; - this.name = name; + + private static PyObject invoke_new_(PyObject new_, PyType type, boolean init, PyObject[] args, + String[] keywords) { + PyObject newobj; + if (new_ instanceof PyNewWrapper) { + newobj = ((PyNewWrapper) new_).new_impl(init, type, args, keywords); + } else { + int n = args.length; + PyObject[] type_prepended = new PyObject[n + 1]; + System.arraycopy(args, 0, type_prepended, 1, n); + type_prepended[0] = type; + newobj = new_.__get__(null, type).__call__(type_prepended, keywords); } - - private Object readResolve() { - //System.err.println("resolve: "+module+"."+name); - if(underlying_class!=null) - return PyType.fromClass(underlying_class); - PyObject mod = imp.importName(module.intern(), false); - PyObject pytyp = mod.__getattr__(name.intern()); - if (!(pytyp instanceof PyType)) { - throw Py.TypeError(module+"."+name+" must be a type for deserialization"); + /* special case type(x) */ + if (type == TYPE && args.length==1 && keywords.length==0) { + return newobj; + } + newobj.dispatch__init__(type,args,keywords); + return newobj; + } + + private static void fillFromClass(PyType newtype, String name, Class c, Class base, + TypeBuilder tb) { + if (base == null) { + base = c.getSuperclass(); + } + if (name == null) { + name = c.getName(); + // Strip the java fully qualified class name (specifically + // remove org.python.core.Py or fallback to stripping to + // the last dot) + if (name.startsWith("org.python.core.Py")) { + name = name.substring("org.python.core.Py".length()).toLowerCase(); + } else { + int lastDot = name.lastIndexOf('.'); + if (lastDot != -1) { + name = name.substring(lastDot + 1); + } } - return pytyp; } - + newtype.name = name; + newtype.underlying_class = c; + newtype.builtin = true; + // basic mro, base, bases + fillInMRO(newtype, base); + PyObject dict; + if (tb != null) { + dict = tb.getDict(newtype); + newtype.non_instantiable = dict.__finditem__("__new__") == null; + } else { + dict = new PyStringMap(); + fillInClassic(c, base, dict); + } + if (base != Object.class) { + if (get_descr_method(c, "__set__", OO) != null || /* backw comp */ + get_descr_method(c, "_doset", OO) != null) { + newtype.has_set = true; + } + if (get_descr_method(c, "__delete__", O) != null || /* backw comp */ + get_descr_method(c, "_dodel", O) != null) { + newtype.has_delete = true; + } + } + newtype.dict = dict; } + private static void fillInClassic(Class c, Class<?> base, PyObject dict) { + if (Py.BOOTSTRAP_TYPES.contains(c)) { + // BOOTSTRAP_TYPES will be filled in by addBuilder later + return; + } + HashMap<String, Object> propnames = new HashMap<String, Object>(); + Method[] methods = c.getMethods(); + for (int i = 0; i < methods.length; i++) { + Method meth = methods[i]; + Class declaring = meth.getDeclaringClass(); + if (declaring != base && base.isAssignableFrom(declaring) && !ignore(meth)) { + String methname = meth.getName(); + String nmethname = normalize_name(methname); + PyReflectedFunction reflfunc = (PyReflectedFunction)dict.__finditem__(nmethname); + boolean added = false; + if (reflfunc == null) { + dict.__setitem__(nmethname, new PyReflectedFunction(meth)); + added = true; + } else { + reflfunc.addMethod(meth); + added = true; + } + if (added && !Modifier.isStatic(meth.getModifiers())) { + // check for xxxX.* + int n = meth.getParameterTypes().length; + if (methname.startsWith("get") && n == 0) { + propnames.put(methname.substring(3), "getter"); + } else if (methname.startsWith("is") && n == 0 + && meth.getReturnType() == Boolean.TYPE) { + propnames.put(methname.substring(2), "getter"); + } else if (methname.startsWith("set") && n == 1) { + propnames.put(methname.substring(3), meth); + } + } + } + } + for (int i = 0; i < methods.length; i++) { + Method meth = methods[i]; + String nmethname = normalize_name(meth.getName()); + PyReflectedFunction reflfunc = (PyReflectedFunction)dict.__finditem__(nmethname); + if (reflfunc != null) { + reflfunc.addMethod(meth); + } + } + Field[] fields = c.getFields(); + for (int i = 0; i < fields.length; i++) { + Field field = fields[i]; + Class declaring = field.getDeclaringClass(); + if (declaring != base && base.isAssignableFrom(declaring)) { + String fldname = field.getName(); + int fldmods = field.getModifiers(); + Class fldtype = field.getType(); + if (Modifier.isStatic(fldmods)) { + if (fldname.startsWith("__doc__") && fldname.length() > 7 + && fldtype == PyString.class) { + String fname = fldname.substring(7).intern(); + PyObject memb = dict.__finditem__(fname); + if (memb != null && memb instanceof PyReflectedFunction) { + PyString doc = null; + try { + doc = (PyString)field.get(null); + } catch (IllegalAccessException e) { + throw error(e); + } + ((PyReflectedFunction)memb).__doc__ = doc; + } + } + } + dict.__setitem__(normalize_name(fldname), new PyReflectedField(field)); + } + } + for (Iterator iter = propnames.keySet().iterator(); iter.hasNext();) { + String propname = (String)iter.next(); + String npropname = normalize_name(decapitalize(propname)); + PyObject prev = dict.__finditem__(npropname); + if (prev != null && prev instanceof PyReflectedFunction) { + continue; + } + Method getter = null; + Method setter = null; + Class proptype = null; + getter = get_non_static_method(c, "get" + propname, new Class[] {}); + if (getter == null) + getter = get_non_static_method(c, "is" + propname, new Class[] {}); + if (getter != null) { + proptype = getter.getReturnType(); + setter = get_non_static_method(c, "set" + propname, new Class[] {proptype}); + } else { + Object o = propnames.get(propname); + if (o instanceof Method) { + setter = (Method)o; + proptype = setter.getParameterTypes()[0]; + } + } + if (setter != null || getter != null) { + dict.__setitem__(npropname, new PyBeanProperty(npropname, proptype, getter, + setter)); + } else { + // XXX error + } + } + Constructor[] ctrs = c.getConstructors(); + if (ctrs.length != 0) { + final PyReflectedConstructor reflctr = new PyReflectedConstructor("_new_impl"); + for (int i = 0; i < ctrs.length; i++) { + reflctr.addConstructor(ctrs[i]); + } + PyObject new_ = new PyNewWrapper(c, "__new__", -1, -1) { + public PyObject new_impl(boolean init, PyType subtype, PyObject[] args, + String[] keywords) { + return reflctr.make(args, keywords); + } + }; + dict.__setitem__("__new__", new_); + } + if (ClassDictInit.class.isAssignableFrom(c) && c != ClassDictInit.class) { + try { + @SuppressWarnings("unchecked") + Method m = c.getMethod("classDictInit", PyObject.class); + m.invoke(null, new Object[] {dict}); + } catch(Exception exc) { + throw error(exc); + } + } + } + + private static void fillInMRO(PyType type, Class base) { + PyType[] mro; + if (base == Object.class) { + mro = new PyType[] {type}; + } else { + PyType baseType = fromClass(base); + mro = new PyType[baseType.mro.length + 1]; + System.arraycopy(baseType.mro, 0, mro, 1, baseType.mro.length); + mro[0] = type; + type.base = baseType; + type.bases = new PyObject[] {baseType}; + } + type.mro = mro; + } + public PyObject getStatic() { PyType cur = this; while (cur.underlying_class == null) { @@ -87,25 +445,24 @@ } return cur; } - + /** * Checks that the physical layout between this type and <code>other</code> * are compatible. */ public boolean layoutAligns(PyType other) { - return getLayout().equals(other.getLayout()) - && needs_userdict == other.needs_userdict + return getLayout().equals(other.getLayout()) && needs_userdict == other.needs_userdict && needs_finalizer == other.needs_finalizer; } - + /** * Gets the most parent PyType that determines the layout of this type ie * has slots or an underlying_class. Can by this PyType. */ private PyType getLayout(){ - if(underlying_class != null){ + if (underlying_class != null){ return this; - }else if(numSlots != base.numSlots){ + } else if (numSlots != base.numSlots){ return this; } return base.getLayout(); @@ -130,26 +487,28 @@ @ExposedSet(name = "__bases__") public void setBases(PyObject newBasesTuple) { - if(!(newBasesTuple instanceof PyTuple)){ + if (!(newBasesTuple instanceof PyTuple)){ throw Py.TypeError("bases must be a tuple"); } PyObject[] newBases = ((PyTuple)newBasesTuple).getArray(); if (newBases.length == 0) { - throw Py.TypeError("can only assign non-empty tuple to __bases__, not " + newBasesTuple); + throw Py.TypeError("can only assign non-empty tuple to __bases__, not " + + newBasesTuple); } - for(int i = 0; i < newBases.length; i++) { - if(!(newBases[i] instanceof PyType)){ - if(!(newBases[i] instanceof PyClass)){ - throw Py.TypeError(name + ".__bases__ must be a tuple of old- or new-style classes, not " + newBases[i]); + for (int i = 0; i < newBases.length; i++) { + if (!(newBases[i] instanceof PyType)){ + if (!(newBases[i] instanceof PyClass)){ + throw Py.TypeError(name + ".__bases__ must be a tuple of old- or new-style " + + "classes, not " + newBases[i]); } - }else{ - if(((PyType)newBases[i]).isSubType(this)){ + } else { + if (((PyType)newBases[i]).isSubType(this)){ throw Py.TypeError("a __bases__ item causes an inheritance cycle"); } } } PyType newBase = best_base(newBases); - if(!newBase.layoutAligns(base)) { + if (!newBase.layoutAligns(base)) { throw Py.TypeError("'" + base + "' layout differs from '" + newBase + "'"); } PyObject[] savedBases = bases; @@ -161,18 +520,18 @@ base = newBase; mro_internal(); mro_subclasses(savedSubMros); - for(int i = 0; i < savedBases.length; i++) { - if(savedBases[i] instanceof PyType) { + for (int i = 0; i < savedBases.length; i++) { + if (savedBases[i] instanceof PyType) { ((PyType)savedBases[i]).detachSubclass(this); } } - for(int i = 0; i < newBases.length; i++) { - if(newBases[i] instanceof PyType) { + for (int i = 0; i < newBases.length; i++) { + if (newBases[i] instanceof PyType) { ((PyType)newBases[i]).attachSubclass(this); } } } catch(PyException t) { - for(Iterator it = savedSubMros.iterator(); it.hasNext(); ){ + for (Iterator it = savedSubMros.iterator(); it.hasNext(); ){ PyType subtype = (PyType)it.next(); PyObject[] subtypeSavedMro = (PyObject[])it.next(); subtype.mro = subtypeSavedMro; @@ -182,17 +541,17 @@ mro = savedMro; throw t; } - + } private void mro_internal() { - if(getType().underlying_class != PyType.class && getType().lookup("mro") != null) { + if (getType().underlying_class != PyType.class && getType().lookup("mro") != null) { mro = Py.make_array(getType().lookup("mro").__get__(null, getType()).__call__(this)); } else { mro = compute_mro(); } } - + /** * Collects the subclasses and current mro of this type in mroCollector. If * this type has subclasses C and D, and D has a subclass E current @@ -200,7 +559,7 @@ * this call. */ private void mro_subclasses(List<Object> mroCollector){ - for(WeakReference<PyType> ref : subclasses) { + for (WeakReference<PyType> ref : subclasses) { PyType subtype = ref.get(); if (subtype == null) { continue; @@ -219,27 +578,6 @@ return null; } - private String name; - private PyType base; - private PyObject[] bases = new PyObject[0]; - private PyObject dict; - private PyObject[] mro = new PyObject[0]; - private long tp_flags; - private Class underlying_class; - - boolean builtin = false; - - private boolean non_instantiable = false; - - boolean has_set, has_delete; - - private boolean needs_finalizer; - private int numSlots; - private boolean needs_userdict = true; - - private ReferenceQueue<PyType> subclasses_refq = new ReferenceQueue<PyType>(); - private HashSet<WeakReference<PyType>> subclasses = new HashSet<WeakReference<PyType>>(); - private void cleanup_subclasses() { Reference ref; while ((ref = subclasses_refq.poll()) != null) { @@ -256,12 +594,12 @@ public PyLong getFlags() { return new PyLong(tp_flags); } - + @ExposedMethod public synchronized final PyObject type___subclasses__() { PyList result = new PyList(); cleanup_subclasses(); - for(WeakReference<PyType> ref : subclasses) { + for (WeakReference<PyType> ref : subclasses) { PyType subtype = ref.get(); if (subtype == null) continue; @@ -277,17 +615,13 @@ private synchronized void detachSubclass(PyType subtype) { cleanup_subclasses(); - for(WeakReference<PyType> ref : subclasses) { - if(ref.get() == subtype){ + for (WeakReference<PyType> ref : subclasses) { + if (ref.get() == subtype){ subclasses.remove(ref); break; } } } - - private interface OnType { - boolean onType(PyType type); - } private synchronized void traverse_hierarchy(boolean top, OnType behavior) { boolean stop = false; @@ -297,7 +631,7 @@ if (stop) { return; } - for(WeakReference<PyType> ref : subclasses) { + for (WeakReference<PyType> ref : subclasses) { PyType subtype = ref.get(); if (subtype == null) { continue; @@ -307,11 +641,11 @@ } private static void fill_classic_mro(ArrayList<PyObject> acc,PyClass classic_cl) { - if(!acc.contains(classic_cl)) { + if (!acc.contains(classic_cl)) { acc.add(classic_cl); } PyObject[] bases = classic_cl.__bases__.getArray(); - for (int i=0; i <bases.length; i++) { + for (int i = 0; i < bases.length; i++) { fill_classic_mro(acc,(PyClass)bases[i]); } } @@ -324,7 +658,7 @@ private static boolean tail_contains(PyObject[] lst,int whence,PyObject o) { int n = lst.length; - for (int i=whence+1; i < n; i++) { + for (int i = whence + 1; i < n; i++) { if (lst[i] == o) { return true; } @@ -333,13 +667,13 @@ } private static PyException mro_error(PyObject[][] to_merge,int[] remain) { - StringBuffer msg = new StringBuffer("Cannot create a consistent method resolution\n" + - "order (MRO) for bases "); + StringBuffer msg = new StringBuffer("Cannot create a consistent method resolution\n" + + "order (MRO) for bases "); PyDictionary set = new PyDictionary(); for (int i=0; i < to_merge.length; i++) { PyObject[] lst = to_merge[i]; - if(remain[i] < lst.length) { - set.__setitem__(lst[remain[i]],Py.None); + if (remain[i] < lst.length) { + set.__setitem__(lst[remain[i]], Py.None); } } PyObject iter = set.__iter__(); @@ -352,14 +686,14 @@ } else { msg.append(", "); } - msg.append(name==null?"?":name.toString()); + msg.append(name == null ? "?" : name.toString()); } return Py.TypeError(msg.toString()); } @ExposedMethod(defaults = "null") final PyList type_mro(PyObject o) { - if(o == null) { + if (o == null) { return new PyList(compute_mro()); } return new PyList(((PyType)o).compute_mro()); @@ -368,27 +702,27 @@ final PyObject[] compute_mro() { PyObject[] bases = this.bases; int n = bases.length; - for(int i = 0; i < n; i++) { + for (int i = 0; i < n; i++) { PyObject cur = bases[i]; - for(int j = i + 1; j < n; j++) { - if(bases[j] == cur) { + for (int j = i + 1; j < n; j++) { + if (bases[j] == cur) { PyObject name = cur.__findattr__("__name__"); - throw Py.TypeError("duplicate base class " - + (name == null ? "?" : name.toString())); + throw Py.TypeError("duplicate base class " + + (name == null ? "?" : name.toString())); } } } - int nmerge = n+1; + int nmerge = n + 1; PyObject[][] to_merge = new PyObject[nmerge][]; int[] remain = new int[nmerge]; - for(int i = 0; i < n; i++) { + for (int i = 0; i < n; i++) { PyObject cur = bases[i]; remain[i] = 0; - if(cur instanceof PyType) { + if (cur instanceof PyType) { to_merge[i] = ((PyType)cur).mro; - } else if(cur instanceof PyClass) { + } else if (cur instanceof PyClass) { to_merge[i] = classic_mro((PyClass)cur); } } @@ -399,7 +733,7 @@ ArrayList<PyObject> acc = new ArrayList<PyObject>(); acc.add(this); - int empty_cnt=0; + int empty_cnt = 0; scan : for (int i = 0; i < nmerge; i++) { PyObject candidate; @@ -411,13 +745,14 @@ candidate = cur[remain[i]]; for (int j = 0; j < nmerge; j++) - if (tail_contains(to_merge[j],remain[j],candidate)) + if (tail_contains(to_merge[j],remain[j],candidate)) { continue scan; + } acc.add(candidate); for (int j = 0; j < nmerge; j++) { - if (remain[j]<to_merge[j].length && - to_merge[j][remain[j]]==candidate) + if (remain[j]<to_merge[j].length && to_merge[j][remain[j]]==candidate) { remain[j]++; + } } // restart scan i = -1; @@ -431,12 +766,12 @@ /** * Finds the parent of base with an underlying_class or with slots - * + * * @raises Py.TypeError if there is no solid base for base */ private static PyType solid_base(PyType base) { PyObject[] mro = base.mro; - for (int i=0; i<mro.length; i++) { + for (int i = 0; i < mro.length; i++) { PyObject parent = mro[i]; if (parent instanceof PyType) { PyType parent_type =(PyType)parent; @@ -454,7 +789,7 @@ /** * Finds the base in bases with the most derived solid_base, ie the most base type - * + * * @throws Py.TypeError if the bases don't all derive from the same solid_base * @throws Py.TypeError if at least one of the bases isn't a new-style class */ @@ -462,12 +797,14 @@ PyType winner = null; PyType candidate = null; PyType best = null; - for (int i=0; i < bases.length;i++) { + for (int i = 0; i < bases.length; i++) { PyObject base_proto = bases[i]; - if (base_proto instanceof PyClass) + if (base_proto instanceof PyClass) { continue; - if (!(base_proto instanceof PyType)) + } + if (!(base_proto instanceof PyType)) { throw Py.TypeError("bases must be types"); + } PyType base = (PyType)base_proto; candidate = solid_base(base); if (winner == null) { @@ -482,124 +819,17 @@ throw Py.TypeError("multiple bases have instance lay-out conflict"); } } - if (best == null) + if (best == null) { throw Py.TypeError("a new-style class can't have only classic bases"); + } return best; } - public static PyObject newType(PyNewWrapper new_,PyType metatype,String name,PyTuple bases,PyObject dict) { - PyType object_type = fromClass(PyObject.class); - - PyObject[] bases_list = bases.getArray(); - PyType winner = findMostDerivedMetatype(bases_list, metatype); - if (winner != metatype) { - PyObject winner_new_ = winner.lookup("__new__"); - if (winner_new_ !=null && winner_new_ != new_) { - return invoke_new_(new_,winner,false,new PyObject[] {new PyString(name),bases,dict},Py.NoKeywords); - } - metatype = winner; - } - if (bases_list.length == 0) { - bases_list = new PyObject[] {object_type}; - } - - // xxx can be subclassed ? - if (dict.__finditem__("__module__") == null) { - PyFrame frame = Py.getFrame(); - if (frame != null) { - PyObject globals = frame.f_globals; - PyObject modname; - if ((modname = globals.__finditem__("__name__")) != null) { - dict.__setitem__("__module__", modname); - } - } - } - // xxx also __doc__ __module__ - - PyType newtype; - if (new_.for_type == metatype) { - newtype = new PyType(); // xxx set metatype - } else { - newtype = new PyTypeDerived(metatype); - } - newtype.dict = dict; - newtype.name = name; - newtype.base = best_base(bases_list); - newtype.numSlots = newtype.base.numSlots; - newtype.bases = bases_list; - - PyObject slots = dict.__finditem__("__slots__"); - if(slots != null) { - newtype.needs_userdict = false; - if(slots instanceof PyString) { - addSlot(newtype, slots); - } else { - for (PyObject slotname : slots.asIterable()) { - addSlot(newtype, slotname); - } - } - } - if(!newtype.needs_userdict) { - newtype.needs_userdict = necessitatesUserdict(bases_list); - } - - newtype.tp_flags=Py.TPFLAGS_HEAPTYPE; - - // special case __new__, if function => static method - PyObject tmp = dict.__finditem__("__new__"); - if (tmp != null && tmp instanceof PyFunction) { // xxx java functions? - dict.__setitem__("__new__",new PyStaticMethod(tmp)); - } - - newtype.mro_internal(); - // __dict__ descriptor - if (newtype.needs_userdict && newtype.lookup("__dict__") == null) { - dict.__setitem__("__dict__", new PyDataDescr(newtype, "__dict__", PyObject.class) { - - @Override - public Object invokeGet(PyObject obj) { - return obj.getDict(); - } - - @Override - public boolean implementsDescrSet() { - return true; - } - - @Override - public void invokeSet(PyObject obj, Object value) { - obj.setDict((PyObject)value); - } - - @Override - public boolean implementsDescrDelete() { - return true; - } - - @Override - public void invokeDelete(PyObject obj) { - obj.delDict(); - } - }); - } - - newtype.has_set = newtype.lookup("__set__") != null; - newtype.has_delete = newtype.lookup("__delete__") != null; - newtype.needs_finalizer = newtype.lookup("__del__") != null; - - for (int i=0; i<bases_list.length;i++) { - PyObject cur = bases_list[i]; - if (cur instanceof PyType) - ((PyType)cur).attachSubclass(newtype); - } - return newtype; - } - private static boolean necessitatesUserdict(PyObject[] bases_list) { - for(int i = 0; i < bases_list.length; i++) { + for (int i = 0; i < bases_list.length; i++) { PyObject cur = bases_list[i]; - if((cur instanceof PyType && ((PyType)cur).needs_userdict && ((PyType)cur).numSlots > 0) - || cur instanceof PyClass) { + if ((cur instanceof PyType && ((PyType)cur).needs_userdict + && ((PyType)cur).numSlots > 0) || cur instanceof PyClass) { return true; } } @@ -607,34 +837,37 @@ } /** - * Finds the most derived subtype of initialMetatype in the types of bases, or initialMetatype if - * it is already the most derived. - * - * @raises Py.TypeError if the all the metaclasses don't descend from the same base - * @raises Py.TypeError if one of the bases is a PyJavaClass or a PyClass with no proxyClass + * Finds the most derived subtype of initialMetatype in the types + * of bases, or initialMetatype if it is already the most derived. + * + * @raises Py.TypeError if the all the metaclasses don't descend + * from the same base + * @raises Py.TypeError if one of the bases is a PyJavaClass or a + * PyClass with no proxyClass */ private static PyType findMostDerivedMetatype(PyObject[] bases_list, PyType initialMetatype) { PyType winner = initialMetatype; - for (int i=0; i<bases_list.length; i++) { + for (int i = 0; i < bases_list.length; i++) { PyObject bases_i = bases_list[i]; - if (bases_i instanceof PyJavaClass) + if (bases_i instanceof PyJavaClass) { throw Py.TypeError("can't mix new-style and java classes"); + } if (bases_i instanceof PyClass) { - if (((PyClass)bases_i).proxyClass != null) + if (((PyClass)bases_i).proxyClass != null) { throw Py.TypeError("can't mix new-style and java classes"); + } continue; } PyType curtype = bases_i.getType(); - if (winner.isSubType(curtype)) + if (winner.isSubType(curtype)) { continue; + } if (curtype.isSubType(winner)) { winner = curtype; continue; } - throw Py.TypeError("metaclass conflict: "+ - "the metaclass of a derived class "+ - "must be a (non-strict) subclass "+ - "of the metaclasses of all its bases"); + throw Py.TypeError("metaclass conflict: the metaclass of a derived class must be a " + + "(non-strict) subclass of the metaclasses of all its bases"); } return winner; } @@ -642,16 +875,14 @@ private static void addSlot(PyType newtype, PyObject slotname) { confirmIdentifier(slotname); String slotstring = mangleName(newtype.name, slotname.toString()); - if(slotstring.equals("__dict__")) { + if (slotstring.equals("__dict__")) { newtype.needs_userdict = true; } else { - newtype.dict.__setitem__(slotstring, new PySlot(newtype, - slotstring, - newtype.numSlots++)); + newtype.dict.__setitem__(slotstring, new PySlot(newtype, slotstring, + newtype.numSlots++)); } } - public String fastGetName() { return name; } @@ -679,18 +910,18 @@ /** * INTERNAL lookup for name through mro objects' dicts - * + * * @param name * attribute name (must be interned) * @return found object or null */ public PyObject lookup(String name) { PyObject[] mro = this.mro; - for(int i = 0; i < mro.length; i++) { + for (int i = 0; i < mro.length; i++) { PyObject dict = mro[i].fastGetDict(); - if(dict != null) { + if (dict != null) { PyObject obj = dict.__finditem__(name); - if(obj != null) + if (obj != null) return obj; } } @@ -716,7 +947,7 @@ public PyObject super_lookup(PyType ref,String name) { PyObject[] mro = this.mro; int i; - for (i=0; i < mro.length; i++) { + for (i = 0; i < mro.length; i++) { if (mro[i] == ref) break; } @@ -732,22 +963,12 @@ return null; } - private PyType(boolean dummy) { - super(true); - } - - private PyType() { - } - - PyType(PyType subtype) { - super(subtype); - } - private static String decapitalize(String s) { char c0 = s.charAt(0); if (Character.isUpperCase(c0)) { - if (s.length() > 1 && Character.isUpperCase(s.charAt(1))) + if (s.length() > 1 && Character.isUpperCase(s.charAt(1))) { return s; + } char[] cs = s.toCharArray(); cs[0] = Character.toLowerCase(c0); return new String(cs); @@ -757,8 +978,9 @@ } private static String normalize_name(String name) { - if (name.endsWith("$")) + if (name.endsWith("$")) { name = name.substring(0, name.length() - 1); + } return name.intern(); } @@ -769,15 +991,18 @@ private static Method get_non_static_method(Class<?> c, String name, Class[] parmtypes) { try { Method meth = c.getMethod(name, parmtypes); - if (!Modifier.isStatic(meth.getModifiers())) + if (!Modifier.isStatic(meth.getModifiers())) { return meth; - } catch (NoSuchMethodException e) {} + } + } catch (NoSuchMethodException e) { + // ok + } return null; } private static Method get_descr_method(Class c, String name, Class[] parmtypes) { Method meth = get_non_static_method(c, name, parmtypes); - if(meth != null && meth.getDeclaringClass() != PyObject.class) { + if (meth != null && meth.getDeclaringClass() != PyObject.class) { return meth; } return null; @@ -793,226 +1018,16 @@ return false; } - private final static Class[] O = { PyObject.class }; - private final static Class[] OO = { PyObject.class, PyObject.class }; - - private static void fillFromClass(PyType newtype, - String name, - Class c, - Class base, - TypeBuilder tb) { - - if(base == null) { - base = c.getSuperclass(); - } - if(name == null) { - name = c.getName(); - // Strip the java fully qualified class name (specifically - // remove org.python.core.Py or fallback to stripping to - // the last dot) - if(name.startsWith("org.python.core.Py")) { - name = name.substring("org.python.core.Py".length()).toLowerCase(); - } else { - int lastDot = name.lastIndexOf('.'); - if(lastDot != -1) { - name = name.substring(lastDot + 1); - } - } - } - newtype.name = name; - newtype.underlying_class = c; - newtype.builtin = true; - // basic mro, base, bases - fillInMRO(newtype, base); - PyObject dict; - if (tb != null) { - dict = tb.getDict(newtype); - newtype.non_instantiable = dict.__finditem__("__new__") == null; - } else { - dict = new PyStringMap(); - fillInClassic(c, base, dict); - } - if (base != Object.class) { - if (get_descr_method(c, "__set__", OO) != null || /* backw comp */ - get_descr_method(c, "_doset", OO) != null) { - newtype.has_set = true; - } - if (get_descr_method(c, "__delete__", O) != null || /* backw comp */ - get_descr_method(c, "_dodel", O) != null) { - newtype.has_delete = true; - } - } - newtype.dict = dict; - } - - private static void fillInClassic(Class c, Class<?> base, PyObject dict) { - if (Py.BOOTSTRAP_TYPES.contains(c)) { - // BOOTSTRAP_TYPES will be filled in by addBuilder later - return; - } - HashMap<String, Object> propnames = new HashMap<String, Object>(); - Method[] methods = c.getMethods(); - for(int i = 0; i < methods.length; i++) { - Method meth = methods[i]; - Class declaring = meth.getDeclaringClass(); - if(declaring != base && base.isAssignableFrom(declaring) - && !ignore(meth)) { - String methname = meth.getName(); - String nmethname = normalize_name(methname); - PyReflectedFunction reflfunc = (PyReflectedFunction)dict.__finditem__(nmethname); - boolean added = false; - if(reflfunc == null) { - dict.__setitem__(nmethname, new PyReflectedFunction(meth)); - added = true; - } else { - reflfunc.addMethod(meth); - added = true; - } - if(added && !Modifier.isStatic(meth.getModifiers())) { - // check for xxxX.* - int n = meth.getParameterTypes().length; - if(methname.startsWith("get") && n == 0) { - propnames.put(methname.substring(3), "getter"); - } else if(methname.startsWith("is") && n == 0 - && meth.getReturnType() == Boolean.TYPE) { - propnames.put(methname.substring(2), "getter"); - } else if(methname.startsWith("set") && n == 1) { - propnames.put(methname.substring(3), meth); - } - } - } - } - for(int i = 0; i < methods.length; i++) { - Method meth = methods[i]; - String nmethname = normalize_name(meth.getName()); - PyReflectedFunction reflfunc = (PyReflectedFunction)dict.__finditem__(nmethname); - if(reflfunc != null) { - reflfunc.addMethod(meth); - } - } - Field[] fields = c.getFields(); - for(int i = 0; i < fields.length; i++) { - Field field = fields[i]; - Class declaring = field.getDeclaringClass(); - if(declaring != base && base.isAssignableFrom(declaring)) { - String fldname = field.getName(); - int fldmods = field.getModifiers(); - Class fldtype = field.getType(); - if (Modifier.isStatic(fldmods)) { - if (fldname.startsWith("__doc__") && fldname.length() > 7 - && fldtype == PyString.class) { - String fname = fldname.substring(7).intern(); - PyObject memb = dict.__finditem__(fname); - if (memb != null && memb instanceof PyReflectedFunction) { - PyString doc = null; - try { - doc = (PyString)field.get(null); - } catch (IllegalAccessException e) { - throw error(e); - } - ((PyReflectedFunction)memb).__doc__ = doc; - } - } - } - dict.__setitem__(normalize_name(fldname), new PyReflectedField(field)); - } - } - for(Iterator iter = propnames.keySet().iterator(); iter.hasNext();) { - String propname = (String)iter.next(); - String npropname = normalize_name(decapitalize(propname)); - PyObject prev = dict.__finditem__(npropname); - if(prev != null && prev instanceof PyReflectedFunction) { - continue; - } - Method getter = null; - Method setter = null; - Class proptype = null; - getter = get_non_static_method(c, "get" + propname, new Class[] {}); - if(getter == null) - getter = get_non_static_method(c, - "is" + propname, - new Class[] {}); - if(getter != null) { - proptype = getter.getReturnType(); - setter = get_non_static_method(c, - "set" + propname, - new Class[] {proptype}); - } else { - Object o = propnames.get(propname); - if(o instanceof Method) { - setter = (Method)o; - proptype = setter.getParameterTypes()[0]; - } - } - if(setter != null || getter != null) { - dict.__setitem__(npropname, new PyBeanProperty(npropname, - proptype, - getter, - setter)); - } else { - // xxx error - } - } - Constructor[] ctrs = c.getConstructors(); - if(ctrs.length != 0) { - final PyReflectedConstructor reflctr = new PyReflectedConstructor("_new_impl"); - for(int i = 0; i < ctrs.length; i++) { - reflctr.addConstructor(ctrs[i]); - } - PyObject new_ = new PyNewWrapper(c, "__new__", -1, -1) { - - public PyObject new_impl(boolean init, - PyType subtype, - PyObject[] args, - String[] keywords) { - return reflctr.make(args, keywords); - } - }; - dict.__setitem__("__new__", new_); - } - if(ClassDictInit.class.isAssignableFrom(c) && c != ClassDictInit.class) { - try { - @SuppressWarnings("unchecked") - Method m = c.getMethod("classDictInit", PyObject.class); - m.invoke(null, new Object[] {dict}); - } catch(Exception exc) { - throw error(exc); - } - } - } - - private static void fillInMRO(PyType type, Class base) { - PyType[] mro; - if (base == Object.class) { - mro = new PyType[] {type}; - } else { - PyType baseType = fromClass(base); - mro = new PyType[baseType.mro.length + 1]; - System.arraycopy(baseType.mro, 0, mro, 1, baseType.mro.length); - mro[0] = type; - type.base = baseType; - type.bases = new PyObject[] {baseType}; - } - type.mro = mro; - } - - private static HashMap<Class, PyType> class_to_type; - - private static HashMap<Class, TypeBuilder> classToBuilder; - - public static interface Newstyle { - } - public static void addBuilder(Class forClass, TypeBuilder builder) { - if(classToBuilder == null) { + if (classToBuilder == null) { classToBuilder = new HashMap<Class, TypeBuilder>(); } classToBuilder.put(forClass, builder); - + if (class_to_type.containsKey(forClass)) { if (!Py.BOOTSTRAP_TYPES.remove(forClass)) { Py.writeWarning("init", "Bootstrapping class not in Py.BOOTSTRAP_TYPES[class=" - + forClass + "]"); + + forClass + "]"); } // The types in Py.BOOTSTRAP_TYPES are initialized before their builders are assigned, // so do the work of addFromClass & fillFromClass after the fact @@ -1052,16 +1067,15 @@ return newtype; } - public static PyType TYPE = fromClass(PyType.class); - public static synchronized PyType fromClass(Class c) { if (class_to_type == null) { class_to_type = new HashMap<Class, PyType>(); addFromClass(PyType.class); } PyType type = class_to_type.get(c); - if (type != null) + if (type != null) { return type; + } return addFromClass(c); } @@ -1069,7 +1083,7 @@ final PyObject type___getattribute__(PyObject name){ return type___findattr__(asName(name)); } - + // name must be interned final PyObject type___findattr__(String name) { PyType metatype = getType(); @@ -1089,8 +1103,9 @@ if (attr != null) { res = attr.__get__(null, this); - if (res != null) + if (res != null) { return res; + } } if (metaattr != null) { @@ -1099,7 +1114,7 @@ return null; } - + @ExposedMethod final void type___setattr__(PyObject name, PyObject value){ type___setattr__(asName(name), value); @@ -1131,14 +1146,13 @@ }); } } - } @ExposedMethod final void type___delattr__(PyObject name) { type___delattr__(asName(name)); } - + final void type___delattr__(String name) { if (builtin) { throw Py.TypeError("can't delete attributes of built-in type '" + this.name + "'"); @@ -1148,8 +1162,7 @@ if (has_set && lookup("__set__") == null) { traverse_hierarchy(false, new OnType() { public boolean onType(PyType type) { - boolean absent = - type.getDict().__finditem__("__set__") == null; + boolean absent = type.getDict().__finditem__("__set__") == null; if (absent) { type.has_set = false; return false; @@ -1162,8 +1175,7 @@ if (has_set && lookup("__delete__") == null) { traverse_hierarchy(false, new OnType() { public boolean onType(PyType type) { - boolean absent = - type.getDict().__finditem__("__delete__") == null; + boolean absent = type.getDict().__finditem__("__delete__") == null; if (absent) { type.has_delete = false; return false; @@ -1189,12 +1201,11 @@ return dict; } - @ExposedGet(name = "__dict__") public PyObject getDict() { // xxx return dict-proxy return dict; } - + @ExposedSet(name = "__dict__") public void setDict(PyObject newDict) { throw Py.TypeError("can't set attribute '__dict__' of type '" + name + "'"); @@ -1224,7 +1235,7 @@ } return Py.newString("__builtin__"); } - + public int getNumSlots(){ return numSlots; } @@ -1264,31 +1275,11 @@ type___setattr__(name, value); } - private static PyObject invoke_new_(PyObject new_,PyType type,boolean init,PyObject[] args,String[] keywords) { - PyObject newobj; - if (new_ instanceof PyNewWrapper) { - newobj = ((PyNewWrapper) new_).new_impl(init, type, args, keywords); - } else { - int n = args.length; - PyObject[] type_prepended = new PyObject[n + 1]; - System.arraycopy(args, 0, type_prepended, 1, n); - type_prepended[0] = type; - newobj = new_.__get__(null, type).__call__(type_prepended, keywords); - } - /* special case type(x) */ - if (type == TYPE && args.length==1 && keywords.length==0) { - return newobj; - } - newobj.dispatch__init__(type,args,keywords); - return newobj; - } - - /** * @see org.python.core.PyObject#__call__(org.python.core.PyObject[], java.lang.String[]) */ public PyObject __call__(PyObject[] args, String[] keywords) { - return type___call__(args,keywords); + return type___call__(args, keywords); } @ExposedMethod @@ -1301,6 +1292,7 @@ return invoke_new_(new_,this,true,args,keywords); } + //XXX: consider pulling this out into a generally accessible place // I bet this is duplicated more or less in other places. private static void confirmIdentifier(PyObject o) { @@ -1309,14 +1301,12 @@ throw Py.TypeError(msg); } String identifier = o.toString(); - if (identifier == null || - identifier.length() < 1 || - (!Character.isLetter(identifier.charAt(0)) && identifier.charAt(0) != '_') - ) { + if (identifier == null || identifier.length() < 1 + || (!Character.isLetter(identifier.charAt(0)) && identifier.charAt(0) != '_')) { throw Py.TypeError(msg); } char[] chars = identifier.toCharArray(); - for(int i = 0; i < chars.length; i++) { + for (int i = 0; i < chars.length; i++) { if (!Character.isLetterOrDigit(chars[i]) && chars[i] != '_') { throw Py.TypeError(msg); } @@ -1326,16 +1316,51 @@ //XXX: copied from CodeCompiler.java and changed variable names. // Maybe this should go someplace for all classes to use. private static String mangleName(String classname, String methodname) { - if (classname != null && methodname.startsWith("__") && - !methodname.endsWith("__")) - { + if (classname != null && methodname.startsWith("__") && !methodname.endsWith("__")) { //remove leading '_' from classname int i = 0; - while (classname.charAt(i) == '_') + while (classname.charAt(i) == '_') { i++; + } return ("_"+classname.substring(i)+methodname).intern(); } return methodname; } + private Object writeReplace() { + // XXX: needed? + return new TypeResolver(underlying_class, getModule().toString(), name); + } + + public static interface Newstyle { + } + + private interface OnType { + boolean onType(PyType type); + } + + static class TypeResolver implements Serializable { + private Class underlying_class; + private String module; + private String name; + + TypeResolver(Class underlying_class, String module, String name) { + this.underlying_class = underlying_class; + this.module = module; + this.name = name; + } + + private Object readResolve() { + //System.err.println("resolve: "+module+"."+name); + if (underlying_class!=null) { + return PyType.fromClass(underlying_class); + } + PyObject mod = imp.importName(module.intern(), false); + PyObject pytyp = mod.__getattr__(name.intern()); + if (!(pytyp instanceof PyType)) { + throw Py.TypeError(module+"."+name+" must be a type for deserialization"); + } + return pytyp; + } + } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pj...@us...> - 2008-04-02 06:02:14
|
Revision: 4271 http://jython.svn.sourceforge.net/jython/?rev=4271&view=rev Author: pjenvey Date: 2008-04-01 23:02:12 -0700 (Tue, 01 Apr 2008) Log Message: ----------- fix slotted class variables -- don't overwrite them with a descriptor Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-04-02 03:19:56 UTC (rev 4270) +++ trunk/jython/src/org/python/core/PyType.java 2008-04-02 06:02:12 UTC (rev 4271) @@ -874,7 +874,7 @@ String slotstring = mangleName(newtype.name, slotname.toString()); if (slotstring.equals("__dict__")) { newtype.needs_userdict = true; - } else { + } else if (newtype.dict.__finditem__(slotstring) == null) { newtype.dict.__setitem__(slotstring, new PySlot(newtype, slotstring, newtype.numSlots++)); } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pj...@us...> - 2008-04-03 21:25:25
|
Revision: 4280 http://jython.svn.sourceforge.net/jython/?rev=4280&view=rev Author: pjenvey Date: 2008-04-03 14:25:21 -0700 (Thu, 03 Apr 2008) Log Message: ----------- whitespace Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-04-03 19:41:56 UTC (rev 4279) +++ trunk/jython/src/org/python/core/PyType.java 2008-04-03 21:25:21 UTC (rev 4280) @@ -119,7 +119,7 @@ if (!(dict instanceof PyDictionary || dict instanceof PyStringMap)) { throw Py.TypeError("type(): dict must be dict"); } - return newType(new_, subtype, name, (PyTuple) bases, dict); + return newType(new_, subtype, name, (PyTuple)bases, dict); } public static PyObject newType(PyNewWrapper new_, PyType metatype, String name, PyTuple bases, @@ -237,7 +237,7 @@ String[] keywords) { PyObject newobj; if (new_ instanceof PyNewWrapper) { - newobj = ((PyNewWrapper) new_).new_impl(init, type, args, keywords); + newobj = ((PyNewWrapper)new_).new_impl(init, type, args, keywords); } else { int n = args.length; PyObject[] type_prepended = new PyObject[n + 1]; @@ -246,7 +246,7 @@ newobj = new_.__get__(null, type).__call__(type_prepended, keywords); } /* special case type(x) */ - if (type == TYPE && args.length==1 && keywords.length==0) { + if (type == TYPE && args.length == 1 && keywords.length == 0) { return newobj; } newobj.dispatch__init__(type, args, keywords); @@ -418,7 +418,7 @@ @SuppressWarnings("unchecked") Method m = c.getMethod("classDictInit", PyObject.class); m.invoke(null, new Object[] {dict}); - } catch(Exception exc) { + } catch (Exception exc) { throw error(exc); } } @@ -460,10 +460,10 @@ * Gets the most parent PyType that determines the layout of this type ie * has slots or an underlying_class. Can by this PyType. */ - private PyType getLayout(){ - if (underlying_class != null){ + private PyType getLayout() { + if (underlying_class != null) { return this; - } else if (numSlots != base.numSlots){ + } else if (numSlots != base.numSlots) { return this; } return base.getLayout(); @@ -488,7 +488,7 @@ @ExposedSet(name = "__bases__") public void setBases(PyObject newBasesTuple) { - if (!(newBasesTuple instanceof PyTuple)){ + if (!(newBasesTuple instanceof PyTuple)) { throw Py.TypeError("bases must be a tuple"); } PyObject[] newBases = ((PyTuple)newBasesTuple).getArray(); @@ -497,13 +497,13 @@ + newBasesTuple); } for (int i = 0; i < newBases.length; i++) { - if (!(newBases[i] instanceof PyType)){ - if (!(newBases[i] instanceof PyClass)){ + if (!(newBases[i] instanceof PyType)) { + if (!(newBases[i] instanceof PyClass)) { throw Py.TypeError(name + ".__bases__ must be a tuple of old- or new-style " + "classes, not " + newBases[i]); } } else { - if (((PyType)newBases[i]).isSubType(this)){ + if (((PyType)newBases[i]).isSubType(this)) { throw Py.TypeError("a __bases__ item causes an inheritance cycle"); } } @@ -531,8 +531,8 @@ ((PyType)newBases[i]).attachSubclass(this); } } - } catch(PyException t) { - for (Iterator it = savedSubMros.iterator(); it.hasNext(); ){ + } catch (PyException t) { + for (Iterator it = savedSubMros.iterator(); it.hasNext();) { PyType subtype = (PyType)it.next(); PyObject[] subtypeSavedMro = (PyObject[])it.next(); subtype.mro = subtypeSavedMro; @@ -559,7 +559,7 @@ * mroCollector will equal [C, C.__mro__, D, D.__mro__, E, E.__mro__] after * this call. */ - private void mro_subclasses(List<Object> mroCollector){ + private void mro_subclasses(List<Object> mroCollector) { for (WeakReference<PyType> ref : subclasses) { PyType subtype = ref.get(); if (subtype == null) { @@ -617,7 +617,7 @@ private synchronized void detachSubclass(PyType subtype) { cleanup_subclasses(); for (WeakReference<PyType> ref : subclasses) { - if (ref.get() == subtype){ + if (ref.get() == subtype) { subclasses.remove(ref); break; } @@ -671,7 +671,7 @@ StringBuffer msg = new StringBuffer("Cannot create a consistent method resolution\n" + "order (MRO) for bases "); PyDictionary set = new PyDictionary(); - for (int i=0; i < to_merge.length; i++) { + for (int i = 0; i < to_merge.length; i++) { PyObject[] lst = to_merge[i]; if (remain[i] < lst.length) { set.__setitem__(lst[remain[i]], Py.None); @@ -751,7 +751,7 @@ } acc.add(candidate); for (int j = 0; j < nmerge; j++) { - if (remain[j]<to_merge[j].length && to_merge[j][remain[j]]==candidate) { + if (remain[j] < to_merge[j].length && to_merge[j][remain[j]] == candidate) { remain[j]++; } } @@ -775,7 +775,7 @@ for (int i = 0; i < mro.length; i++) { PyObject parent = mro[i]; if (parent instanceof PyType) { - PyType parent_type =(PyType)parent; + PyType parent_type = (PyType)parent; if (isSolidBase(parent_type)) { return parent_type; } @@ -1051,7 +1051,7 @@ } @ExposedMethod - final PyObject type___getattribute__(PyObject name){ + final PyObject type___getattribute__(PyObject name) { return type___findattr__(asName(name)); } @@ -1091,7 +1091,7 @@ } @ExposedMethod - final void type___setattr__(PyObject name, PyObject value){ + final void type___setattr__(PyObject name, PyObject value) { type___setattr__(asName(name), value); } @@ -1257,8 +1257,8 @@ } public Object __tojava__(Class c) { - if (underlying_class!= null &&( - c == Object.class || c == Class.class || c == Serializable.class)) { + if (underlying_class != null && (c == Object.class || c == Class.class || + c == Serializable.class)) { return underlying_class; } return super.__tojava__(c); @@ -1281,7 +1281,7 @@ throw Py.TypeError(String.format("can't delete %s.__module__", name)); } - public int getNumSlots(){ + public int getNumSlots() { return numSlots; } @@ -1357,7 +1357,7 @@ } private Object readResolve() { - if (underlying_class!=null) { + if (underlying_class != null) { return PyType.fromClass(underlying_class); } PyObject mod = imp.importName(module.intern(), false); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pj...@us...> - 2008-05-29 22:39:03
|
Revision: 4476 http://jython.svn.sourceforge.net/jython/?rev=4476&view=rev Author: pjenvey Date: 2008-05-29 15:39:00 -0700 (Thu, 29 May 2008) Log Message: ----------- revert part of r4409: Java 6 disallows the exposed method access to the private base Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-05-29 21:37:07 UTC (rev 4475) +++ trunk/jython/src/org/python/core/PyType.java 2008-05-29 22:39:00 UTC (rev 4476) @@ -38,7 +38,6 @@ private String name; /** __base__, the direct base type or null. */ - @ExposedGet(name = "__base__") private PyType base; /** __bases__, the base classes. */ @@ -478,6 +477,13 @@ return base.getLayout(); } + @ExposedGet(name = "__base__") + public PyObject getBase() { + if (base == null) + return Py.None; + return base; + } + @ExposedGet(name = "__bases__") public PyObject getBases() { return new PyTuple(bases); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <pj...@us...> - 2008-06-08 22:55:29
|
Revision: 4572 http://jython.svn.sourceforge.net/jython/?rev=4572&view=rev Author: pjenvey Date: 2008-06-08 15:55:28 -0700 (Sun, 08 Jun 2008) Log Message: ----------- fix types to handle __doc__ descriptors fixes test_descr.docdescriptor, #1605006 and #1639663 thanks leouserz Modified Paths: -------------- trunk/jython/src/org/python/core/PyType.java Modified: trunk/jython/src/org/python/core/PyType.java =================================================================== --- trunk/jython/src/org/python/core/PyType.java 2008-06-08 21:44:41 UTC (rev 4571) +++ trunk/jython/src/org/python/core/PyType.java 2008-06-08 22:55:28 UTC (rev 4572) @@ -1262,6 +1262,17 @@ setDict(null); } + /** + * Equivalent of CPython's typeobject type_get_doc; handles __doc__ descriptors. + */ + public PyObject getDoc() { + PyObject doc = super.getDoc(); + if (!builtin && doc != null && doc.getType().lookup("__get__") != null) { + return doc.__get__(null, this); + } + return doc; + } + public Object __tojava__(Class c) { if (underlying_class != null && (c == Object.class || c == Class.class || c == Serializable.class)) { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |