diff options
Diffstat (limited to 'Mac/Modules/cf/_CFmodule.c')
| -rw-r--r-- | Mac/Modules/cf/_CFmodule.c | 731 |
1 files changed, 631 insertions, 100 deletions
diff --git a/Mac/Modules/cf/_CFmodule.c b/Mac/Modules/cf/_CFmodule.c index 250e7ac..1f44a8e 100644 --- a/Mac/Modules/cf/_CFmodule.c +++ b/Mac/Modules/cf/_CFmodule.c @@ -159,7 +159,7 @@ static void CFTypeRefObj_dealloc(CFTypeRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_free((PyObject *)self); } static PyObject *CFTypeRefObj_CFGetTypeID(CFTypeRefObject *_self, PyObject *_args) @@ -375,14 +375,8 @@ static PyMethodDef CFTypeRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFTypeRefObj_chain = { CFTypeRefObj_methods, NULL }; +#define CFTypeRefObj_getsetlist NULL -static PyObject *CFTypeRefObj_getattr(CFTypeRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFTypeRefObj_chain, (PyObject *)self, name); -} - -#define CFTypeRefObj_setattr NULL static int CFTypeRefObj_compare(CFTypeRefObject *self, CFTypeRefObject *other) { @@ -404,6 +398,32 @@ static int CFTypeRefObj_hash(CFTypeRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFTypeRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFTypeRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFTypeRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFTypeRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFTypeRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFTypeRefObject *)self)->ob_itself = NULL; + ((CFTypeRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFTypeRefObj_tp_free PyObject_Del + PyTypeObject CFTypeRef_Type = { PyObject_HEAD_INIT(NULL) @@ -414,14 +434,39 @@ PyTypeObject CFTypeRef_Type = { /* methods */ (destructor) CFTypeRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFTypeRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFTypeRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFTypeRefObj_compare, /*tp_compare*/ (reprfunc) CFTypeRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFTypeRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFTypeRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFTypeRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFTypeRefObj_tp_init, /* tp_init */ + CFTypeRefObj_tp_alloc, /* tp_alloc */ + CFTypeRefObj_tp_new, /* tp_new */ + CFTypeRefObj_tp_free, /* tp_free */ }; /* ------------------- End object type CFTypeRef -------------------- */ @@ -449,6 +494,7 @@ PyObject *CFArrayRefObj_New(CFArrayRef itself) } it = PyObject_NEW(CFArrayRefObject, &CFArrayRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -474,7 +520,7 @@ static void CFArrayRefObj_dealloc(CFArrayRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFArrayRefObj_CFArrayCreateCopy(CFArrayRefObject *_self, PyObject *_args) @@ -531,14 +577,8 @@ static PyMethodDef CFArrayRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFArrayRefObj_chain = { CFArrayRefObj_methods, &CFTypeRefObj_chain }; - -static PyObject *CFArrayRefObj_getattr(CFArrayRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFArrayRefObj_chain, (PyObject *)self, name); -} +#define CFArrayRefObj_getsetlist NULL -#define CFArrayRefObj_setattr NULL static int CFArrayRefObj_compare(CFArrayRefObject *self, CFArrayRefObject *other) { @@ -560,6 +600,39 @@ static int CFArrayRefObj_hash(CFArrayRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFArrayRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFArrayRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFArrayRefObj_Convert, &itself)) + { + ((CFArrayRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFArrayRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFArrayRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFArrayRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFArrayRefObject *)self)->ob_itself = NULL; + ((CFArrayRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFArrayRefObj_tp_free PyObject_Del + PyTypeObject CFArrayRef_Type = { PyObject_HEAD_INIT(NULL) @@ -570,14 +643,39 @@ PyTypeObject CFArrayRef_Type = { /* methods */ (destructor) CFArrayRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFArrayRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFArrayRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFArrayRefObj_compare, /*tp_compare*/ (reprfunc) CFArrayRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFArrayRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFArrayRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFArrayRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFArrayRefObj_tp_init, /* tp_init */ + CFArrayRefObj_tp_alloc, /* tp_alloc */ + CFArrayRefObj_tp_new, /* tp_new */ + CFArrayRefObj_tp_free, /* tp_free */ }; /* ------------------- End object type CFArrayRef ------------------- */ @@ -605,6 +703,7 @@ PyObject *CFMutableArrayRefObj_New(CFMutableArrayRef itself) } it = PyObject_NEW(CFMutableArrayRefObject, &CFMutableArrayRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -630,7 +729,7 @@ static void CFMutableArrayRefObj_dealloc(CFMutableArrayRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFMutableArrayRefObj_CFArrayRemoveValueAtIndex(CFMutableArrayRefObject *_self, PyObject *_args) @@ -716,14 +815,8 @@ static PyMethodDef CFMutableArrayRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFMutableArrayRefObj_chain = { CFMutableArrayRefObj_methods, &CFArrayRefObj_chain }; +#define CFMutableArrayRefObj_getsetlist NULL -static PyObject *CFMutableArrayRefObj_getattr(CFMutableArrayRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFMutableArrayRefObj_chain, (PyObject *)self, name); -} - -#define CFMutableArrayRefObj_setattr NULL static int CFMutableArrayRefObj_compare(CFMutableArrayRefObject *self, CFMutableArrayRefObject *other) { @@ -745,6 +838,39 @@ static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFMutableArrayRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFMutableArrayRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFMutableArrayRefObj_Convert, &itself)) + { + ((CFMutableArrayRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFMutableArrayRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFMutableArrayRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFMutableArrayRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFMutableArrayRefObject *)self)->ob_itself = NULL; + ((CFMutableArrayRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFMutableArrayRefObj_tp_free PyObject_Del + PyTypeObject CFMutableArrayRef_Type = { PyObject_HEAD_INIT(NULL) @@ -755,14 +881,39 @@ PyTypeObject CFMutableArrayRef_Type = { /* methods */ (destructor) CFMutableArrayRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFMutableArrayRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFMutableArrayRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFMutableArrayRefObj_compare, /*tp_compare*/ (reprfunc) CFMutableArrayRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFMutableArrayRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFMutableArrayRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFMutableArrayRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFMutableArrayRefObj_tp_init, /* tp_init */ + CFMutableArrayRefObj_tp_alloc, /* tp_alloc */ + CFMutableArrayRefObj_tp_new, /* tp_new */ + CFMutableArrayRefObj_tp_free, /* tp_free */ }; /* --------------- End object type CFMutableArrayRef ---------------- */ @@ -790,6 +941,7 @@ PyObject *CFDictionaryRefObj_New(CFDictionaryRef itself) } it = PyObject_NEW(CFDictionaryRefObject, &CFDictionaryRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -815,7 +967,7 @@ static void CFDictionaryRefObj_dealloc(CFDictionaryRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFDictionaryRefObj_CFDictionaryCreateCopy(CFDictionaryRefObject *_self, PyObject *_args) @@ -854,14 +1006,8 @@ static PyMethodDef CFDictionaryRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFDictionaryRefObj_chain = { CFDictionaryRefObj_methods, &CFTypeRefObj_chain }; +#define CFDictionaryRefObj_getsetlist NULL -static PyObject *CFDictionaryRefObj_getattr(CFDictionaryRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFDictionaryRefObj_chain, (PyObject *)self, name); -} - -#define CFDictionaryRefObj_setattr NULL static int CFDictionaryRefObj_compare(CFDictionaryRefObject *self, CFDictionaryRefObject *other) { @@ -883,6 +1029,39 @@ static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFDictionaryRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFDictionaryRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFDictionaryRefObj_Convert, &itself)) + { + ((CFDictionaryRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFDictionaryRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFDictionaryRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFDictionaryRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFDictionaryRefObject *)self)->ob_itself = NULL; + ((CFDictionaryRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFDictionaryRefObj_tp_free PyObject_Del + PyTypeObject CFDictionaryRef_Type = { PyObject_HEAD_INIT(NULL) @@ -893,14 +1072,39 @@ PyTypeObject CFDictionaryRef_Type = { /* methods */ (destructor) CFDictionaryRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFDictionaryRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFDictionaryRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFDictionaryRefObj_compare, /*tp_compare*/ (reprfunc) CFDictionaryRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFDictionaryRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFDictionaryRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFDictionaryRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFDictionaryRefObj_tp_init, /* tp_init */ + CFDictionaryRefObj_tp_alloc, /* tp_alloc */ + CFDictionaryRefObj_tp_new, /* tp_new */ + CFDictionaryRefObj_tp_free, /* tp_free */ }; /* ---------------- End object type CFDictionaryRef ----------------- */ @@ -928,6 +1132,7 @@ PyObject *CFMutableDictionaryRefObj_New(CFMutableDictionaryRef itself) } it = PyObject_NEW(CFMutableDictionaryRefObject, &CFMutableDictionaryRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -953,7 +1158,7 @@ static void CFMutableDictionaryRefObj_dealloc(CFMutableDictionaryRefObject *self { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutableDictionaryRefObject *_self, PyObject *_args) @@ -976,14 +1181,8 @@ static PyMethodDef CFMutableDictionaryRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFMutableDictionaryRefObj_chain = { CFMutableDictionaryRefObj_methods, &CFDictionaryRefObj_chain }; - -static PyObject *CFMutableDictionaryRefObj_getattr(CFMutableDictionaryRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFMutableDictionaryRefObj_chain, (PyObject *)self, name); -} +#define CFMutableDictionaryRefObj_getsetlist NULL -#define CFMutableDictionaryRefObj_setattr NULL static int CFMutableDictionaryRefObj_compare(CFMutableDictionaryRefObject *self, CFMutableDictionaryRefObject *other) { @@ -1005,6 +1204,39 @@ static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFMutableDictionaryRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFMutableDictionaryRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFMutableDictionaryRefObj_Convert, &itself)) + { + ((CFMutableDictionaryRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFMutableDictionaryRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFMutableDictionaryRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFMutableDictionaryRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFMutableDictionaryRefObject *)self)->ob_itself = NULL; + ((CFMutableDictionaryRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFMutableDictionaryRefObj_tp_free PyObject_Del + PyTypeObject CFMutableDictionaryRef_Type = { PyObject_HEAD_INIT(NULL) @@ -1015,14 +1247,39 @@ PyTypeObject CFMutableDictionaryRef_Type = { /* methods */ (destructor) CFMutableDictionaryRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFMutableDictionaryRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFMutableDictionaryRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFMutableDictionaryRefObj_compare, /*tp_compare*/ (reprfunc) CFMutableDictionaryRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFMutableDictionaryRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFMutableDictionaryRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFMutableDictionaryRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFMutableDictionaryRefObj_tp_init, /* tp_init */ + CFMutableDictionaryRefObj_tp_alloc, /* tp_alloc */ + CFMutableDictionaryRefObj_tp_new, /* tp_new */ + CFMutableDictionaryRefObj_tp_free, /* tp_free */ }; /* ------------- End object type CFMutableDictionaryRef ------------- */ @@ -1050,6 +1307,7 @@ PyObject *CFDataRefObj_New(CFDataRef itself) } it = PyObject_NEW(CFDataRefObject, &CFDataRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -1081,7 +1339,7 @@ static void CFDataRefObj_dealloc(CFDataRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFDataRefObj_CFDataCreateCopy(CFDataRefObject *_self, PyObject *_args) @@ -1152,14 +1410,8 @@ static PyMethodDef CFDataRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFDataRefObj_chain = { CFDataRefObj_methods, &CFTypeRefObj_chain }; - -static PyObject *CFDataRefObj_getattr(CFDataRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFDataRefObj_chain, (PyObject *)self, name); -} +#define CFDataRefObj_getsetlist NULL -#define CFDataRefObj_setattr NULL static int CFDataRefObj_compare(CFDataRefObject *self, CFDataRefObject *other) { @@ -1181,6 +1433,39 @@ static int CFDataRefObj_hash(CFDataRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFDataRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFDataRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFDataRefObj_Convert, &itself)) + { + ((CFDataRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFDataRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFDataRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFDataRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFDataRefObject *)self)->ob_itself = NULL; + ((CFDataRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFDataRefObj_tp_free PyObject_Del + PyTypeObject CFDataRef_Type = { PyObject_HEAD_INIT(NULL) @@ -1191,14 +1476,39 @@ PyTypeObject CFDataRef_Type = { /* methods */ (destructor) CFDataRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFDataRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFDataRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFDataRefObj_compare, /*tp_compare*/ (reprfunc) CFDataRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFDataRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFDataRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFDataRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFDataRefObj_tp_init, /* tp_init */ + CFDataRefObj_tp_alloc, /* tp_alloc */ + CFDataRefObj_tp_new, /* tp_new */ + CFDataRefObj_tp_free, /* tp_free */ }; /* ------------------- End object type CFDataRef -------------------- */ @@ -1226,6 +1536,7 @@ PyObject *CFMutableDataRefObj_New(CFMutableDataRef itself) } it = PyObject_NEW(CFMutableDataRefObject, &CFMutableDataRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -1251,7 +1562,7 @@ static void CFMutableDataRefObj_dealloc(CFMutableDataRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFMutableDataRefObj_CFDataSetLength(CFMutableDataRefObject *_self, PyObject *_args) @@ -1362,14 +1673,8 @@ static PyMethodDef CFMutableDataRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFMutableDataRefObj_chain = { CFMutableDataRefObj_methods, &CFDataRefObj_chain }; - -static PyObject *CFMutableDataRefObj_getattr(CFMutableDataRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFMutableDataRefObj_chain, (PyObject *)self, name); -} +#define CFMutableDataRefObj_getsetlist NULL -#define CFMutableDataRefObj_setattr NULL static int CFMutableDataRefObj_compare(CFMutableDataRefObject *self, CFMutableDataRefObject *other) { @@ -1391,6 +1696,39 @@ static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFMutableDataRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFMutableDataRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFMutableDataRefObj_Convert, &itself)) + { + ((CFMutableDataRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFMutableDataRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFMutableDataRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFMutableDataRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFMutableDataRefObject *)self)->ob_itself = NULL; + ((CFMutableDataRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFMutableDataRefObj_tp_free PyObject_Del + PyTypeObject CFMutableDataRef_Type = { PyObject_HEAD_INIT(NULL) @@ -1401,14 +1739,39 @@ PyTypeObject CFMutableDataRef_Type = { /* methods */ (destructor) CFMutableDataRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFMutableDataRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFMutableDataRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFMutableDataRefObj_compare, /*tp_compare*/ (reprfunc) CFMutableDataRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFMutableDataRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFMutableDataRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFMutableDataRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFMutableDataRefObj_tp_init, /* tp_init */ + CFMutableDataRefObj_tp_alloc, /* tp_alloc */ + CFMutableDataRefObj_tp_new, /* tp_new */ + CFMutableDataRefObj_tp_free, /* tp_free */ }; /* ---------------- End object type CFMutableDataRef ---------------- */ @@ -1436,6 +1799,7 @@ PyObject *CFStringRefObj_New(CFStringRef itself) } it = PyObject_NEW(CFStringRefObject, &CFStringRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -1476,7 +1840,7 @@ static void CFStringRefObj_dealloc(CFStringRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFStringRefObj_CFStringCreateWithSubstring(CFStringRefObject *_self, PyObject *_args) @@ -2049,14 +2413,8 @@ static PyMethodDef CFStringRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFStringRefObj_chain = { CFStringRefObj_methods, &CFTypeRefObj_chain }; +#define CFStringRefObj_getsetlist NULL -static PyObject *CFStringRefObj_getattr(CFStringRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFStringRefObj_chain, (PyObject *)self, name); -} - -#define CFStringRefObj_setattr NULL static int CFStringRefObj_compare(CFStringRefObject *self, CFStringRefObject *other) { @@ -2078,6 +2436,39 @@ static int CFStringRefObj_hash(CFStringRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFStringRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFStringRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFStringRefObj_Convert, &itself)) + { + ((CFStringRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFStringRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFStringRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFStringRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFStringRefObject *)self)->ob_itself = NULL; + ((CFStringRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFStringRefObj_tp_free PyObject_Del + PyTypeObject CFStringRef_Type = { PyObject_HEAD_INIT(NULL) @@ -2088,14 +2479,39 @@ PyTypeObject CFStringRef_Type = { /* methods */ (destructor) CFStringRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFStringRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFStringRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFStringRefObj_compare, /*tp_compare*/ (reprfunc) CFStringRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFStringRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFStringRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFStringRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFStringRefObj_tp_init, /* tp_init */ + CFStringRefObj_tp_alloc, /* tp_alloc */ + CFStringRefObj_tp_new, /* tp_new */ + CFStringRefObj_tp_free, /* tp_free */ }; /* ------------------ End object type CFStringRef ------------------- */ @@ -2123,6 +2539,7 @@ PyObject *CFMutableStringRefObj_New(CFMutableStringRef itself) } it = PyObject_NEW(CFMutableStringRefObject, &CFMutableStringRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -2148,7 +2565,7 @@ static void CFMutableStringRefObj_dealloc(CFMutableStringRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFMutableStringRefObj_CFStringAppend(CFMutableStringRefObject *_self, PyObject *_args) @@ -2382,14 +2799,8 @@ static PyMethodDef CFMutableStringRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFMutableStringRefObj_chain = { CFMutableStringRefObj_methods, &CFStringRefObj_chain }; - -static PyObject *CFMutableStringRefObj_getattr(CFMutableStringRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFMutableStringRefObj_chain, (PyObject *)self, name); -} +#define CFMutableStringRefObj_getsetlist NULL -#define CFMutableStringRefObj_setattr NULL static int CFMutableStringRefObj_compare(CFMutableStringRefObject *self, CFMutableStringRefObject *other) { @@ -2411,6 +2822,39 @@ static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFMutableStringRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFMutableStringRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFMutableStringRefObj_Convert, &itself)) + { + ((CFMutableStringRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFMutableStringRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFMutableStringRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFMutableStringRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFMutableStringRefObject *)self)->ob_itself = NULL; + ((CFMutableStringRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFMutableStringRefObj_tp_free PyObject_Del + PyTypeObject CFMutableStringRef_Type = { PyObject_HEAD_INIT(NULL) @@ -2421,14 +2865,39 @@ PyTypeObject CFMutableStringRef_Type = { /* methods */ (destructor) CFMutableStringRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFMutableStringRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFMutableStringRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFMutableStringRefObj_compare, /*tp_compare*/ (reprfunc) CFMutableStringRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFMutableStringRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFMutableStringRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFMutableStringRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFMutableStringRefObj_tp_init, /* tp_init */ + CFMutableStringRefObj_tp_alloc, /* tp_alloc */ + CFMutableStringRefObj_tp_new, /* tp_new */ + CFMutableStringRefObj_tp_free, /* tp_free */ }; /* --------------- End object type CFMutableStringRef --------------- */ @@ -2456,6 +2925,7 @@ PyObject *CFURLRefObj_New(CFURLRef itself) } it = PyObject_NEW(CFURLRefObject, &CFURLRef_Type); if (it == NULL) return NULL; + /* XXXX Should we tp_init or tp_new our basetype? */ it->ob_itself = itself; it->ob_freeit = CFRelease; return (PyObject *)it; @@ -2481,7 +2951,7 @@ static void CFURLRefObj_dealloc(CFURLRefObject *self) { self->ob_freeit((CFTypeRef)self->ob_itself); } - PyObject_Free((PyObject *)self); + self->ob_type->tp_base->tp_dealloc((PyObject *)self); } static PyObject *CFURLRefObj_CFURLCreateData(CFURLRefObject *_self, PyObject *_args) @@ -2979,14 +3449,8 @@ static PyMethodDef CFURLRefObj_methods[] = { {NULL, NULL, 0} }; -PyMethodChain CFURLRefObj_chain = { CFURLRefObj_methods, &CFTypeRefObj_chain }; - -static PyObject *CFURLRefObj_getattr(CFURLRefObject *self, char *name) -{ - return Py_FindMethodInChain(&CFURLRefObj_chain, (PyObject *)self, name); -} +#define CFURLRefObj_getsetlist NULL -#define CFURLRefObj_setattr NULL static int CFURLRefObj_compare(CFURLRefObject *self, CFURLRefObject *other) { @@ -3008,6 +3472,39 @@ static int CFURLRefObj_hash(CFURLRefObject *self) /* XXXX Or should we use CFHash?? */ return (int)self->ob_itself; } +static int CFURLRefObj_tp_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + CFURLRef itself; + char *kw[] = {"itself", 0}; + + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFURLRefObj_Convert, &itself)) + { + ((CFURLRefObject *)self)->ob_itself = itself; + return 0; + } + + /* Any CFTypeRef descendent is allowed as initializer too */ + if (PyArg_ParseTupleAndKeywords(args, kwds, "O&", kw, CFTypeRefObj_Convert, &itself)) + { + ((CFURLRefObject *)self)->ob_itself = itself; + return 0; + } + return -1; +} + +#define CFURLRefObj_tp_alloc PyType_GenericAlloc + +static PyObject *CFURLRefObj_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *self; + if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; + ((CFURLRefObject *)self)->ob_itself = NULL; + ((CFURLRefObject *)self)->ob_freeit = CFRelease; + return self; +} + +#define CFURLRefObj_tp_free PyObject_Del + PyTypeObject CFURLRef_Type = { PyObject_HEAD_INIT(NULL) @@ -3018,14 +3515,39 @@ PyTypeObject CFURLRef_Type = { /* methods */ (destructor) CFURLRefObj_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ - (getattrfunc) CFURLRefObj_getattr, /*tp_getattr*/ - (setattrfunc) CFURLRefObj_setattr, /*tp_setattr*/ + (getattrfunc)0, /*tp_getattr*/ + (setattrfunc)0, /*tp_setattr*/ (cmpfunc) CFURLRefObj_compare, /*tp_compare*/ (reprfunc) CFURLRefObj_repr, /*tp_repr*/ (PyNumberMethods *)0, /* tp_as_number */ (PySequenceMethods *)0, /* tp_as_sequence */ (PyMappingMethods *)0, /* tp_as_mapping */ (hashfunc) CFURLRefObj_hash, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + PyObject_GenericGetAttr, /*tp_getattro*/ + PyObject_GenericSetAttr, /*tp_setattro */ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + CFURLRefObj_methods, /* tp_methods */ + 0, /*tp_members*/ + CFURLRefObj_getsetlist, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + CFURLRefObj_tp_init, /* tp_init */ + CFURLRefObj_tp_alloc, /* tp_alloc */ + CFURLRefObj_tp_new, /* tp_new */ + CFURLRefObj_tp_free, /* tp_free */ }; /* -------------------- End object type CFURLRef -------------------- */ @@ -4365,6 +4887,7 @@ void init_CF(void) Py_INCREF(&CFTypeRef_Type); PyModule_AddObject(m, "CFTypeRefType", (PyObject *)&CFTypeRef_Type); CFArrayRef_Type.ob_type = &PyType_Type; + CFArrayRef_Type.tp_base = &CFTypeRef_Type; if (PyType_Ready(&CFArrayRef_Type) < 0) return; Py_INCREF(&CFArrayRef_Type); PyModule_AddObject(m, "CFArrayRef", (PyObject *)&CFArrayRef_Type); @@ -4372,6 +4895,7 @@ void init_CF(void) Py_INCREF(&CFArrayRef_Type); PyModule_AddObject(m, "CFArrayRefType", (PyObject *)&CFArrayRef_Type); CFMutableArrayRef_Type.ob_type = &PyType_Type; + CFMutableArrayRef_Type.tp_base = &CFArrayRef_Type; if (PyType_Ready(&CFMutableArrayRef_Type) < 0) return; Py_INCREF(&CFMutableArrayRef_Type); PyModule_AddObject(m, "CFMutableArrayRef", (PyObject *)&CFMutableArrayRef_Type); @@ -4379,6 +4903,7 @@ void init_CF(void) Py_INCREF(&CFMutableArrayRef_Type); PyModule_AddObject(m, "CFMutableArrayRefType", (PyObject *)&CFMutableArrayRef_Type); CFDictionaryRef_Type.ob_type = &PyType_Type; + CFDictionaryRef_Type.tp_base = &CFTypeRef_Type; if (PyType_Ready(&CFDictionaryRef_Type) < 0) return; Py_INCREF(&CFDictionaryRef_Type); PyModule_AddObject(m, "CFDictionaryRef", (PyObject *)&CFDictionaryRef_Type); @@ -4386,6 +4911,7 @@ void init_CF(void) Py_INCREF(&CFDictionaryRef_Type); PyModule_AddObject(m, "CFDictionaryRefType", (PyObject *)&CFDictionaryRef_Type); CFMutableDictionaryRef_Type.ob_type = &PyType_Type; + CFMutableDictionaryRef_Type.tp_base = &CFDictionaryRef_Type; if (PyType_Ready(&CFMutableDictionaryRef_Type) < 0) return; Py_INCREF(&CFMutableDictionaryRef_Type); PyModule_AddObject(m, "CFMutableDictionaryRef", (PyObject *)&CFMutableDictionaryRef_Type); @@ -4393,6 +4919,7 @@ void init_CF(void) Py_INCREF(&CFMutableDictionaryRef_Type); PyModule_AddObject(m, "CFMutableDictionaryRefType", (PyObject *)&CFMutableDictionaryRef_Type); CFDataRef_Type.ob_type = &PyType_Type; + CFDataRef_Type.tp_base = &CFTypeRef_Type; if (PyType_Ready(&CFDataRef_Type) < 0) return; Py_INCREF(&CFDataRef_Type); PyModule_AddObject(m, "CFDataRef", (PyObject *)&CFDataRef_Type); @@ -4400,6 +4927,7 @@ void init_CF(void) Py_INCREF(&CFDataRef_Type); PyModule_AddObject(m, "CFDataRefType", (PyObject *)&CFDataRef_Type); CFMutableDataRef_Type.ob_type = &PyType_Type; + CFMutableDataRef_Type.tp_base = &CFDataRef_Type; if (PyType_Ready(&CFMutableDataRef_Type) < 0) return; Py_INCREF(&CFMutableDataRef_Type); PyModule_AddObject(m, "CFMutableDataRef", (PyObject *)&CFMutableDataRef_Type); @@ -4407,6 +4935,7 @@ void init_CF(void) Py_INCREF(&CFMutableDataRef_Type); PyModule_AddObject(m, "CFMutableDataRefType", (PyObject *)&CFMutableDataRef_Type); CFStringRef_Type.ob_type = &PyType_Type; + CFStringRef_Type.tp_base = &CFTypeRef_Type; if (PyType_Ready(&CFStringRef_Type) < 0) return; Py_INCREF(&CFStringRef_Type); PyModule_AddObject(m, "CFStringRef", (PyObject *)&CFStringRef_Type); @@ -4414,6 +4943,7 @@ void init_CF(void) Py_INCREF(&CFStringRef_Type); PyModule_AddObject(m, "CFStringRefType", (PyObject *)&CFStringRef_Type); CFMutableStringRef_Type.ob_type = &PyType_Type; + CFMutableStringRef_Type.tp_base = &CFStringRef_Type; if (PyType_Ready(&CFMutableStringRef_Type) < 0) return; Py_INCREF(&CFMutableStringRef_Type); PyModule_AddObject(m, "CFMutableStringRef", (PyObject *)&CFMutableStringRef_Type); @@ -4421,6 +4951,7 @@ void init_CF(void) Py_INCREF(&CFMutableStringRef_Type); PyModule_AddObject(m, "CFMutableStringRefType", (PyObject *)&CFMutableStringRef_Type); CFURLRef_Type.ob_type = &PyType_Type; + CFURLRef_Type.tp_base = &CFTypeRef_Type; if (PyType_Ready(&CFURLRef_Type) < 0) return; Py_INCREF(&CFURLRef_Type); PyModule_AddObject(m, "CFURLRef", (PyObject *)&CFURLRef_Type); |