{
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)
{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)
{
/* 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)
/* 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 -------------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 ------------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 ---------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 ----------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 ------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 -------------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 ---------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 ------------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 --------------- */
}
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;
{
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)
{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)
{
/* 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)
/* 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 -------------------- */
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);
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);
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);
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);
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);
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);
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);
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);
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);
projects / python / commitdiff