diff options
Diffstat (limited to 'Mac/Modules/cf/_CFmodule.c')
| -rw-r--r-- | Mac/Modules/cf/_CFmodule.c | 6772 |
1 files changed, 3386 insertions, 3386 deletions
diff --git a/Mac/Modules/cf/_CFmodule.c b/Mac/Modules/cf/_CFmodule.c index 0904ae1..ee67c70 100644 --- a/Mac/Modules/cf/_CFmodule.c +++ b/Mac/Modules/cf/_CFmodule.c @@ -9,9 +9,9 @@ /* Macro to test whether a weak-loaded CFM function exists */ #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ - PyErr_SetString(PyExc_NotImplementedError, \ - "Not available in this shared library/OS version"); \ - return NULL; \ + PyErr_SetString(PyExc_NotImplementedError, \ + "Not available in this shared library/OS version"); \ + return NULL; \ }} while(0) @@ -84,19 +84,19 @@ extern int _OptionalCFURLRefObj_Convert(PyObject *, CFURLRef *); PyObject *CFRange_New(CFRange *itself) { - return Py_BuildValue("ll", (long)itself->location, (long)itself->length); + return Py_BuildValue("ll", (long)itself->location, (long)itself->length); } int CFRange_Convert(PyObject *v, CFRange *p_itself) { - long location, length; + long location, length; - if( !PyArg_ParseTuple(v, "ll", &location, &length) ) - return 0; - p_itself->location = (CFIndex)location; - p_itself->length = (CFIndex)length; - return 1; + if( !PyArg_ParseTuple(v, "ll", &location, &length) ) + return 0; + p_itself->location = (CFIndex)location; + p_itself->length = (CFIndex)length; + return 1; } /* Optional CFURL argument or None (passed as NULL) */ @@ -104,8 +104,8 @@ int OptionalCFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself) { if ( v == Py_None ) { - p_itself = NULL; - return 1; + p_itself = NULL; + return 1; } return CFURLRefObj_Convert(v, p_itself); } @@ -119,262 +119,262 @@ PyTypeObject CFTypeRef_Type; #define CFTypeRefObj_Check(x) ((x)->ob_type == &CFTypeRef_Type || PyObject_TypeCheck((x), &CFTypeRef_Type)) typedef struct CFTypeRefObject { - PyObject_HEAD - CFTypeRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFTypeRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFTypeRefObject; PyObject *CFTypeRefObj_New(CFTypeRef itself) { - CFTypeRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - it = PyObject_NEW(CFTypeRefObject, &CFTypeRef_Type); - if (it == NULL) return NULL; - it->ob_itself = itself; - it->ob_freeit = CFRelease; - return (PyObject *)it; + CFTypeRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + it = PyObject_NEW(CFTypeRefObject, &CFTypeRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + it->ob_freeit = CFRelease; + return (PyObject *)it; } int CFTypeRefObj_Convert(PyObject *v, CFTypeRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ - if (!CFTypeRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFTypeRef required"); - return 0; - } - *p_itself = ((CFTypeRefObject *)v)->ob_itself; - return 1; + if (!CFTypeRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFTypeRef required"); + return 0; + } + *p_itself = ((CFTypeRefObject *)v)->ob_itself; + return 1; } static void CFTypeRefObj_dealloc(CFTypeRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - self->ob_type->tp_free((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + self->ob_type->tp_free((PyObject *)self); } static PyObject *CFTypeRefObj_CFGetTypeID(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeID _rv; + PyObject *_res = NULL; + CFTypeID _rv; #ifndef CFGetTypeID - PyMac_PRECHECK(CFGetTypeID); + PyMac_PRECHECK(CFGetTypeID); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFGetTypeID(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFGetTypeID(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFTypeRefObj_CFRetain(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeRef _rv; + PyObject *_res = NULL; + CFTypeRef _rv; #ifndef CFRetain - PyMac_PRECHECK(CFRetain); + PyMac_PRECHECK(CFRetain); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFRetain(_self->ob_itself); - _res = Py_BuildValue("O&", - CFTypeRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFRetain(_self->ob_itself); + _res = Py_BuildValue("O&", + CFTypeRefObj_New, _rv); + return _res; } static PyObject *CFTypeRefObj_CFRelease(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; #ifndef CFRelease - PyMac_PRECHECK(CFRelease); + PyMac_PRECHECK(CFRelease); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - CFRelease(_self->ob_itself); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFRelease(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFTypeRefObj_CFGetRetainCount(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; + PyObject *_res = NULL; + CFIndex _rv; #ifndef CFGetRetainCount - PyMac_PRECHECK(CFGetRetainCount); + PyMac_PRECHECK(CFGetRetainCount); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFGetRetainCount(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFGetRetainCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFTypeRefObj_CFEqual(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - CFTypeRef cf2; + PyObject *_res = NULL; + Boolean _rv; + CFTypeRef cf2; #ifndef CFEqual - PyMac_PRECHECK(CFEqual); + PyMac_PRECHECK(CFEqual); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFTypeRefObj_Convert, &cf2)) - return NULL; - _rv = CFEqual(_self->ob_itself, - cf2); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFTypeRefObj_Convert, &cf2)) + return NULL; + _rv = CFEqual(_self->ob_itself, + cf2); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFTypeRefObj_CFHash(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFHashCode _rv; + PyObject *_res = NULL; + CFHashCode _rv; #ifndef CFHash - PyMac_PRECHECK(CFHash); + PyMac_PRECHECK(CFHash); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFHash(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFHash(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFTypeRefObj_CFCopyDescription(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFCopyDescription - PyMac_PRECHECK(CFCopyDescription); + PyMac_PRECHECK(CFCopyDescription); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFCopyDescription(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFCopyDescription(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFTypeRefObj_CFPropertyListCreateXMLData(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDataRef _rv; - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFPropertyListCreateXMLData((CFAllocatorRef)NULL, - _self->ob_itself); - _res = Py_BuildValue("O&", - CFDataRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFDataRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFPropertyListCreateXMLData((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; } static PyObject *CFTypeRefObj_CFPropertyListCreateDeepCopy(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeRef _rv; - CFOptionFlags mutabilityOption; - if (!PyArg_ParseTuple(_args, "l", - &mutabilityOption)) - return NULL; - _rv = CFPropertyListCreateDeepCopy((CFAllocatorRef)NULL, - _self->ob_itself, - mutabilityOption); - _res = Py_BuildValue("O&", - CFTypeRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFTypeRef _rv; + CFOptionFlags mutabilityOption; + if (!PyArg_ParseTuple(_args, "l", + &mutabilityOption)) + return NULL; + _rv = CFPropertyListCreateDeepCopy((CFAllocatorRef)NULL, + _self->ob_itself, + mutabilityOption); + _res = Py_BuildValue("O&", + CFTypeRefObj_New, _rv); + return _res; } static PyObject *CFTypeRefObj_CFShow(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; #ifndef CFShow - PyMac_PRECHECK(CFShow); + PyMac_PRECHECK(CFShow); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - CFShow(_self->ob_itself); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFShow(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFTypeRefObj_CFPropertyListCreateFromXMLData(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - - CFTypeRef _rv; - CFOptionFlags mutabilityOption; - CFStringRef errorString; - if (!PyArg_ParseTuple(_args, "l", - &mutabilityOption)) - return NULL; - _rv = CFPropertyListCreateFromXMLData((CFAllocatorRef)NULL, - _self->ob_itself, - mutabilityOption, - &errorString); - if (errorString) - CFRelease(errorString); - if (_rv == NULL) { - PyErr_SetString(PyExc_RuntimeError, "Parse error in XML data"); - return NULL; - } - _res = Py_BuildValue("O&", - CFTypeRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + + CFTypeRef _rv; + CFOptionFlags mutabilityOption; + CFStringRef errorString; + if (!PyArg_ParseTuple(_args, "l", + &mutabilityOption)) + return NULL; + _rv = CFPropertyListCreateFromXMLData((CFAllocatorRef)NULL, + _self->ob_itself, + mutabilityOption, + &errorString); + if (errorString) + CFRelease(errorString); + if (_rv == NULL) { + PyErr_SetString(PyExc_RuntimeError, "Parse error in XML data"); + return NULL; + } + _res = Py_BuildValue("O&", + CFTypeRefObj_New, _rv); + return _res; } static PyObject *CFTypeRefObj_toPython(CFTypeRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; - _res = PyCF_CF2Python(_self->ob_itself); - return _res; + _res = PyCF_CF2Python(_self->ob_itself); + return _res; } static PyMethodDef CFTypeRefObj_methods[] = { - {"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1, - PyDoc_STR("() -> (CFTypeID _rv)")}, - {"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1, - PyDoc_STR("() -> (CFTypeRef _rv)")}, - {"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1, - PyDoc_STR("() -> None")}, - {"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1, - PyDoc_STR("() -> (CFIndex _rv)")}, - {"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1, - PyDoc_STR("(CFTypeRef cf2) -> (Boolean _rv)")}, - {"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1, - PyDoc_STR("() -> (CFHashCode _rv)")}, - {"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFPropertyListCreateXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateXMLData, 1, - PyDoc_STR("() -> (CFDataRef _rv)")}, - {"CFPropertyListCreateDeepCopy", (PyCFunction)CFTypeRefObj_CFPropertyListCreateDeepCopy, 1, - PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)")}, - {"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1, - PyDoc_STR("() -> None")}, - {"CFPropertyListCreateFromXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateFromXMLData, 1, - PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)")}, - {"toPython", (PyCFunction)CFTypeRefObj_toPython, 1, - PyDoc_STR("() -> (python_object)")}, - {NULL, NULL, 0} + {"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1, + PyDoc_STR("() -> (CFTypeRef _rv)")}, + {"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1, + PyDoc_STR("() -> None")}, + {"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1, + PyDoc_STR("(CFTypeRef cf2) -> (Boolean _rv)")}, + {"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1, + PyDoc_STR("() -> (CFHashCode _rv)")}, + {"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFPropertyListCreateXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateXMLData, 1, + PyDoc_STR("() -> (CFDataRef _rv)")}, + {"CFPropertyListCreateDeepCopy", (PyCFunction)CFTypeRefObj_CFPropertyListCreateDeepCopy, 1, + PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)")}, + {"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1, + PyDoc_STR("() -> None")}, + {"CFPropertyListCreateFromXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateFromXMLData, 1, + PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)")}, + {"toPython", (PyCFunction)CFTypeRefObj_toPython, 1, + PyDoc_STR("() -> (python_object)")}, + {NULL, NULL, 0} }; #define CFTypeRefObj_getsetlist NULL @@ -382,93 +382,93 @@ static PyMethodDef CFTypeRefObj_methods[] = { static int CFTypeRefObj_compare(CFTypeRefObject *self, CFTypeRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFTypeRefObj_repr(CFTypeRefObject *self) { - char buf[100]; - sprintf(buf, "<CFTypeRef type-%d object at 0x%8.8x for 0x%8.8x>", (int)CFGetTypeID(self->ob_itself), (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFTypeRef type-%d object at 0x%8.8x for 0x%8.8x>", (int)CFGetTypeID(self->ob_itself), (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFTypeRefObj_hash(CFTypeRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + 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; + 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; + 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) - 0, /*ob_size*/ - "_CF.CFTypeRef", /*tp_name*/ - sizeof(CFTypeRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFTypeRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFTypeRef", /*tp_name*/ + sizeof(CFTypeRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFTypeRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 -------------------- */ @@ -481,104 +481,104 @@ PyTypeObject CFArrayRef_Type; #define CFArrayRefObj_Check(x) ((x)->ob_type == &CFArrayRef_Type || PyObject_TypeCheck((x), &CFArrayRef_Type)) typedef struct CFArrayRefObject { - PyObject_HEAD - CFArrayRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFArrayRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFArrayRefObject; PyObject *CFArrayRefObj_New(CFArrayRef itself) { - CFArrayRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFArrayRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFArrayRefObj_Convert(PyObject *v, CFArrayRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ - if (!CFArrayRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFArrayRef required"); - return 0; - } - *p_itself = ((CFArrayRefObject *)v)->ob_itself; - return 1; + if (!CFArrayRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFArrayRef required"); + return 0; + } + *p_itself = ((CFArrayRefObject *)v)->ob_itself; + return 1; } static void CFArrayRefObj_dealloc(CFArrayRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFTypeRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFTypeRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFArrayRefObj_CFArrayCreateCopy(CFArrayRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFArrayRef _rv; - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFArrayCreateCopy((CFAllocatorRef)NULL, - _self->ob_itself); - _res = Py_BuildValue("O&", - CFArrayRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFArrayRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFArrayCreateCopy((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; } static PyObject *CFArrayRefObj_CFArrayGetCount(CFArrayRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; + PyObject *_res = NULL; + CFIndex _rv; #ifndef CFArrayGetCount - PyMac_PRECHECK(CFArrayGetCount); + PyMac_PRECHECK(CFArrayGetCount); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFArrayGetCount(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFArrayGetCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFArrayRefObj_CFStringCreateByCombiningStrings(CFArrayRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringRef separatorString; - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &separatorString)) - return NULL; - _rv = CFStringCreateByCombiningStrings((CFAllocatorRef)NULL, - _self->ob_itself, - separatorString); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef separatorString; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &separatorString)) + return NULL; + _rv = CFStringCreateByCombiningStrings((CFAllocatorRef)NULL, + _self->ob_itself, + separatorString); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyMethodDef CFArrayRefObj_methods[] = { - {"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1, - PyDoc_STR("() -> (CFArrayRef _rv)")}, - {"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1, - PyDoc_STR("() -> (CFIndex _rv)")}, - {"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1, - PyDoc_STR("(CFStringRef separatorString) -> (CFStringRef _rv)")}, - {NULL, NULL, 0} + {"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1, + PyDoc_STR("() -> (CFArrayRef _rv)")}, + {"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1, + PyDoc_STR("(CFStringRef separatorString) -> (CFStringRef _rv)")}, + {NULL, NULL, 0} }; #define CFArrayRefObj_getsetlist NULL @@ -586,100 +586,100 @@ static PyMethodDef CFArrayRefObj_methods[] = { static int CFArrayRefObj_compare(CFArrayRefObject *self, CFArrayRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFArrayRefObj_repr(CFArrayRefObject *self) { - char buf[100]; - sprintf(buf, "<CFArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFArrayRefObj_hash(CFArrayRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFArrayRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFArrayRefObj_Convert, &itself)) - { - ((CFArrayRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFArrayRef", /*tp_name*/ - sizeof(CFArrayRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFArrayRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFArrayRef", /*tp_name*/ + sizeof(CFArrayRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFArrayRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 ------------------- */ @@ -692,133 +692,133 @@ PyTypeObject CFMutableArrayRef_Type; #define CFMutableArrayRefObj_Check(x) ((x)->ob_type == &CFMutableArrayRef_Type || PyObject_TypeCheck((x), &CFMutableArrayRef_Type)) typedef struct CFMutableArrayRefObject { - PyObject_HEAD - CFMutableArrayRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFMutableArrayRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFMutableArrayRefObject; PyObject *CFMutableArrayRefObj_New(CFMutableArrayRef itself) { - CFMutableArrayRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFMutableArrayRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFMutableArrayRefObj_Convert(PyObject *v, CFMutableArrayRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ - if (!CFMutableArrayRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFMutableArrayRef required"); - return 0; - } - *p_itself = ((CFMutableArrayRefObject *)v)->ob_itself; - return 1; + if (!CFMutableArrayRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFMutableArrayRef required"); + return 0; + } + *p_itself = ((CFMutableArrayRefObject *)v)->ob_itself; + return 1; } static void CFMutableArrayRefObj_dealloc(CFMutableArrayRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFArrayRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFArrayRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFMutableArrayRefObj_CFArrayRemoveValueAtIndex(CFMutableArrayRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex idx; + PyObject *_res = NULL; + CFIndex idx; #ifndef CFArrayRemoveValueAtIndex - PyMac_PRECHECK(CFArrayRemoveValueAtIndex); + PyMac_PRECHECK(CFArrayRemoveValueAtIndex); #endif - if (!PyArg_ParseTuple(_args, "l", - &idx)) - return NULL; - CFArrayRemoveValueAtIndex(_self->ob_itself, - idx); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "l", + &idx)) + return NULL; + CFArrayRemoveValueAtIndex(_self->ob_itself, + idx); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableArrayRefObj_CFArrayRemoveAllValues(CFMutableArrayRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; #ifndef CFArrayRemoveAllValues - PyMac_PRECHECK(CFArrayRemoveAllValues); + PyMac_PRECHECK(CFArrayRemoveAllValues); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - CFArrayRemoveAllValues(_self->ob_itself); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFArrayRemoveAllValues(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices(CFMutableArrayRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex idx1; - CFIndex idx2; + PyObject *_res = NULL; + CFIndex idx1; + CFIndex idx2; #ifndef CFArrayExchangeValuesAtIndices - PyMac_PRECHECK(CFArrayExchangeValuesAtIndices); + PyMac_PRECHECK(CFArrayExchangeValuesAtIndices); #endif - if (!PyArg_ParseTuple(_args, "ll", - &idx1, - &idx2)) - return NULL; - CFArrayExchangeValuesAtIndices(_self->ob_itself, - idx1, - idx2); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "ll", + &idx1, + &idx2)) + return NULL; + CFArrayExchangeValuesAtIndices(_self->ob_itself, + idx1, + idx2); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableArrayRefObj_CFArrayAppendArray(CFMutableArrayRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFArrayRef otherArray; - CFRange otherRange; + PyObject *_res = NULL; + CFArrayRef otherArray; + CFRange otherRange; #ifndef CFArrayAppendArray - PyMac_PRECHECK(CFArrayAppendArray); + PyMac_PRECHECK(CFArrayAppendArray); #endif - if (!PyArg_ParseTuple(_args, "O&O&", - CFArrayRefObj_Convert, &otherArray, - CFRange_Convert, &otherRange)) - return NULL; - CFArrayAppendArray(_self->ob_itself, - otherArray, - otherRange); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&O&", + CFArrayRefObj_Convert, &otherArray, + CFRange_Convert, &otherRange)) + return NULL; + CFArrayAppendArray(_self->ob_itself, + otherArray, + otherRange); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyMethodDef CFMutableArrayRefObj_methods[] = { - {"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1, - PyDoc_STR("(CFIndex idx) -> None")}, - {"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1, - PyDoc_STR("() -> None")}, - {"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1, - PyDoc_STR("(CFIndex idx1, CFIndex idx2) -> None")}, - {"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1, - PyDoc_STR("(CFArrayRef otherArray, CFRange otherRange) -> None")}, - {NULL, NULL, 0} + {"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1, + PyDoc_STR("(CFIndex idx) -> None")}, + {"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1, + PyDoc_STR("() -> None")}, + {"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1, + PyDoc_STR("(CFIndex idx1, CFIndex idx2) -> None")}, + {"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1, + PyDoc_STR("(CFArrayRef otherArray, CFRange otherRange) -> None")}, + {NULL, NULL, 0} }; #define CFMutableArrayRefObj_getsetlist NULL @@ -826,100 +826,100 @@ static PyMethodDef CFMutableArrayRefObj_methods[] = { static int CFMutableArrayRefObj_compare(CFMutableArrayRefObject *self, CFMutableArrayRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFMutableArrayRefObj_repr(CFMutableArrayRefObject *self) { - char buf[100]; - sprintf(buf, "<CFMutableArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFMutableArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFMutableArrayRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableArrayRefObj_Convert, &itself)) - { - ((CFMutableArrayRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFMutableArrayRef", /*tp_name*/ - sizeof(CFMutableArrayRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFMutableArrayRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFMutableArrayRef", /*tp_name*/ + sizeof(CFMutableArrayRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFMutableArrayRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 ---------------- */ @@ -932,86 +932,86 @@ PyTypeObject CFDictionaryRef_Type; #define CFDictionaryRefObj_Check(x) ((x)->ob_type == &CFDictionaryRef_Type || PyObject_TypeCheck((x), &CFDictionaryRef_Type)) typedef struct CFDictionaryRefObject { - PyObject_HEAD - CFDictionaryRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFDictionaryRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFDictionaryRefObject; PyObject *CFDictionaryRefObj_New(CFDictionaryRef itself) { - CFDictionaryRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFDictionaryRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFDictionaryRefObj_Convert(PyObject *v, CFDictionaryRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ - if (!CFDictionaryRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFDictionaryRef required"); - return 0; - } - *p_itself = ((CFDictionaryRefObject *)v)->ob_itself; - return 1; + if (!CFDictionaryRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFDictionaryRef required"); + return 0; + } + *p_itself = ((CFDictionaryRefObject *)v)->ob_itself; + return 1; } static void CFDictionaryRefObj_dealloc(CFDictionaryRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFTypeRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFTypeRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFDictionaryRefObj_CFDictionaryCreateCopy(CFDictionaryRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDictionaryRef _rv; - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFDictionaryCreateCopy((CFAllocatorRef)NULL, - _self->ob_itself); - _res = Py_BuildValue("O&", - CFDictionaryRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFDictionaryRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDictionaryCreateCopy((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFDictionaryRefObj_New, _rv); + return _res; } static PyObject *CFDictionaryRefObj_CFDictionaryGetCount(CFDictionaryRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; + PyObject *_res = NULL; + CFIndex _rv; #ifndef CFDictionaryGetCount - PyMac_PRECHECK(CFDictionaryGetCount); + PyMac_PRECHECK(CFDictionaryGetCount); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFDictionaryGetCount(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDictionaryGetCount(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyMethodDef CFDictionaryRefObj_methods[] = { - {"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1, - PyDoc_STR("() -> (CFDictionaryRef _rv)")}, - {"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1, - PyDoc_STR("() -> (CFIndex _rv)")}, - {NULL, NULL, 0} + {"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1, + PyDoc_STR("() -> (CFDictionaryRef _rv)")}, + {"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {NULL, NULL, 0} }; #define CFDictionaryRefObj_getsetlist NULL @@ -1019,100 +1019,100 @@ static PyMethodDef CFDictionaryRefObj_methods[] = { static int CFDictionaryRefObj_compare(CFDictionaryRefObject *self, CFDictionaryRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFDictionaryRefObj_repr(CFDictionaryRefObject *self) { - char buf[100]; - sprintf(buf, "<CFDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFDictionaryRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFDictionaryRefObj_Convert, &itself)) - { - ((CFDictionaryRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFDictionaryRef", /*tp_name*/ - sizeof(CFDictionaryRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFDictionaryRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFDictionaryRef", /*tp_name*/ + sizeof(CFDictionaryRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFDictionaryRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 ----------------- */ @@ -1125,70 +1125,70 @@ PyTypeObject CFMutableDictionaryRef_Type; #define CFMutableDictionaryRefObj_Check(x) ((x)->ob_type == &CFMutableDictionaryRef_Type || PyObject_TypeCheck((x), &CFMutableDictionaryRef_Type)) typedef struct CFMutableDictionaryRefObject { - PyObject_HEAD - CFMutableDictionaryRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFMutableDictionaryRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFMutableDictionaryRefObject; PyObject *CFMutableDictionaryRefObj_New(CFMutableDictionaryRef itself) { - CFMutableDictionaryRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFMutableDictionaryRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFMutableDictionaryRefObj_Convert(PyObject *v, CFMutableDictionaryRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ - if (!CFMutableDictionaryRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFMutableDictionaryRef required"); - return 0; - } - *p_itself = ((CFMutableDictionaryRefObject *)v)->ob_itself; - return 1; + if (!CFMutableDictionaryRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFMutableDictionaryRef required"); + return 0; + } + *p_itself = ((CFMutableDictionaryRefObject *)v)->ob_itself; + return 1; } static void CFMutableDictionaryRefObj_dealloc(CFMutableDictionaryRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFDictionaryRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFDictionaryRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues(CFMutableDictionaryRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; #ifndef CFDictionaryRemoveAllValues - PyMac_PRECHECK(CFDictionaryRemoveAllValues); + PyMac_PRECHECK(CFDictionaryRemoveAllValues); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - CFDictionaryRemoveAllValues(_self->ob_itself); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFDictionaryRemoveAllValues(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyMethodDef CFMutableDictionaryRefObj_methods[] = { - {"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1, - PyDoc_STR("() -> None")}, - {NULL, NULL, 0} + {"CFDictionaryRemoveAllValues", (PyCFunction)CFMutableDictionaryRefObj_CFDictionaryRemoveAllValues, 1, + PyDoc_STR("() -> None")}, + {NULL, NULL, 0} }; #define CFMutableDictionaryRefObj_getsetlist NULL @@ -1196,100 +1196,100 @@ static PyMethodDef CFMutableDictionaryRefObj_methods[] = { static int CFMutableDictionaryRefObj_compare(CFMutableDictionaryRefObject *self, CFMutableDictionaryRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFMutableDictionaryRefObj_repr(CFMutableDictionaryRefObject *self) { - char buf[100]; - sprintf(buf, "<CFMutableDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFMutableDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFMutableDictionaryRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableDictionaryRefObj_Convert, &itself)) - { - ((CFMutableDictionaryRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFMutableDictionaryRef", /*tp_name*/ - sizeof(CFMutableDictionaryRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFMutableDictionaryRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFMutableDictionaryRef", /*tp_name*/ + sizeof(CFMutableDictionaryRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFMutableDictionaryRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 ------------- */ @@ -1302,124 +1302,124 @@ PyTypeObject CFDataRef_Type; #define CFDataRefObj_Check(x) ((x)->ob_type == &CFDataRef_Type || PyObject_TypeCheck((x), &CFDataRef_Type)) typedef struct CFDataRefObject { - PyObject_HEAD - CFDataRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFDataRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFDataRefObject; PyObject *CFDataRefObj_New(CFDataRef itself) { - CFDataRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFDataRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFDataRefObj_Convert(PyObject *v, CFDataRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - if (PyString_Check(v)) { - char *cStr; - Py_ssize_t cLen; - if( PyString_AsStringAndSize(v, &cStr, &cLen) < 0 ) return 0; - *p_itself = CFDataCreate((CFAllocatorRef)NULL, (unsigned char *)cStr, cLen); - return 1; - } + if (v == Py_None) { *p_itself = NULL; return 1; } + if (PyString_Check(v)) { + char *cStr; + Py_ssize_t cLen; + if( PyString_AsStringAndSize(v, &cStr, &cLen) < 0 ) return 0; + *p_itself = CFDataCreate((CFAllocatorRef)NULL, (unsigned char *)cStr, cLen); + return 1; + } - if (!CFDataRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFDataRef required"); - return 0; - } - *p_itself = ((CFDataRefObject *)v)->ob_itself; - return 1; + if (!CFDataRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFDataRef required"); + return 0; + } + *p_itself = ((CFDataRefObject *)v)->ob_itself; + return 1; } static void CFDataRefObj_dealloc(CFDataRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFTypeRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFTypeRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFDataRefObj_CFDataCreateCopy(CFDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDataRef _rv; - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFDataCreateCopy((CFAllocatorRef)NULL, - _self->ob_itself); - _res = Py_BuildValue("O&", - CFDataRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFDataRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDataCreateCopy((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; } static PyObject *CFDataRefObj_CFDataGetLength(CFDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; + PyObject *_res = NULL; + CFIndex _rv; #ifndef CFDataGetLength - PyMac_PRECHECK(CFDataGetLength); + PyMac_PRECHECK(CFDataGetLength); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFDataGetLength(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDataGetLength(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFDataRefObj_CFStringCreateFromExternalRepresentation(CFDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringEncoding encoding; - if (!PyArg_ParseTuple(_args, "l", - &encoding)) - return NULL; - _rv = CFStringCreateFromExternalRepresentation((CFAllocatorRef)NULL, - _self->ob_itself, - encoding); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringEncoding encoding; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringCreateFromExternalRepresentation((CFAllocatorRef)NULL, + _self->ob_itself, + encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFDataRefObj_CFDataGetData(CFDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; - int size = CFDataGetLength(_self->ob_itself); - char *data = (char *)CFDataGetBytePtr(_self->ob_itself); + int size = CFDataGetLength(_self->ob_itself); + char *data = (char *)CFDataGetBytePtr(_self->ob_itself); - _res = (PyObject *)PyString_FromStringAndSize(data, size); - return _res; + _res = (PyObject *)PyString_FromStringAndSize(data, size); + return _res; } static PyMethodDef CFDataRefObj_methods[] = { - {"CFDataCreateCopy", (PyCFunction)CFDataRefObj_CFDataCreateCopy, 1, - PyDoc_STR("() -> (CFDataRef _rv)")}, - {"CFDataGetLength", (PyCFunction)CFDataRefObj_CFDataGetLength, 1, - PyDoc_STR("() -> (CFIndex _rv)")}, - {"CFStringCreateFromExternalRepresentation", (PyCFunction)CFDataRefObj_CFStringCreateFromExternalRepresentation, 1, - PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, - {"CFDataGetData", (PyCFunction)CFDataRefObj_CFDataGetData, 1, - PyDoc_STR("() -> (string _rv)")}, - {NULL, NULL, 0} + {"CFDataCreateCopy", (PyCFunction)CFDataRefObj_CFDataCreateCopy, 1, + PyDoc_STR("() -> (CFDataRef _rv)")}, + {"CFDataGetLength", (PyCFunction)CFDataRefObj_CFDataGetLength, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {"CFStringCreateFromExternalRepresentation", (PyCFunction)CFDataRefObj_CFStringCreateFromExternalRepresentation, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFDataGetData", (PyCFunction)CFDataRefObj_CFDataGetData, 1, + PyDoc_STR("() -> (string _rv)")}, + {NULL, NULL, 0} }; #define CFDataRefObj_getsetlist NULL @@ -1427,100 +1427,100 @@ static PyMethodDef CFDataRefObj_methods[] = { static int CFDataRefObj_compare(CFDataRefObject *self, CFDataRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFDataRefObj_repr(CFDataRefObject *self) { - char buf[100]; - sprintf(buf, "<CFDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFDataRefObj_hash(CFDataRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFDataRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFDataRefObj_Convert, &itself)) - { - ((CFDataRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFDataRef", /*tp_name*/ - sizeof(CFDataRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFDataRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFDataRef", /*tp_name*/ + sizeof(CFDataRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFDataRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 -------------------- */ @@ -1533,158 +1533,158 @@ PyTypeObject CFMutableDataRef_Type; #define CFMutableDataRefObj_Check(x) ((x)->ob_type == &CFMutableDataRef_Type || PyObject_TypeCheck((x), &CFMutableDataRef_Type)) typedef struct CFMutableDataRefObject { - PyObject_HEAD - CFMutableDataRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFMutableDataRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFMutableDataRefObject; PyObject *CFMutableDataRefObj_New(CFMutableDataRef itself) { - CFMutableDataRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFMutableDataRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFMutableDataRefObj_Convert(PyObject *v, CFMutableDataRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ - if (!CFMutableDataRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFMutableDataRef required"); - return 0; - } - *p_itself = ((CFMutableDataRefObject *)v)->ob_itself; - return 1; + if (!CFMutableDataRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFMutableDataRef required"); + return 0; + } + *p_itself = ((CFMutableDataRefObject *)v)->ob_itself; + return 1; } static void CFMutableDataRefObj_dealloc(CFMutableDataRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFDataRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFDataRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFMutableDataRefObj_CFDataSetLength(CFMutableDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex length; + PyObject *_res = NULL; + CFIndex length; #ifndef CFDataSetLength - PyMac_PRECHECK(CFDataSetLength); + PyMac_PRECHECK(CFDataSetLength); #endif - if (!PyArg_ParseTuple(_args, "l", - &length)) - return NULL; - CFDataSetLength(_self->ob_itself, - length); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "l", + &length)) + return NULL; + CFDataSetLength(_self->ob_itself, + length); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableDataRefObj_CFDataIncreaseLength(CFMutableDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex extraLength; + PyObject *_res = NULL; + CFIndex extraLength; #ifndef CFDataIncreaseLength - PyMac_PRECHECK(CFDataIncreaseLength); + PyMac_PRECHECK(CFDataIncreaseLength); #endif - if (!PyArg_ParseTuple(_args, "l", - &extraLength)) - return NULL; - CFDataIncreaseLength(_self->ob_itself, - extraLength); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "l", + &extraLength)) + return NULL; + CFDataIncreaseLength(_self->ob_itself, + extraLength); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableDataRefObj_CFDataAppendBytes(CFMutableDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - unsigned char *bytes__in__; - long bytes__len__; - int bytes__in_len__; + PyObject *_res = NULL; + unsigned char *bytes__in__; + long bytes__len__; + int bytes__in_len__; #ifndef CFDataAppendBytes - PyMac_PRECHECK(CFDataAppendBytes); + PyMac_PRECHECK(CFDataAppendBytes); #endif - if (!PyArg_ParseTuple(_args, "s#", - &bytes__in__, &bytes__in_len__)) - return NULL; - bytes__len__ = bytes__in_len__; - CFDataAppendBytes(_self->ob_itself, - bytes__in__, bytes__len__); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "s#", + &bytes__in__, &bytes__in_len__)) + return NULL; + bytes__len__ = bytes__in_len__; + CFDataAppendBytes(_self->ob_itself, + bytes__in__, bytes__len__); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableDataRefObj_CFDataReplaceBytes(CFMutableDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFRange range; - unsigned char *newBytes__in__; - long newBytes__len__; - int newBytes__in_len__; + PyObject *_res = NULL; + CFRange range; + unsigned char *newBytes__in__; + long newBytes__len__; + int newBytes__in_len__; #ifndef CFDataReplaceBytes - PyMac_PRECHECK(CFDataReplaceBytes); + PyMac_PRECHECK(CFDataReplaceBytes); #endif - if (!PyArg_ParseTuple(_args, "O&s#", - CFRange_Convert, &range, - &newBytes__in__, &newBytes__in_len__)) - return NULL; - newBytes__len__ = newBytes__in_len__; - CFDataReplaceBytes(_self->ob_itself, - range, - newBytes__in__, newBytes__len__); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&s#", + CFRange_Convert, &range, + &newBytes__in__, &newBytes__in_len__)) + return NULL; + newBytes__len__ = newBytes__in_len__; + CFDataReplaceBytes(_self->ob_itself, + range, + newBytes__in__, newBytes__len__); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableDataRefObj_CFDataDeleteBytes(CFMutableDataRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFRange range; + PyObject *_res = NULL; + CFRange range; #ifndef CFDataDeleteBytes - PyMac_PRECHECK(CFDataDeleteBytes); + PyMac_PRECHECK(CFDataDeleteBytes); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFRange_Convert, &range)) - return NULL; - CFDataDeleteBytes(_self->ob_itself, - range); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFRange_Convert, &range)) + return NULL; + CFDataDeleteBytes(_self->ob_itself, + range); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyMethodDef CFMutableDataRefObj_methods[] = { - {"CFDataSetLength", (PyCFunction)CFMutableDataRefObj_CFDataSetLength, 1, - PyDoc_STR("(CFIndex length) -> None")}, - {"CFDataIncreaseLength", (PyCFunction)CFMutableDataRefObj_CFDataIncreaseLength, 1, - PyDoc_STR("(CFIndex extraLength) -> None")}, - {"CFDataAppendBytes", (PyCFunction)CFMutableDataRefObj_CFDataAppendBytes, 1, - PyDoc_STR("(Buffer bytes) -> None")}, - {"CFDataReplaceBytes", (PyCFunction)CFMutableDataRefObj_CFDataReplaceBytes, 1, - PyDoc_STR("(CFRange range, Buffer newBytes) -> None")}, - {"CFDataDeleteBytes", (PyCFunction)CFMutableDataRefObj_CFDataDeleteBytes, 1, - PyDoc_STR("(CFRange range) -> None")}, - {NULL, NULL, 0} + {"CFDataSetLength", (PyCFunction)CFMutableDataRefObj_CFDataSetLength, 1, + PyDoc_STR("(CFIndex length) -> None")}, + {"CFDataIncreaseLength", (PyCFunction)CFMutableDataRefObj_CFDataIncreaseLength, 1, + PyDoc_STR("(CFIndex extraLength) -> None")}, + {"CFDataAppendBytes", (PyCFunction)CFMutableDataRefObj_CFDataAppendBytes, 1, + PyDoc_STR("(Buffer bytes) -> None")}, + {"CFDataReplaceBytes", (PyCFunction)CFMutableDataRefObj_CFDataReplaceBytes, 1, + PyDoc_STR("(CFRange range, Buffer newBytes) -> None")}, + {"CFDataDeleteBytes", (PyCFunction)CFMutableDataRefObj_CFDataDeleteBytes, 1, + PyDoc_STR("(CFRange range) -> None")}, + {NULL, NULL, 0} }; #define CFMutableDataRefObj_getsetlist NULL @@ -1692,100 +1692,100 @@ static PyMethodDef CFMutableDataRefObj_methods[] = { static int CFMutableDataRefObj_compare(CFMutableDataRefObject *self, CFMutableDataRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFMutableDataRefObj_repr(CFMutableDataRefObject *self) { - char buf[100]; - sprintf(buf, "<CFMutableDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFMutableDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFMutableDataRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableDataRefObj_Convert, &itself)) - { - ((CFMutableDataRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFMutableDataRef", /*tp_name*/ - sizeof(CFMutableDataRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFMutableDataRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFMutableDataRef", /*tp_name*/ + sizeof(CFMutableDataRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFMutableDataRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 ---------------- */ @@ -1798,636 +1798,636 @@ PyTypeObject CFStringRef_Type; #define CFStringRefObj_Check(x) ((x)->ob_type == &CFStringRef_Type || PyObject_TypeCheck((x), &CFStringRef_Type)) typedef struct CFStringRefObject { - PyObject_HEAD - CFStringRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFStringRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFStringRefObject; PyObject *CFStringRefObj_New(CFStringRef itself) { - CFStringRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFStringRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFStringRefObj_Convert(PyObject *v, CFStringRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - if (PyString_Check(v)) { - char *cStr; - if (!PyArg_Parse(v, "es", "ascii", &cStr)) - return 0; - *p_itself = CFStringCreateWithCString((CFAllocatorRef)NULL, cStr, kCFStringEncodingASCII); - PyMem_Free(cStr); - return 1; - } - if (PyUnicode_Check(v)) { - /* We use the CF types here, if Python was configured differently that will give an error */ - CFIndex size = PyUnicode_GetSize(v); - UniChar *unichars = PyUnicode_AsUnicode(v); - if (!unichars) return 0; - *p_itself = CFStringCreateWithCharacters((CFAllocatorRef)NULL, unichars, size); - return 1; - } - - - if (!CFStringRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFStringRef required"); - return 0; - } - *p_itself = ((CFStringRefObject *)v)->ob_itself; - return 1; + if (v == Py_None) { *p_itself = NULL; return 1; } + if (PyString_Check(v)) { + char *cStr; + if (!PyArg_Parse(v, "es", "ascii", &cStr)) + return 0; + *p_itself = CFStringCreateWithCString((CFAllocatorRef)NULL, cStr, kCFStringEncodingASCII); + PyMem_Free(cStr); + return 1; + } + if (PyUnicode_Check(v)) { + /* We use the CF types here, if Python was configured differently that will give an error */ + CFIndex size = PyUnicode_GetSize(v); + UniChar *unichars = PyUnicode_AsUnicode(v); + if (!unichars) return 0; + *p_itself = CFStringCreateWithCharacters((CFAllocatorRef)NULL, unichars, size); + return 1; + } + + + if (!CFStringRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFStringRef required"); + return 0; + } + *p_itself = ((CFStringRefObject *)v)->ob_itself; + return 1; } static void CFStringRefObj_dealloc(CFStringRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFTypeRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFTypeRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFStringRefObj_CFStringCreateWithSubstring(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFRange range; - if (!PyArg_ParseTuple(_args, "O&", - CFRange_Convert, &range)) - return NULL; - _rv = CFStringCreateWithSubstring((CFAllocatorRef)NULL, - _self->ob_itself, - range); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFStringRef _rv; + CFRange range; + if (!PyArg_ParseTuple(_args, "O&", + CFRange_Convert, &range)) + return NULL; + _rv = CFStringCreateWithSubstring((CFAllocatorRef)NULL, + _self->ob_itself, + range); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFStringCreateCopy(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringCreateCopy((CFAllocatorRef)NULL, - _self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFStringRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringCreateCopy((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFStringGetLength(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; + PyObject *_res = NULL; + CFIndex _rv; #ifndef CFStringGetLength - PyMac_PRECHECK(CFStringGetLength); + PyMac_PRECHECK(CFStringGetLength); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringGetLength(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetLength(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringGetBytes(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; - CFRange range; - CFStringEncoding encoding; - UInt8 lossByte; - Boolean isExternalRepresentation; - UInt8 buffer; - CFIndex maxBufLen; - CFIndex usedBufLen; + PyObject *_res = NULL; + CFIndex _rv; + CFRange range; + CFStringEncoding encoding; + UInt8 lossByte; + Boolean isExternalRepresentation; + UInt8 buffer; + CFIndex maxBufLen; + CFIndex usedBufLen; #ifndef CFStringGetBytes - PyMac_PRECHECK(CFStringGetBytes); + PyMac_PRECHECK(CFStringGetBytes); #endif - if (!PyArg_ParseTuple(_args, "O&lbll", - CFRange_Convert, &range, - &encoding, - &lossByte, - &isExternalRepresentation, - &maxBufLen)) - return NULL; - _rv = CFStringGetBytes(_self->ob_itself, - range, - encoding, - lossByte, - isExternalRepresentation, - &buffer, - maxBufLen, - &usedBufLen); - _res = Py_BuildValue("lbl", - _rv, - buffer, - usedBufLen); - return _res; + if (!PyArg_ParseTuple(_args, "O&lbll", + CFRange_Convert, &range, + &encoding, + &lossByte, + &isExternalRepresentation, + &maxBufLen)) + return NULL; + _rv = CFStringGetBytes(_self->ob_itself, + range, + encoding, + lossByte, + isExternalRepresentation, + &buffer, + maxBufLen, + &usedBufLen); + _res = Py_BuildValue("lbl", + _rv, + buffer, + usedBufLen); + return _res; } static PyObject *CFStringRefObj_CFStringCreateExternalRepresentation(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDataRef _rv; - CFStringEncoding encoding; - UInt8 lossByte; - if (!PyArg_ParseTuple(_args, "lb", - &encoding, - &lossByte)) - return NULL; - _rv = CFStringCreateExternalRepresentation((CFAllocatorRef)NULL, - _self->ob_itself, - encoding, - lossByte); - _res = Py_BuildValue("O&", - CFDataRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFDataRef _rv; + CFStringEncoding encoding; + UInt8 lossByte; + if (!PyArg_ParseTuple(_args, "lb", + &encoding, + &lossByte)) + return NULL; + _rv = CFStringCreateExternalRepresentation((CFAllocatorRef)NULL, + _self->ob_itself, + encoding, + lossByte); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFStringGetSmallestEncoding(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringEncoding _rv; + PyObject *_res = NULL; + CFStringEncoding _rv; #ifndef CFStringGetSmallestEncoding - PyMac_PRECHECK(CFStringGetSmallestEncoding); + PyMac_PRECHECK(CFStringGetSmallestEncoding); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringGetSmallestEncoding(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetSmallestEncoding(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringGetFastestEncoding(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringEncoding _rv; + PyObject *_res = NULL; + CFStringEncoding _rv; #ifndef CFStringGetFastestEncoding - PyMac_PRECHECK(CFStringGetFastestEncoding); + PyMac_PRECHECK(CFStringGetFastestEncoding); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringGetFastestEncoding(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetFastestEncoding(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringCompareWithOptions(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFComparisonResult _rv; - CFStringRef theString2; - CFRange rangeToCompare; - CFOptionFlags compareOptions; + PyObject *_res = NULL; + CFComparisonResult _rv; + CFStringRef theString2; + CFRange rangeToCompare; + CFOptionFlags compareOptions; #ifndef CFStringCompareWithOptions - PyMac_PRECHECK(CFStringCompareWithOptions); + PyMac_PRECHECK(CFStringCompareWithOptions); #endif - if (!PyArg_ParseTuple(_args, "O&O&l", - CFStringRefObj_Convert, &theString2, - CFRange_Convert, &rangeToCompare, - &compareOptions)) - return NULL; - _rv = CFStringCompareWithOptions(_self->ob_itself, - theString2, - rangeToCompare, - compareOptions); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&l", + CFStringRefObj_Convert, &theString2, + CFRange_Convert, &rangeToCompare, + &compareOptions)) + return NULL; + _rv = CFStringCompareWithOptions(_self->ob_itself, + theString2, + rangeToCompare, + compareOptions); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringCompare(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFComparisonResult _rv; - CFStringRef theString2; - CFOptionFlags compareOptions; + PyObject *_res = NULL; + CFComparisonResult _rv; + CFStringRef theString2; + CFOptionFlags compareOptions; #ifndef CFStringCompare - PyMac_PRECHECK(CFStringCompare); + PyMac_PRECHECK(CFStringCompare); #endif - if (!PyArg_ParseTuple(_args, "O&l", - CFStringRefObj_Convert, &theString2, - &compareOptions)) - return NULL; - _rv = CFStringCompare(_self->ob_itself, - theString2, - compareOptions); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&l", + CFStringRefObj_Convert, &theString2, + &compareOptions)) + return NULL; + _rv = CFStringCompare(_self->ob_itself, + theString2, + compareOptions); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringFindWithOptions(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - CFStringRef stringToFind; - CFRange rangeToSearch; - CFOptionFlags searchOptions; - CFRange result; + PyObject *_res = NULL; + Boolean _rv; + CFStringRef stringToFind; + CFRange rangeToSearch; + CFOptionFlags searchOptions; + CFRange result; #ifndef CFStringFindWithOptions - PyMac_PRECHECK(CFStringFindWithOptions); + PyMac_PRECHECK(CFStringFindWithOptions); #endif - if (!PyArg_ParseTuple(_args, "O&O&l", - CFStringRefObj_Convert, &stringToFind, - CFRange_Convert, &rangeToSearch, - &searchOptions)) - return NULL; - _rv = CFStringFindWithOptions(_self->ob_itself, - stringToFind, - rangeToSearch, - searchOptions, - &result); - _res = Py_BuildValue("lO&", - _rv, - CFRange_New, result); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&l", + CFStringRefObj_Convert, &stringToFind, + CFRange_Convert, &rangeToSearch, + &searchOptions)) + return NULL; + _rv = CFStringFindWithOptions(_self->ob_itself, + stringToFind, + rangeToSearch, + searchOptions, + &result); + _res = Py_BuildValue("lO&", + _rv, + CFRange_New, result); + return _res; } static PyObject *CFStringRefObj_CFStringCreateArrayWithFindResults(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFArrayRef _rv; - CFStringRef stringToFind; - CFRange rangeToSearch; - CFOptionFlags compareOptions; - if (!PyArg_ParseTuple(_args, "O&O&l", - CFStringRefObj_Convert, &stringToFind, - CFRange_Convert, &rangeToSearch, - &compareOptions)) - return NULL; - _rv = CFStringCreateArrayWithFindResults((CFAllocatorRef)NULL, - _self->ob_itself, - stringToFind, - rangeToSearch, - compareOptions); - _res = Py_BuildValue("O&", - CFArrayRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFArrayRef _rv; + CFStringRef stringToFind; + CFRange rangeToSearch; + CFOptionFlags compareOptions; + if (!PyArg_ParseTuple(_args, "O&O&l", + CFStringRefObj_Convert, &stringToFind, + CFRange_Convert, &rangeToSearch, + &compareOptions)) + return NULL; + _rv = CFStringCreateArrayWithFindResults((CFAllocatorRef)NULL, + _self->ob_itself, + stringToFind, + rangeToSearch, + compareOptions); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFStringFind(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFRange _rv; - CFStringRef stringToFind; - CFOptionFlags compareOptions; + PyObject *_res = NULL; + CFRange _rv; + CFStringRef stringToFind; + CFOptionFlags compareOptions; #ifndef CFStringFind - PyMac_PRECHECK(CFStringFind); + PyMac_PRECHECK(CFStringFind); #endif - if (!PyArg_ParseTuple(_args, "O&l", - CFStringRefObj_Convert, &stringToFind, - &compareOptions)) - return NULL; - _rv = CFStringFind(_self->ob_itself, - stringToFind, - compareOptions); - _res = Py_BuildValue("O&", - CFRange_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&l", + CFStringRefObj_Convert, &stringToFind, + &compareOptions)) + return NULL; + _rv = CFStringFind(_self->ob_itself, + stringToFind, + compareOptions); + _res = Py_BuildValue("O&", + CFRange_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFStringHasPrefix(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - CFStringRef prefix; + PyObject *_res = NULL; + Boolean _rv; + CFStringRef prefix; #ifndef CFStringHasPrefix - PyMac_PRECHECK(CFStringHasPrefix); + PyMac_PRECHECK(CFStringHasPrefix); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &prefix)) - return NULL; - _rv = CFStringHasPrefix(_self->ob_itself, - prefix); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &prefix)) + return NULL; + _rv = CFStringHasPrefix(_self->ob_itself, + prefix); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringHasSuffix(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - CFStringRef suffix; + PyObject *_res = NULL; + Boolean _rv; + CFStringRef suffix; #ifndef CFStringHasSuffix - PyMac_PRECHECK(CFStringHasSuffix); + PyMac_PRECHECK(CFStringHasSuffix); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &suffix)) - return NULL; - _rv = CFStringHasSuffix(_self->ob_itself, - suffix); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &suffix)) + return NULL; + _rv = CFStringHasSuffix(_self->ob_itself, + suffix); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringGetLineBounds(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFRange range; - CFIndex lineBeginIndex; - CFIndex lineEndIndex; - CFIndex contentsEndIndex; + PyObject *_res = NULL; + CFRange range; + CFIndex lineBeginIndex; + CFIndex lineEndIndex; + CFIndex contentsEndIndex; #ifndef CFStringGetLineBounds - PyMac_PRECHECK(CFStringGetLineBounds); + PyMac_PRECHECK(CFStringGetLineBounds); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFRange_Convert, &range)) - return NULL; - CFStringGetLineBounds(_self->ob_itself, - range, - &lineBeginIndex, - &lineEndIndex, - &contentsEndIndex); - _res = Py_BuildValue("lll", - lineBeginIndex, - lineEndIndex, - contentsEndIndex); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFRange_Convert, &range)) + return NULL; + CFStringGetLineBounds(_self->ob_itself, + range, + &lineBeginIndex, + &lineEndIndex, + &contentsEndIndex); + _res = Py_BuildValue("lll", + lineBeginIndex, + lineEndIndex, + contentsEndIndex); + return _res; } static PyObject *CFStringRefObj_CFStringCreateArrayBySeparatingStrings(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFArrayRef _rv; - CFStringRef separatorString; - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &separatorString)) - return NULL; - _rv = CFStringCreateArrayBySeparatingStrings((CFAllocatorRef)NULL, - _self->ob_itself, - separatorString); - _res = Py_BuildValue("O&", - CFArrayRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFArrayRef _rv; + CFStringRef separatorString; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &separatorString)) + return NULL; + _rv = CFStringCreateArrayBySeparatingStrings((CFAllocatorRef)NULL, + _self->ob_itself, + separatorString); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFStringGetIntValue(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - SInt32 _rv; + PyObject *_res = NULL; + SInt32 _rv; #ifndef CFStringGetIntValue - PyMac_PRECHECK(CFStringGetIntValue); + PyMac_PRECHECK(CFStringGetIntValue); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringGetIntValue(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetIntValue(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringGetDoubleValue(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - double _rv; + PyObject *_res = NULL; + double _rv; #ifndef CFStringGetDoubleValue - PyMac_PRECHECK(CFStringGetDoubleValue); + PyMac_PRECHECK(CFStringGetDoubleValue); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringGetDoubleValue(_self->ob_itself); - _res = Py_BuildValue("d", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetDoubleValue(_self->ob_itself); + _res = Py_BuildValue("d", + _rv); + return _res; } static PyObject *CFStringRefObj_CFStringConvertIANACharSetNameToEncoding(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringEncoding _rv; + PyObject *_res = NULL; + CFStringEncoding _rv; #ifndef CFStringConvertIANACharSetNameToEncoding - PyMac_PRECHECK(CFStringConvertIANACharSetNameToEncoding); + PyMac_PRECHECK(CFStringConvertIANACharSetNameToEncoding); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringConvertIANACharSetNameToEncoding(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringConvertIANACharSetNameToEncoding(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFStringRefObj_CFShowStr(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; #ifndef CFShowStr - PyMac_PRECHECK(CFShowStr); + PyMac_PRECHECK(CFShowStr); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - CFShowStr(_self->ob_itself); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFShowStr(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFStringRefObj_CFURLCreateWithString(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - CFURLRef baseURL; - if (!PyArg_ParseTuple(_args, "O&", - OptionalCFURLRefObj_Convert, &baseURL)) - return NULL; - _rv = CFURLCreateWithString((CFAllocatorRef)NULL, - _self->ob_itself, - baseURL); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFURLRef _rv; + CFURLRef baseURL; + if (!PyArg_ParseTuple(_args, "O&", + OptionalCFURLRefObj_Convert, &baseURL)) + return NULL; + _rv = CFURLCreateWithString((CFAllocatorRef)NULL, + _self->ob_itself, + baseURL); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFURLCreateWithFileSystemPath(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - CFURLPathStyle pathStyle; - Boolean isDirectory; - if (!PyArg_ParseTuple(_args, "ll", - &pathStyle, - &isDirectory)) - return NULL; - _rv = CFURLCreateWithFileSystemPath((CFAllocatorRef)NULL, - _self->ob_itself, - pathStyle, - isDirectory); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFURLRef _rv; + CFURLPathStyle pathStyle; + Boolean isDirectory; + if (!PyArg_ParseTuple(_args, "ll", + &pathStyle, + &isDirectory)) + return NULL; + _rv = CFURLCreateWithFileSystemPath((CFAllocatorRef)NULL, + _self->ob_itself, + pathStyle, + isDirectory); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - CFURLPathStyle pathStyle; - Boolean isDirectory; - CFURLRef baseURL; - if (!PyArg_ParseTuple(_args, "llO&", - &pathStyle, - &isDirectory, - OptionalCFURLRefObj_Convert, &baseURL)) - return NULL; - _rv = CFURLCreateWithFileSystemPathRelativeToBase((CFAllocatorRef)NULL, - _self->ob_itself, - pathStyle, - isDirectory, - baseURL); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFURLRef _rv; + CFURLPathStyle pathStyle; + Boolean isDirectory; + CFURLRef baseURL; + if (!PyArg_ParseTuple(_args, "llO&", + &pathStyle, + &isDirectory, + OptionalCFURLRefObj_Convert, &baseURL)) + return NULL; + _rv = CFURLCreateWithFileSystemPathRelativeToBase((CFAllocatorRef)NULL, + _self->ob_itself, + pathStyle, + isDirectory, + baseURL); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringRef charactersToLeaveEscaped; - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &charactersToLeaveEscaped)) - return NULL; - _rv = CFURLCreateStringByReplacingPercentEscapes((CFAllocatorRef)NULL, - _self->ob_itself, - charactersToLeaveEscaped); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveEscaped; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &charactersToLeaveEscaped)) + return NULL; + _rv = CFURLCreateStringByReplacingPercentEscapes((CFAllocatorRef)NULL, + _self->ob_itself, + charactersToLeaveEscaped); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFURLCreateStringByAddingPercentEscapes(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringRef charactersToLeaveUnescaped; - CFStringRef legalURLCharactersToBeEscaped; - CFStringEncoding encoding; - if (!PyArg_ParseTuple(_args, "O&O&l", - CFStringRefObj_Convert, &charactersToLeaveUnescaped, - CFStringRefObj_Convert, &legalURLCharactersToBeEscaped, - &encoding)) - return NULL; - _rv = CFURLCreateStringByAddingPercentEscapes((CFAllocatorRef)NULL, - _self->ob_itself, - charactersToLeaveUnescaped, - legalURLCharactersToBeEscaped, - encoding); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveUnescaped; + CFStringRef legalURLCharactersToBeEscaped; + CFStringEncoding encoding; + if (!PyArg_ParseTuple(_args, "O&O&l", + CFStringRefObj_Convert, &charactersToLeaveUnescaped, + CFStringRefObj_Convert, &legalURLCharactersToBeEscaped, + &encoding)) + return NULL; + _rv = CFURLCreateStringByAddingPercentEscapes((CFAllocatorRef)NULL, + _self->ob_itself, + charactersToLeaveUnescaped, + legalURLCharactersToBeEscaped, + encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFStringRefObj_CFStringGetString(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; - int size = CFStringGetLength(_self->ob_itself)+1; - char *data = malloc(size); + int size = CFStringGetLength(_self->ob_itself)+1; + char *data = malloc(size); - if( data == NULL ) return PyErr_NoMemory(); - if ( CFStringGetCString(_self->ob_itself, data, size, 0) ) { - _res = (PyObject *)PyString_FromString(data); - } else { - PyErr_SetString(PyExc_RuntimeError, "CFStringGetCString could not fit the string"); - _res = NULL; - } - free(data); - return _res; + if( data == NULL ) return PyErr_NoMemory(); + if ( CFStringGetCString(_self->ob_itself, data, size, 0) ) { + _res = (PyObject *)PyString_FromString(data); + } else { + PyErr_SetString(PyExc_RuntimeError, "CFStringGetCString could not fit the string"); + _res = NULL; + } + free(data); + return _res; } static PyObject *CFStringRefObj_CFStringGetUnicode(CFStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; - int size = CFStringGetLength(_self->ob_itself)+1; - Py_UNICODE *data = malloc(size*sizeof(Py_UNICODE)); - CFRange range; + int size = CFStringGetLength(_self->ob_itself)+1; + Py_UNICODE *data = malloc(size*sizeof(Py_UNICODE)); + CFRange range; - range.location = 0; - range.length = size; - if( data == NULL ) return PyErr_NoMemory(); - CFStringGetCharacters(_self->ob_itself, range, data); - _res = (PyObject *)PyUnicode_FromUnicode(data, size-1); - free(data); - return _res; + range.location = 0; + range.length = size; + if( data == NULL ) return PyErr_NoMemory(); + CFStringGetCharacters(_self->ob_itself, range, data); + _res = (PyObject *)PyUnicode_FromUnicode(data, size-1); + free(data); + return _res; } static PyMethodDef CFStringRefObj_methods[] = { - {"CFStringCreateWithSubstring", (PyCFunction)CFStringRefObj_CFStringCreateWithSubstring, 1, - PyDoc_STR("(CFRange range) -> (CFStringRef _rv)")}, - {"CFStringCreateCopy", (PyCFunction)CFStringRefObj_CFStringCreateCopy, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFStringGetLength", (PyCFunction)CFStringRefObj_CFStringGetLength, 1, - PyDoc_STR("() -> (CFIndex _rv)")}, - {"CFStringGetBytes", (PyCFunction)CFStringRefObj_CFStringGetBytes, 1, - PyDoc_STR("(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)")}, - {"CFStringCreateExternalRepresentation", (PyCFunction)CFStringRefObj_CFStringCreateExternalRepresentation, 1, - PyDoc_STR("(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)")}, - {"CFStringGetSmallestEncoding", (PyCFunction)CFStringRefObj_CFStringGetSmallestEncoding, 1, - PyDoc_STR("() -> (CFStringEncoding _rv)")}, - {"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1, - PyDoc_STR("() -> (CFStringEncoding _rv)")}, - {"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1, - PyDoc_STR("(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")}, - {"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1, - PyDoc_STR("(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")}, - {"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1, - PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)")}, - {"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1, - PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)")}, - {"CFStringFind", (PyCFunction)CFStringRefObj_CFStringFind, 1, - PyDoc_STR("(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)")}, - {"CFStringHasPrefix", (PyCFunction)CFStringRefObj_CFStringHasPrefix, 1, - PyDoc_STR("(CFStringRef prefix) -> (Boolean _rv)")}, - {"CFStringHasSuffix", (PyCFunction)CFStringRefObj_CFStringHasSuffix, 1, - PyDoc_STR("(CFStringRef suffix) -> (Boolean _rv)")}, - {"CFStringGetLineBounds", (PyCFunction)CFStringRefObj_CFStringGetLineBounds, 1, - PyDoc_STR("(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)")}, - {"CFStringCreateArrayBySeparatingStrings", (PyCFunction)CFStringRefObj_CFStringCreateArrayBySeparatingStrings, 1, - PyDoc_STR("(CFStringRef separatorString) -> (CFArrayRef _rv)")}, - {"CFStringGetIntValue", (PyCFunction)CFStringRefObj_CFStringGetIntValue, 1, - PyDoc_STR("() -> (SInt32 _rv)")}, - {"CFStringGetDoubleValue", (PyCFunction)CFStringRefObj_CFStringGetDoubleValue, 1, - PyDoc_STR("() -> (double _rv)")}, - {"CFStringConvertIANACharSetNameToEncoding", (PyCFunction)CFStringRefObj_CFStringConvertIANACharSetNameToEncoding, 1, - PyDoc_STR("() -> (CFStringEncoding _rv)")}, - {"CFShowStr", (PyCFunction)CFStringRefObj_CFShowStr, 1, - PyDoc_STR("() -> None")}, - {"CFURLCreateWithString", (PyCFunction)CFStringRefObj_CFURLCreateWithString, 1, - PyDoc_STR("(CFURLRef baseURL) -> (CFURLRef _rv)")}, - {"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1, - PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)")}, - {"CFURLCreateWithFileSystemPathRelativeToBase", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase, 1, - PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")}, - {"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1, - PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, - {"CFURLCreateStringByAddingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByAddingPercentEscapes, 1, - PyDoc_STR("(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)")}, - {"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1, - PyDoc_STR("() -> (string _rv)")}, - {"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1, - PyDoc_STR("() -> (unicode _rv)")}, - {NULL, NULL, 0} + {"CFStringCreateWithSubstring", (PyCFunction)CFStringRefObj_CFStringCreateWithSubstring, 1, + PyDoc_STR("(CFRange range) -> (CFStringRef _rv)")}, + {"CFStringCreateCopy", (PyCFunction)CFStringRefObj_CFStringCreateCopy, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFStringGetLength", (PyCFunction)CFStringRefObj_CFStringGetLength, 1, + PyDoc_STR("() -> (CFIndex _rv)")}, + {"CFStringGetBytes", (PyCFunction)CFStringRefObj_CFStringGetBytes, 1, + PyDoc_STR("(CFRange range, CFStringEncoding encoding, UInt8 lossByte, Boolean isExternalRepresentation, CFIndex maxBufLen) -> (CFIndex _rv, UInt8 buffer, CFIndex usedBufLen)")}, + {"CFStringCreateExternalRepresentation", (PyCFunction)CFStringRefObj_CFStringCreateExternalRepresentation, 1, + PyDoc_STR("(CFStringEncoding encoding, UInt8 lossByte) -> (CFDataRef _rv)")}, + {"CFStringGetSmallestEncoding", (PyCFunction)CFStringRefObj_CFStringGetSmallestEncoding, 1, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, + {"CFStringGetFastestEncoding", (PyCFunction)CFStringRefObj_CFStringGetFastestEncoding, 1, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, + {"CFStringCompareWithOptions", (PyCFunction)CFStringRefObj_CFStringCompareWithOptions, 1, + PyDoc_STR("(CFStringRef theString2, CFRange rangeToCompare, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")}, + {"CFStringCompare", (PyCFunction)CFStringRefObj_CFStringCompare, 1, + PyDoc_STR("(CFStringRef theString2, CFOptionFlags compareOptions) -> (CFComparisonResult _rv)")}, + {"CFStringFindWithOptions", (PyCFunction)CFStringRefObj_CFStringFindWithOptions, 1, + PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags searchOptions) -> (Boolean _rv, CFRange result)")}, + {"CFStringCreateArrayWithFindResults", (PyCFunction)CFStringRefObj_CFStringCreateArrayWithFindResults, 1, + PyDoc_STR("(CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) -> (CFArrayRef _rv)")}, + {"CFStringFind", (PyCFunction)CFStringRefObj_CFStringFind, 1, + PyDoc_STR("(CFStringRef stringToFind, CFOptionFlags compareOptions) -> (CFRange _rv)")}, + {"CFStringHasPrefix", (PyCFunction)CFStringRefObj_CFStringHasPrefix, 1, + PyDoc_STR("(CFStringRef prefix) -> (Boolean _rv)")}, + {"CFStringHasSuffix", (PyCFunction)CFStringRefObj_CFStringHasSuffix, 1, + PyDoc_STR("(CFStringRef suffix) -> (Boolean _rv)")}, + {"CFStringGetLineBounds", (PyCFunction)CFStringRefObj_CFStringGetLineBounds, 1, + PyDoc_STR("(CFRange range) -> (CFIndex lineBeginIndex, CFIndex lineEndIndex, CFIndex contentsEndIndex)")}, + {"CFStringCreateArrayBySeparatingStrings", (PyCFunction)CFStringRefObj_CFStringCreateArrayBySeparatingStrings, 1, + PyDoc_STR("(CFStringRef separatorString) -> (CFArrayRef _rv)")}, + {"CFStringGetIntValue", (PyCFunction)CFStringRefObj_CFStringGetIntValue, 1, + PyDoc_STR("() -> (SInt32 _rv)")}, + {"CFStringGetDoubleValue", (PyCFunction)CFStringRefObj_CFStringGetDoubleValue, 1, + PyDoc_STR("() -> (double _rv)")}, + {"CFStringConvertIANACharSetNameToEncoding", (PyCFunction)CFStringRefObj_CFStringConvertIANACharSetNameToEncoding, 1, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, + {"CFShowStr", (PyCFunction)CFStringRefObj_CFShowStr, 1, + PyDoc_STR("() -> None")}, + {"CFURLCreateWithString", (PyCFunction)CFStringRefObj_CFURLCreateWithString, 1, + PyDoc_STR("(CFURLRef baseURL) -> (CFURLRef _rv)")}, + {"CFURLCreateWithFileSystemPath", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPath, 1, + PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory) -> (CFURLRef _rv)")}, + {"CFURLCreateWithFileSystemPathRelativeToBase", (PyCFunction)CFStringRefObj_CFURLCreateWithFileSystemPathRelativeToBase, 1, + PyDoc_STR("(CFURLPathStyle pathStyle, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")}, + {"CFURLCreateStringByReplacingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByReplacingPercentEscapes, 1, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, + {"CFURLCreateStringByAddingPercentEscapes", (PyCFunction)CFStringRefObj_CFURLCreateStringByAddingPercentEscapes, 1, + PyDoc_STR("(CFStringRef charactersToLeaveUnescaped, CFStringRef legalURLCharactersToBeEscaped, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringGetString", (PyCFunction)CFStringRefObj_CFStringGetString, 1, + PyDoc_STR("() -> (string _rv)")}, + {"CFStringGetUnicode", (PyCFunction)CFStringRefObj_CFStringGetUnicode, 1, + PyDoc_STR("() -> (unicode _rv)")}, + {NULL, NULL, 0} }; #define CFStringRefObj_getsetlist NULL @@ -2435,100 +2435,100 @@ static PyMethodDef CFStringRefObj_methods[] = { static int CFStringRefObj_compare(CFStringRefObject *self, CFStringRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFStringRefObj_repr(CFStringRefObject *self) { - char buf[100]; - sprintf(buf, "<CFStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFStringRefObj_hash(CFStringRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFStringRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFStringRefObj_Convert, &itself)) - { - ((CFStringRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFStringRef", /*tp_name*/ - sizeof(CFStringRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFStringRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFStringRef", /*tp_name*/ + sizeof(CFStringRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFStringRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 ------------------- */ @@ -2541,281 +2541,281 @@ PyTypeObject CFMutableStringRef_Type; #define CFMutableStringRefObj_Check(x) ((x)->ob_type == &CFMutableStringRef_Type || PyObject_TypeCheck((x), &CFMutableStringRef_Type)) typedef struct CFMutableStringRefObject { - PyObject_HEAD - CFMutableStringRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFMutableStringRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFMutableStringRefObject; PyObject *CFMutableStringRefObj_New(CFMutableStringRef itself) { - CFMutableStringRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFMutableStringRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFMutableStringRefObj_Convert(PyObject *v, CFMutableStringRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ - if (!CFMutableStringRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFMutableStringRef required"); - return 0; - } - *p_itself = ((CFMutableStringRefObject *)v)->ob_itself; - return 1; + if (!CFMutableStringRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFMutableStringRef required"); + return 0; + } + *p_itself = ((CFMutableStringRefObject *)v)->ob_itself; + return 1; } static void CFMutableStringRefObj_dealloc(CFMutableStringRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFStringRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFStringRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFMutableStringRefObj_CFStringAppend(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef appendedString; + PyObject *_res = NULL; + CFStringRef appendedString; #ifndef CFStringAppend - PyMac_PRECHECK(CFStringAppend); + PyMac_PRECHECK(CFStringAppend); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &appendedString)) - return NULL; - CFStringAppend(_self->ob_itself, - appendedString); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &appendedString)) + return NULL; + CFStringAppend(_self->ob_itself, + appendedString); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringAppendCharacters(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - UniChar *chars__in__; - UniCharCount chars__len__; - int chars__in_len__; + PyObject *_res = NULL; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; #ifndef CFStringAppendCharacters - PyMac_PRECHECK(CFStringAppendCharacters); + PyMac_PRECHECK(CFStringAppendCharacters); #endif - if (!PyArg_ParseTuple(_args, "u#", - &chars__in__, &chars__in_len__)) - return NULL; - chars__len__ = chars__in_len__; - CFStringAppendCharacters(_self->ob_itself, - chars__in__, chars__len__); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + CFStringAppendCharacters(_self->ob_itself, + chars__in__, chars__len__); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringAppendPascalString(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Str255 pStr; - CFStringEncoding encoding; + PyObject *_res = NULL; + Str255 pStr; + CFStringEncoding encoding; #ifndef CFStringAppendPascalString - PyMac_PRECHECK(CFStringAppendPascalString); + PyMac_PRECHECK(CFStringAppendPascalString); #endif - if (!PyArg_ParseTuple(_args, "O&l", - PyMac_GetStr255, pStr, - &encoding)) - return NULL; - CFStringAppendPascalString(_self->ob_itself, - pStr, - encoding); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetStr255, pStr, + &encoding)) + return NULL; + CFStringAppendPascalString(_self->ob_itself, + pStr, + encoding); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringAppendCString(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - char* cStr; - CFStringEncoding encoding; + PyObject *_res = NULL; + char* cStr; + CFStringEncoding encoding; #ifndef CFStringAppendCString - PyMac_PRECHECK(CFStringAppendCString); + PyMac_PRECHECK(CFStringAppendCString); #endif - if (!PyArg_ParseTuple(_args, "sl", - &cStr, - &encoding)) - return NULL; - CFStringAppendCString(_self->ob_itself, - cStr, - encoding); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "sl", + &cStr, + &encoding)) + return NULL; + CFStringAppendCString(_self->ob_itself, + cStr, + encoding); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringInsert(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex idx; - CFStringRef insertedStr; + PyObject *_res = NULL; + CFIndex idx; + CFStringRef insertedStr; #ifndef CFStringInsert - PyMac_PRECHECK(CFStringInsert); + PyMac_PRECHECK(CFStringInsert); #endif - if (!PyArg_ParseTuple(_args, "lO&", - &idx, - CFStringRefObj_Convert, &insertedStr)) - return NULL; - CFStringInsert(_self->ob_itself, - idx, - insertedStr); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "lO&", + &idx, + CFStringRefObj_Convert, &insertedStr)) + return NULL; + CFStringInsert(_self->ob_itself, + idx, + insertedStr); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringDelete(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFRange range; + PyObject *_res = NULL; + CFRange range; #ifndef CFStringDelete - PyMac_PRECHECK(CFStringDelete); + PyMac_PRECHECK(CFStringDelete); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFRange_Convert, &range)) - return NULL; - CFStringDelete(_self->ob_itself, - range); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFRange_Convert, &range)) + return NULL; + CFStringDelete(_self->ob_itself, + range); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringReplace(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFRange range; - CFStringRef replacement; + PyObject *_res = NULL; + CFRange range; + CFStringRef replacement; #ifndef CFStringReplace - PyMac_PRECHECK(CFStringReplace); + PyMac_PRECHECK(CFStringReplace); #endif - if (!PyArg_ParseTuple(_args, "O&O&", - CFRange_Convert, &range, - CFStringRefObj_Convert, &replacement)) - return NULL; - CFStringReplace(_self->ob_itself, - range, - replacement); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&O&", + CFRange_Convert, &range, + CFStringRefObj_Convert, &replacement)) + return NULL; + CFStringReplace(_self->ob_itself, + range, + replacement); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringReplaceAll(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef replacement; + PyObject *_res = NULL; + CFStringRef replacement; #ifndef CFStringReplaceAll - PyMac_PRECHECK(CFStringReplaceAll); + PyMac_PRECHECK(CFStringReplaceAll); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &replacement)) - return NULL; - CFStringReplaceAll(_self->ob_itself, - replacement); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &replacement)) + return NULL; + CFStringReplaceAll(_self->ob_itself, + replacement); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringPad(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef padString; - CFIndex length; - CFIndex indexIntoPad; + PyObject *_res = NULL; + CFStringRef padString; + CFIndex length; + CFIndex indexIntoPad; #ifndef CFStringPad - PyMac_PRECHECK(CFStringPad); + PyMac_PRECHECK(CFStringPad); #endif - if (!PyArg_ParseTuple(_args, "O&ll", - CFStringRefObj_Convert, &padString, - &length, - &indexIntoPad)) - return NULL; - CFStringPad(_self->ob_itself, - padString, - length, - indexIntoPad); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&ll", + CFStringRefObj_Convert, &padString, + &length, + &indexIntoPad)) + return NULL; + CFStringPad(_self->ob_itself, + padString, + length, + indexIntoPad); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringTrim(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef trimString; + PyObject *_res = NULL; + CFStringRef trimString; #ifndef CFStringTrim - PyMac_PRECHECK(CFStringTrim); + PyMac_PRECHECK(CFStringTrim); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &trimString)) - return NULL; - CFStringTrim(_self->ob_itself, - trimString); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &trimString)) + return NULL; + CFStringTrim(_self->ob_itself, + trimString); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CFMutableStringRefObj_CFStringTrimWhitespace(CFMutableStringRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; #ifndef CFStringTrimWhitespace - PyMac_PRECHECK(CFStringTrimWhitespace); + PyMac_PRECHECK(CFStringTrimWhitespace); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - CFStringTrimWhitespace(_self->ob_itself); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + CFStringTrimWhitespace(_self->ob_itself); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyMethodDef CFMutableStringRefObj_methods[] = { - {"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1, - PyDoc_STR("(CFStringRef appendedString) -> None")}, - {"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1, - PyDoc_STR("(Buffer chars) -> None")}, - {"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1, - PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> None")}, - {"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1, - PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> None")}, - {"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1, - PyDoc_STR("(CFIndex idx, CFStringRef insertedStr) -> None")}, - {"CFStringDelete", (PyCFunction)CFMutableStringRefObj_CFStringDelete, 1, - PyDoc_STR("(CFRange range) -> None")}, - {"CFStringReplace", (PyCFunction)CFMutableStringRefObj_CFStringReplace, 1, - PyDoc_STR("(CFRange range, CFStringRef replacement) -> None")}, - {"CFStringReplaceAll", (PyCFunction)CFMutableStringRefObj_CFStringReplaceAll, 1, - PyDoc_STR("(CFStringRef replacement) -> None")}, - {"CFStringPad", (PyCFunction)CFMutableStringRefObj_CFStringPad, 1, - PyDoc_STR("(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None")}, - {"CFStringTrim", (PyCFunction)CFMutableStringRefObj_CFStringTrim, 1, - PyDoc_STR("(CFStringRef trimString) -> None")}, - {"CFStringTrimWhitespace", (PyCFunction)CFMutableStringRefObj_CFStringTrimWhitespace, 1, - PyDoc_STR("() -> None")}, - {NULL, NULL, 0} + {"CFStringAppend", (PyCFunction)CFMutableStringRefObj_CFStringAppend, 1, + PyDoc_STR("(CFStringRef appendedString) -> None")}, + {"CFStringAppendCharacters", (PyCFunction)CFMutableStringRefObj_CFStringAppendCharacters, 1, + PyDoc_STR("(Buffer chars) -> None")}, + {"CFStringAppendPascalString", (PyCFunction)CFMutableStringRefObj_CFStringAppendPascalString, 1, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> None")}, + {"CFStringAppendCString", (PyCFunction)CFMutableStringRefObj_CFStringAppendCString, 1, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> None")}, + {"CFStringInsert", (PyCFunction)CFMutableStringRefObj_CFStringInsert, 1, + PyDoc_STR("(CFIndex idx, CFStringRef insertedStr) -> None")}, + {"CFStringDelete", (PyCFunction)CFMutableStringRefObj_CFStringDelete, 1, + PyDoc_STR("(CFRange range) -> None")}, + {"CFStringReplace", (PyCFunction)CFMutableStringRefObj_CFStringReplace, 1, + PyDoc_STR("(CFRange range, CFStringRef replacement) -> None")}, + {"CFStringReplaceAll", (PyCFunction)CFMutableStringRefObj_CFStringReplaceAll, 1, + PyDoc_STR("(CFStringRef replacement) -> None")}, + {"CFStringPad", (PyCFunction)CFMutableStringRefObj_CFStringPad, 1, + PyDoc_STR("(CFStringRef padString, CFIndex length, CFIndex indexIntoPad) -> None")}, + {"CFStringTrim", (PyCFunction)CFMutableStringRefObj_CFStringTrim, 1, + PyDoc_STR("(CFStringRef trimString) -> None")}, + {"CFStringTrimWhitespace", (PyCFunction)CFMutableStringRefObj_CFStringTrimWhitespace, 1, + PyDoc_STR("() -> None")}, + {NULL, NULL, 0} }; #define CFMutableStringRefObj_getsetlist NULL @@ -2823,100 +2823,100 @@ static PyMethodDef CFMutableStringRefObj_methods[] = { static int CFMutableStringRefObj_compare(CFMutableStringRefObject *self, CFMutableStringRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFMutableStringRefObj_repr(CFMutableStringRefObject *self) { - char buf[100]; - sprintf(buf, "<CFMutableStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFMutableStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFMutableStringRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableStringRefObj_Convert, &itself)) - { - ((CFMutableStringRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFMutableStringRef", /*tp_name*/ - sizeof(CFMutableStringRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFMutableStringRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFMutableStringRef", /*tp_name*/ + sizeof(CFMutableStringRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFMutableStringRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 --------------- */ @@ -2929,545 +2929,545 @@ PyTypeObject CFURLRef_Type; #define CFURLRefObj_Check(x) ((x)->ob_type == &CFURLRef_Type || PyObject_TypeCheck((x), &CFURLRef_Type)) typedef struct CFURLRefObject { - PyObject_HEAD - CFURLRef ob_itself; - void (*ob_freeit)(CFTypeRef ptr); + PyObject_HEAD + CFURLRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); } CFURLRefObject; PyObject *CFURLRefObj_New(CFURLRef itself) { - CFURLRefObject *it; - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - 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; + CFURLRefObject *it; + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + 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; } int CFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ - if (!CFURLRefObj_Check(v)) - { - PyErr_SetString(PyExc_TypeError, "CFURLRef required"); - return 0; - } - *p_itself = ((CFURLRefObject *)v)->ob_itself; - return 1; + if (!CFURLRefObj_Check(v)) + { + PyErr_SetString(PyExc_TypeError, "CFURLRef required"); + return 0; + } + *p_itself = ((CFURLRefObject *)v)->ob_itself; + return 1; } static void CFURLRefObj_dealloc(CFURLRefObject *self) { - if (self->ob_freeit && self->ob_itself) - { - self->ob_freeit((CFTypeRef)self->ob_itself); - self->ob_itself = NULL; - } - CFTypeRef_Type.tp_dealloc((PyObject *)self); + if (self->ob_freeit && self->ob_itself) + { + self->ob_freeit((CFTypeRef)self->ob_itself); + self->ob_itself = NULL; + } + CFTypeRef_Type.tp_dealloc((PyObject *)self); } static PyObject *CFURLRefObj_CFURLCreateData(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDataRef _rv; - CFStringEncoding encoding; - Boolean escapeWhitespace; - if (!PyArg_ParseTuple(_args, "ll", - &encoding, - &escapeWhitespace)) - return NULL; - _rv = CFURLCreateData((CFAllocatorRef)NULL, - _self->ob_itself, - encoding, - escapeWhitespace); - _res = Py_BuildValue("O&", - CFDataRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFDataRef _rv; + CFStringEncoding encoding; + Boolean escapeWhitespace; + if (!PyArg_ParseTuple(_args, "ll", + &encoding, + &escapeWhitespace)) + return NULL; + _rv = CFURLCreateData((CFAllocatorRef)NULL, + _self->ob_itself, + encoding, + escapeWhitespace); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLGetFileSystemRepresentation(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - Boolean resolveAgainstBase; - UInt8 buffer; - CFIndex maxBufLen; + PyObject *_res = NULL; + Boolean _rv; + Boolean resolveAgainstBase; + UInt8 buffer; + CFIndex maxBufLen; #ifndef CFURLGetFileSystemRepresentation - PyMac_PRECHECK(CFURLGetFileSystemRepresentation); + PyMac_PRECHECK(CFURLGetFileSystemRepresentation); #endif - if (!PyArg_ParseTuple(_args, "ll", - &resolveAgainstBase, - &maxBufLen)) - return NULL; - _rv = CFURLGetFileSystemRepresentation(_self->ob_itself, - resolveAgainstBase, - &buffer, - maxBufLen); - _res = Py_BuildValue("lb", - _rv, - buffer); - return _res; + if (!PyArg_ParseTuple(_args, "ll", + &resolveAgainstBase, + &maxBufLen)) + return NULL; + _rv = CFURLGetFileSystemRepresentation(_self->ob_itself, + resolveAgainstBase, + &buffer, + maxBufLen); + _res = Py_BuildValue("lb", + _rv, + buffer); + return _res; } static PyObject *CFURLRefObj_CFURLCopyAbsoluteURL(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; + PyObject *_res = NULL; + CFURLRef _rv; #ifndef CFURLCopyAbsoluteURL - PyMac_PRECHECK(CFURLCopyAbsoluteURL); + PyMac_PRECHECK(CFURLCopyAbsoluteURL); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyAbsoluteURL(_self->ob_itself); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyAbsoluteURL(_self->ob_itself); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLGetString(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLGetString - PyMac_PRECHECK(CFURLGetString); + PyMac_PRECHECK(CFURLGetString); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLGetString(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetString(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLGetBaseURL(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; + PyObject *_res = NULL; + CFURLRef _rv; #ifndef CFURLGetBaseURL - PyMac_PRECHECK(CFURLGetBaseURL); + PyMac_PRECHECK(CFURLGetBaseURL); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLGetBaseURL(_self->ob_itself); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetBaseURL(_self->ob_itself); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCanBeDecomposed(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; + PyObject *_res = NULL; + Boolean _rv; #ifndef CFURLCanBeDecomposed - PyMac_PRECHECK(CFURLCanBeDecomposed); + PyMac_PRECHECK(CFURLCanBeDecomposed); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCanBeDecomposed(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCanBeDecomposed(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyScheme(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyScheme - PyMac_PRECHECK(CFURLCopyScheme); + PyMac_PRECHECK(CFURLCopyScheme); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyScheme(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyScheme(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyNetLocation(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyNetLocation - PyMac_PRECHECK(CFURLCopyNetLocation); + PyMac_PRECHECK(CFURLCopyNetLocation); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyNetLocation(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyNetLocation(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyPath(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyPath - PyMac_PRECHECK(CFURLCopyPath); + PyMac_PRECHECK(CFURLCopyPath); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyPath(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyPath(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyStrictPath(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - Boolean isAbsolute; + PyObject *_res = NULL; + CFStringRef _rv; + Boolean isAbsolute; #ifndef CFURLCopyStrictPath - PyMac_PRECHECK(CFURLCopyStrictPath); + PyMac_PRECHECK(CFURLCopyStrictPath); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyStrictPath(_self->ob_itself, - &isAbsolute); - _res = Py_BuildValue("O&l", - CFStringRefObj_New, _rv, - isAbsolute); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyStrictPath(_self->ob_itself, + &isAbsolute); + _res = Py_BuildValue("O&l", + CFStringRefObj_New, _rv, + isAbsolute); + return _res; } static PyObject *CFURLRefObj_CFURLCopyFileSystemPath(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFURLPathStyle pathStyle; + PyObject *_res = NULL; + CFStringRef _rv; + CFURLPathStyle pathStyle; #ifndef CFURLCopyFileSystemPath - PyMac_PRECHECK(CFURLCopyFileSystemPath); + PyMac_PRECHECK(CFURLCopyFileSystemPath); #endif - if (!PyArg_ParseTuple(_args, "l", - &pathStyle)) - return NULL; - _rv = CFURLCopyFileSystemPath(_self->ob_itself, - pathStyle); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &pathStyle)) + return NULL; + _rv = CFURLCopyFileSystemPath(_self->ob_itself, + pathStyle); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLHasDirectoryPath(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; + PyObject *_res = NULL; + Boolean _rv; #ifndef CFURLHasDirectoryPath - PyMac_PRECHECK(CFURLHasDirectoryPath); + PyMac_PRECHECK(CFURLHasDirectoryPath); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLHasDirectoryPath(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLHasDirectoryPath(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyResourceSpecifier(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyResourceSpecifier - PyMac_PRECHECK(CFURLCopyResourceSpecifier); + PyMac_PRECHECK(CFURLCopyResourceSpecifier); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyResourceSpecifier(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyResourceSpecifier(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyHostName(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyHostName - PyMac_PRECHECK(CFURLCopyHostName); + PyMac_PRECHECK(CFURLCopyHostName); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyHostName(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyHostName(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLGetPortNumber(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - SInt32 _rv; + PyObject *_res = NULL; + SInt32 _rv; #ifndef CFURLGetPortNumber - PyMac_PRECHECK(CFURLGetPortNumber); + PyMac_PRECHECK(CFURLGetPortNumber); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLGetPortNumber(_self->ob_itself); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetPortNumber(_self->ob_itself); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyUserName(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyUserName - PyMac_PRECHECK(CFURLCopyUserName); + PyMac_PRECHECK(CFURLCopyUserName); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyUserName(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyUserName(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyPassword(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyPassword - PyMac_PRECHECK(CFURLCopyPassword); + PyMac_PRECHECK(CFURLCopyPassword); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyPassword(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyPassword(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyParameterString(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringRef charactersToLeaveEscaped; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveEscaped; #ifndef CFURLCopyParameterString - PyMac_PRECHECK(CFURLCopyParameterString); + PyMac_PRECHECK(CFURLCopyParameterString); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &charactersToLeaveEscaped)) - return NULL; - _rv = CFURLCopyParameterString(_self->ob_itself, - charactersToLeaveEscaped); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &charactersToLeaveEscaped)) + return NULL; + _rv = CFURLCopyParameterString(_self->ob_itself, + charactersToLeaveEscaped); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyQueryString(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringRef charactersToLeaveEscaped; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveEscaped; #ifndef CFURLCopyQueryString - PyMac_PRECHECK(CFURLCopyQueryString); + PyMac_PRECHECK(CFURLCopyQueryString); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &charactersToLeaveEscaped)) - return NULL; - _rv = CFURLCopyQueryString(_self->ob_itself, - charactersToLeaveEscaped); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &charactersToLeaveEscaped)) + return NULL; + _rv = CFURLCopyQueryString(_self->ob_itself, + charactersToLeaveEscaped); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyFragment(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringRef charactersToLeaveEscaped; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringRef charactersToLeaveEscaped; #ifndef CFURLCopyFragment - PyMac_PRECHECK(CFURLCopyFragment); + PyMac_PRECHECK(CFURLCopyFragment); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &charactersToLeaveEscaped)) - return NULL; - _rv = CFURLCopyFragment(_self->ob_itself, - charactersToLeaveEscaped); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &charactersToLeaveEscaped)) + return NULL; + _rv = CFURLCopyFragment(_self->ob_itself, + charactersToLeaveEscaped); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyLastPathComponent(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyLastPathComponent - PyMac_PRECHECK(CFURLCopyLastPathComponent); + PyMac_PRECHECK(CFURLCopyLastPathComponent); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyLastPathComponent(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyLastPathComponent(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCopyPathExtension(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; + PyObject *_res = NULL; + CFStringRef _rv; #ifndef CFURLCopyPathExtension - PyMac_PRECHECK(CFURLCopyPathExtension); + PyMac_PRECHECK(CFURLCopyPathExtension); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCopyPathExtension(_self->ob_itself); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCopyPathExtension(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCreateCopyAppendingPathComponent(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - CFStringRef pathComponent; - Boolean isDirectory; - if (!PyArg_ParseTuple(_args, "O&l", - CFStringRefObj_Convert, &pathComponent, - &isDirectory)) - return NULL; - _rv = CFURLCreateCopyAppendingPathComponent((CFAllocatorRef)NULL, - _self->ob_itself, - pathComponent, - isDirectory); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFURLRef _rv; + CFStringRef pathComponent; + Boolean isDirectory; + if (!PyArg_ParseTuple(_args, "O&l", + CFStringRefObj_Convert, &pathComponent, + &isDirectory)) + return NULL; + _rv = CFURLCreateCopyAppendingPathComponent((CFAllocatorRef)NULL, + _self->ob_itself, + pathComponent, + isDirectory); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCreateCopyDeletingLastPathComponent((CFAllocatorRef)NULL, - _self->ob_itself); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFURLRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCreateCopyDeletingLastPathComponent((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCreateCopyAppendingPathExtension(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - CFStringRef extension; - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &extension)) - return NULL; - _rv = CFURLCreateCopyAppendingPathExtension((CFAllocatorRef)NULL, - _self->ob_itself, - extension); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFURLRef _rv; + CFStringRef extension; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &extension)) + return NULL; + _rv = CFURLCreateCopyAppendingPathExtension((CFAllocatorRef)NULL, + _self->ob_itself, + extension); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLCreateCopyDeletingPathExtension(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLCreateCopyDeletingPathExtension((CFAllocatorRef)NULL, - _self->ob_itself); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + PyObject *_res = NULL; + CFURLRef _rv; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLCreateCopyDeletingPathExtension((CFAllocatorRef)NULL, + _self->ob_itself); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CFURLRefObj_CFURLGetFSRef(CFURLRefObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - FSRef fsRef; + PyObject *_res = NULL; + Boolean _rv; + FSRef fsRef; #ifndef CFURLGetFSRef - PyMac_PRECHECK(CFURLGetFSRef); + PyMac_PRECHECK(CFURLGetFSRef); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLGetFSRef(_self->ob_itself, - &fsRef); - _res = Py_BuildValue("lO&", - _rv, - PyMac_BuildFSRef, &fsRef); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetFSRef(_self->ob_itself, + &fsRef); + _res = Py_BuildValue("lO&", + _rv, + PyMac_BuildFSRef, &fsRef); + return _res; } static PyMethodDef CFURLRefObj_methods[] = { - {"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1, - PyDoc_STR("(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)")}, - {"CFURLGetFileSystemRepresentation", (PyCFunction)CFURLRefObj_CFURLGetFileSystemRepresentation, 1, - PyDoc_STR("(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)")}, - {"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1, - PyDoc_STR("() -> (CFURLRef _rv)")}, - {"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLGetBaseURL", (PyCFunction)CFURLRefObj_CFURLGetBaseURL, 1, - PyDoc_STR("() -> (CFURLRef _rv)")}, - {"CFURLCanBeDecomposed", (PyCFunction)CFURLRefObj_CFURLCanBeDecomposed, 1, - PyDoc_STR("() -> (Boolean _rv)")}, - {"CFURLCopyScheme", (PyCFunction)CFURLRefObj_CFURLCopyScheme, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLCopyNetLocation", (PyCFunction)CFURLRefObj_CFURLCopyNetLocation, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLCopyStrictPath", (PyCFunction)CFURLRefObj_CFURLCopyStrictPath, 1, - PyDoc_STR("() -> (CFStringRef _rv, Boolean isAbsolute)")}, - {"CFURLCopyFileSystemPath", (PyCFunction)CFURLRefObj_CFURLCopyFileSystemPath, 1, - PyDoc_STR("(CFURLPathStyle pathStyle) -> (CFStringRef _rv)")}, - {"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1, - PyDoc_STR("() -> (Boolean _rv)")}, - {"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLCopyHostName", (PyCFunction)CFURLRefObj_CFURLCopyHostName, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLGetPortNumber", (PyCFunction)CFURLRefObj_CFURLGetPortNumber, 1, - PyDoc_STR("() -> (SInt32 _rv)")}, - {"CFURLCopyUserName", (PyCFunction)CFURLRefObj_CFURLCopyUserName, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLCopyPassword", (PyCFunction)CFURLRefObj_CFURLCopyPassword, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLCopyParameterString", (PyCFunction)CFURLRefObj_CFURLCopyParameterString, 1, - PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, - {"CFURLCopyQueryString", (PyCFunction)CFURLRefObj_CFURLCopyQueryString, 1, - PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, - {"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1, - PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, - {"CFURLCopyLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCopyLastPathComponent, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLCopyPathExtension", (PyCFunction)CFURLRefObj_CFURLCopyPathExtension, 1, - PyDoc_STR("() -> (CFStringRef _rv)")}, - {"CFURLCreateCopyAppendingPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathComponent, 1, - PyDoc_STR("(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)")}, - {"CFURLCreateCopyDeletingLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent, 1, - PyDoc_STR("() -> (CFURLRef _rv)")}, - {"CFURLCreateCopyAppendingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathExtension, 1, - PyDoc_STR("(CFStringRef extension) -> (CFURLRef _rv)")}, - {"CFURLCreateCopyDeletingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingPathExtension, 1, - PyDoc_STR("() -> (CFURLRef _rv)")}, - {"CFURLGetFSRef", (PyCFunction)CFURLRefObj_CFURLGetFSRef, 1, - PyDoc_STR("() -> (Boolean _rv, FSRef fsRef)")}, - {NULL, NULL, 0} + {"CFURLCreateData", (PyCFunction)CFURLRefObj_CFURLCreateData, 1, + PyDoc_STR("(CFStringEncoding encoding, Boolean escapeWhitespace) -> (CFDataRef _rv)")}, + {"CFURLGetFileSystemRepresentation", (PyCFunction)CFURLRefObj_CFURLGetFileSystemRepresentation, 1, + PyDoc_STR("(Boolean resolveAgainstBase, CFIndex maxBufLen) -> (Boolean _rv, UInt8 buffer)")}, + {"CFURLCopyAbsoluteURL", (PyCFunction)CFURLRefObj_CFURLCopyAbsoluteURL, 1, + PyDoc_STR("() -> (CFURLRef _rv)")}, + {"CFURLGetString", (PyCFunction)CFURLRefObj_CFURLGetString, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLGetBaseURL", (PyCFunction)CFURLRefObj_CFURLGetBaseURL, 1, + PyDoc_STR("() -> (CFURLRef _rv)")}, + {"CFURLCanBeDecomposed", (PyCFunction)CFURLRefObj_CFURLCanBeDecomposed, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"CFURLCopyScheme", (PyCFunction)CFURLRefObj_CFURLCopyScheme, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyNetLocation", (PyCFunction)CFURLRefObj_CFURLCopyNetLocation, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyPath", (PyCFunction)CFURLRefObj_CFURLCopyPath, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyStrictPath", (PyCFunction)CFURLRefObj_CFURLCopyStrictPath, 1, + PyDoc_STR("() -> (CFStringRef _rv, Boolean isAbsolute)")}, + {"CFURLCopyFileSystemPath", (PyCFunction)CFURLRefObj_CFURLCopyFileSystemPath, 1, + PyDoc_STR("(CFURLPathStyle pathStyle) -> (CFStringRef _rv)")}, + {"CFURLHasDirectoryPath", (PyCFunction)CFURLRefObj_CFURLHasDirectoryPath, 1, + PyDoc_STR("() -> (Boolean _rv)")}, + {"CFURLCopyResourceSpecifier", (PyCFunction)CFURLRefObj_CFURLCopyResourceSpecifier, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyHostName", (PyCFunction)CFURLRefObj_CFURLCopyHostName, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLGetPortNumber", (PyCFunction)CFURLRefObj_CFURLGetPortNumber, 1, + PyDoc_STR("() -> (SInt32 _rv)")}, + {"CFURLCopyUserName", (PyCFunction)CFURLRefObj_CFURLCopyUserName, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyPassword", (PyCFunction)CFURLRefObj_CFURLCopyPassword, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyParameterString", (PyCFunction)CFURLRefObj_CFURLCopyParameterString, 1, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, + {"CFURLCopyQueryString", (PyCFunction)CFURLRefObj_CFURLCopyQueryString, 1, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, + {"CFURLCopyFragment", (PyCFunction)CFURLRefObj_CFURLCopyFragment, 1, + PyDoc_STR("(CFStringRef charactersToLeaveEscaped) -> (CFStringRef _rv)")}, + {"CFURLCopyLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCopyLastPathComponent, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCopyPathExtension", (PyCFunction)CFURLRefObj_CFURLCopyPathExtension, 1, + PyDoc_STR("() -> (CFStringRef _rv)")}, + {"CFURLCreateCopyAppendingPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathComponent, 1, + PyDoc_STR("(CFStringRef pathComponent, Boolean isDirectory) -> (CFURLRef _rv)")}, + {"CFURLCreateCopyDeletingLastPathComponent", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingLastPathComponent, 1, + PyDoc_STR("() -> (CFURLRef _rv)")}, + {"CFURLCreateCopyAppendingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyAppendingPathExtension, 1, + PyDoc_STR("(CFStringRef extension) -> (CFURLRef _rv)")}, + {"CFURLCreateCopyDeletingPathExtension", (PyCFunction)CFURLRefObj_CFURLCreateCopyDeletingPathExtension, 1, + PyDoc_STR("() -> (CFURLRef _rv)")}, + {"CFURLGetFSRef", (PyCFunction)CFURLRefObj_CFURLGetFSRef, 1, + PyDoc_STR("() -> (Boolean _rv, FSRef fsRef)")}, + {NULL, NULL, 0} }; #define CFURLRefObj_getsetlist NULL @@ -3475,100 +3475,100 @@ static PyMethodDef CFURLRefObj_methods[] = { static int CFURLRefObj_compare(CFURLRefObject *self, CFURLRefObject *other) { - /* XXXX Or should we use CFEqual?? */ - if ( self->ob_itself > other->ob_itself ) return 1; - if ( self->ob_itself < other->ob_itself ) return -1; - return 0; + /* XXXX Or should we use CFEqual?? */ + if ( self->ob_itself > other->ob_itself ) return 1; + if ( self->ob_itself < other->ob_itself ) return -1; + return 0; } static PyObject * CFURLRefObj_repr(CFURLRefObject *self) { - char buf[100]; - sprintf(buf, "<CFURL object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); - return PyString_FromString(buf); + char buf[100]; + sprintf(buf, "<CFURL object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself); + return PyString_FromString(buf); } static int CFURLRefObj_hash(CFURLRefObject *self) { - /* XXXX Or should we use CFHash?? */ - return (int)self->ob_itself; + /* 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}; + CFURLRef itself; + char *kw[] = {"itself", 0}; - if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFURLRefObj_Convert, &itself)) - { - ((CFURLRefObject *)_self)->ob_itself = itself; - return 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; + /* 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; + 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) - 0, /*ob_size*/ - "_CF.CFURLRef", /*tp_name*/ - sizeof(CFURLRefObject), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - /* methods */ - (destructor) CFURLRefObj_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - (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 */ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_CF.CFURLRef", /*tp_name*/ + sizeof(CFURLRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFURLRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (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 -------------------- */ @@ -3576,1250 +3576,1250 @@ PyTypeObject CFURLRef_Type = { static PyObject *CF___CFRangeMake(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFRange _rv; - CFIndex loc; - CFIndex len; + PyObject *_res = NULL; + CFRange _rv; + CFIndex loc; + CFIndex len; #ifndef __CFRangeMake - PyMac_PRECHECK(__CFRangeMake); + PyMac_PRECHECK(__CFRangeMake); #endif - if (!PyArg_ParseTuple(_args, "ll", - &loc, - &len)) - return NULL; - _rv = __CFRangeMake(loc, - len); - _res = Py_BuildValue("O&", - CFRange_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "ll", + &loc, + &len)) + return NULL; + _rv = __CFRangeMake(loc, + len); + _res = Py_BuildValue("O&", + CFRange_New, _rv); + return _res; } static PyObject *CF_CFAllocatorGetTypeID(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeID _rv; + PyObject *_res = NULL; + CFTypeID _rv; #ifndef CFAllocatorGetTypeID - PyMac_PRECHECK(CFAllocatorGetTypeID); + PyMac_PRECHECK(CFAllocatorGetTypeID); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFAllocatorGetTypeID(); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFAllocatorGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFAllocatorGetPreferredSizeForSize(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; - CFIndex size; - CFOptionFlags hint; + PyObject *_res = NULL; + CFIndex _rv; + CFIndex size; + CFOptionFlags hint; #ifndef CFAllocatorGetPreferredSizeForSize - PyMac_PRECHECK(CFAllocatorGetPreferredSizeForSize); + PyMac_PRECHECK(CFAllocatorGetPreferredSizeForSize); #endif - if (!PyArg_ParseTuple(_args, "ll", - &size, - &hint)) - return NULL; - _rv = CFAllocatorGetPreferredSizeForSize((CFAllocatorRef)NULL, - size, - hint); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "ll", + &size, + &hint)) + return NULL; + _rv = CFAllocatorGetPreferredSizeForSize((CFAllocatorRef)NULL, + size, + hint); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFCopyTypeIDDescription(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFTypeID type_id; + PyObject *_res = NULL; + CFStringRef _rv; + CFTypeID type_id; #ifndef CFCopyTypeIDDescription - PyMac_PRECHECK(CFCopyTypeIDDescription); + PyMac_PRECHECK(CFCopyTypeIDDescription); #endif - if (!PyArg_ParseTuple(_args, "l", - &type_id)) - return NULL; - _rv = CFCopyTypeIDDescription(type_id); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &type_id)) + return NULL; + _rv = CFCopyTypeIDDescription(type_id); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFArrayGetTypeID(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeID _rv; + PyObject *_res = NULL; + CFTypeID _rv; #ifndef CFArrayGetTypeID - PyMac_PRECHECK(CFArrayGetTypeID); + PyMac_PRECHECK(CFArrayGetTypeID); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFArrayGetTypeID(); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFArrayGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFArrayCreateMutable(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFMutableArrayRef _rv; - CFIndex capacity; + PyObject *_res = NULL; + CFMutableArrayRef _rv; + CFIndex capacity; #ifndef CFArrayCreateMutable - PyMac_PRECHECK(CFArrayCreateMutable); + PyMac_PRECHECK(CFArrayCreateMutable); #endif - if (!PyArg_ParseTuple(_args, "l", - &capacity)) - return NULL; - _rv = CFArrayCreateMutable((CFAllocatorRef)NULL, - capacity, - &kCFTypeArrayCallBacks); - _res = Py_BuildValue("O&", - CFMutableArrayRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &capacity)) + return NULL; + _rv = CFArrayCreateMutable((CFAllocatorRef)NULL, + capacity, + &kCFTypeArrayCallBacks); + _res = Py_BuildValue("O&", + CFMutableArrayRefObj_New, _rv); + return _res; } static PyObject *CF_CFArrayCreateMutableCopy(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFMutableArrayRef _rv; - CFIndex capacity; - CFArrayRef theArray; + PyObject *_res = NULL; + CFMutableArrayRef _rv; + CFIndex capacity; + CFArrayRef theArray; #ifndef CFArrayCreateMutableCopy - PyMac_PRECHECK(CFArrayCreateMutableCopy); + PyMac_PRECHECK(CFArrayCreateMutableCopy); #endif - if (!PyArg_ParseTuple(_args, "lO&", - &capacity, - CFArrayRefObj_Convert, &theArray)) - return NULL; - _rv = CFArrayCreateMutableCopy((CFAllocatorRef)NULL, - capacity, - theArray); - _res = Py_BuildValue("O&", - CFMutableArrayRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "lO&", + &capacity, + CFArrayRefObj_Convert, &theArray)) + return NULL; + _rv = CFArrayCreateMutableCopy((CFAllocatorRef)NULL, + capacity, + theArray); + _res = Py_BuildValue("O&", + CFMutableArrayRefObj_New, _rv); + return _res; } static PyObject *CF_CFDataGetTypeID(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeID _rv; + PyObject *_res = NULL; + CFTypeID _rv; #ifndef CFDataGetTypeID - PyMac_PRECHECK(CFDataGetTypeID); + PyMac_PRECHECK(CFDataGetTypeID); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFDataGetTypeID(); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDataGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFDataCreate(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDataRef _rv; - unsigned char *bytes__in__; - long bytes__len__; - int bytes__in_len__; + PyObject *_res = NULL; + CFDataRef _rv; + unsigned char *bytes__in__; + long bytes__len__; + int bytes__in_len__; #ifndef CFDataCreate - PyMac_PRECHECK(CFDataCreate); + PyMac_PRECHECK(CFDataCreate); #endif - if (!PyArg_ParseTuple(_args, "s#", - &bytes__in__, &bytes__in_len__)) - return NULL; - bytes__len__ = bytes__in_len__; - _rv = CFDataCreate((CFAllocatorRef)NULL, - bytes__in__, bytes__len__); - _res = Py_BuildValue("O&", - CFDataRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "s#", + &bytes__in__, &bytes__in_len__)) + return NULL; + bytes__len__ = bytes__in_len__; + _rv = CFDataCreate((CFAllocatorRef)NULL, + bytes__in__, bytes__len__); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; } static PyObject *CF_CFDataCreateWithBytesNoCopy(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDataRef _rv; - unsigned char *bytes__in__; - long bytes__len__; - int bytes__in_len__; + PyObject *_res = NULL; + CFDataRef _rv; + unsigned char *bytes__in__; + long bytes__len__; + int bytes__in_len__; #ifndef CFDataCreateWithBytesNoCopy - PyMac_PRECHECK(CFDataCreateWithBytesNoCopy); + PyMac_PRECHECK(CFDataCreateWithBytesNoCopy); #endif - if (!PyArg_ParseTuple(_args, "s#", - &bytes__in__, &bytes__in_len__)) - return NULL; - bytes__len__ = bytes__in_len__; - _rv = CFDataCreateWithBytesNoCopy((CFAllocatorRef)NULL, - bytes__in__, bytes__len__, - (CFAllocatorRef)NULL); - _res = Py_BuildValue("O&", - CFDataRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "s#", + &bytes__in__, &bytes__in_len__)) + return NULL; + bytes__len__ = bytes__in_len__; + _rv = CFDataCreateWithBytesNoCopy((CFAllocatorRef)NULL, + bytes__in__, bytes__len__, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFDataRefObj_New, _rv); + return _res; } static PyObject *CF_CFDataCreateMutable(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFMutableDataRef _rv; - CFIndex capacity; + PyObject *_res = NULL; + CFMutableDataRef _rv; + CFIndex capacity; #ifndef CFDataCreateMutable - PyMac_PRECHECK(CFDataCreateMutable); + PyMac_PRECHECK(CFDataCreateMutable); #endif - if (!PyArg_ParseTuple(_args, "l", - &capacity)) - return NULL; - _rv = CFDataCreateMutable((CFAllocatorRef)NULL, - capacity); - _res = Py_BuildValue("O&", - CFMutableDataRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &capacity)) + return NULL; + _rv = CFDataCreateMutable((CFAllocatorRef)NULL, + capacity); + _res = Py_BuildValue("O&", + CFMutableDataRefObj_New, _rv); + return _res; } static PyObject *CF_CFDataCreateMutableCopy(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFMutableDataRef _rv; - CFIndex capacity; - CFDataRef theData; + PyObject *_res = NULL; + CFMutableDataRef _rv; + CFIndex capacity; + CFDataRef theData; #ifndef CFDataCreateMutableCopy - PyMac_PRECHECK(CFDataCreateMutableCopy); + PyMac_PRECHECK(CFDataCreateMutableCopy); #endif - if (!PyArg_ParseTuple(_args, "lO&", - &capacity, - CFDataRefObj_Convert, &theData)) - return NULL; - _rv = CFDataCreateMutableCopy((CFAllocatorRef)NULL, - capacity, - theData); - _res = Py_BuildValue("O&", - CFMutableDataRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "lO&", + &capacity, + CFDataRefObj_Convert, &theData)) + return NULL; + _rv = CFDataCreateMutableCopy((CFAllocatorRef)NULL, + capacity, + theData); + _res = Py_BuildValue("O&", + CFMutableDataRefObj_New, _rv); + return _res; } static PyObject *CF_CFDictionaryGetTypeID(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeID _rv; + PyObject *_res = NULL; + CFTypeID _rv; #ifndef CFDictionaryGetTypeID - PyMac_PRECHECK(CFDictionaryGetTypeID); + PyMac_PRECHECK(CFDictionaryGetTypeID); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFDictionaryGetTypeID(); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFDictionaryGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFDictionaryCreateMutable(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFMutableDictionaryRef _rv; - CFIndex capacity; + PyObject *_res = NULL; + CFMutableDictionaryRef _rv; + CFIndex capacity; #ifndef CFDictionaryCreateMutable - PyMac_PRECHECK(CFDictionaryCreateMutable); + PyMac_PRECHECK(CFDictionaryCreateMutable); #endif - if (!PyArg_ParseTuple(_args, "l", - &capacity)) - return NULL; - _rv = CFDictionaryCreateMutable((CFAllocatorRef)NULL, - capacity, - &kCFTypeDictionaryKeyCallBacks, - &kCFTypeDictionaryValueCallBacks); - _res = Py_BuildValue("O&", - CFMutableDictionaryRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &capacity)) + return NULL; + _rv = CFDictionaryCreateMutable((CFAllocatorRef)NULL, + capacity, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + _res = Py_BuildValue("O&", + CFMutableDictionaryRefObj_New, _rv); + return _res; } static PyObject *CF_CFDictionaryCreateMutableCopy(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFMutableDictionaryRef _rv; - CFIndex capacity; - CFDictionaryRef theDict; + PyObject *_res = NULL; + CFMutableDictionaryRef _rv; + CFIndex capacity; + CFDictionaryRef theDict; #ifndef CFDictionaryCreateMutableCopy - PyMac_PRECHECK(CFDictionaryCreateMutableCopy); + PyMac_PRECHECK(CFDictionaryCreateMutableCopy); #endif - if (!PyArg_ParseTuple(_args, "lO&", - &capacity, - CFDictionaryRefObj_Convert, &theDict)) - return NULL; - _rv = CFDictionaryCreateMutableCopy((CFAllocatorRef)NULL, - capacity, - theDict); - _res = Py_BuildValue("O&", - CFMutableDictionaryRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "lO&", + &capacity, + CFDictionaryRefObj_Convert, &theDict)) + return NULL; + _rv = CFDictionaryCreateMutableCopy((CFAllocatorRef)NULL, + capacity, + theDict); + _res = Py_BuildValue("O&", + CFMutableDictionaryRefObj_New, _rv); + return _res; } static PyObject *CF_CFPreferencesCopyAppValue(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeRef _rv; - CFStringRef key; - CFStringRef applicationID; + PyObject *_res = NULL; + CFTypeRef _rv; + CFStringRef key; + CFStringRef applicationID; #ifndef CFPreferencesCopyAppValue - PyMac_PRECHECK(CFPreferencesCopyAppValue); + PyMac_PRECHECK(CFPreferencesCopyAppValue); #endif - if (!PyArg_ParseTuple(_args, "O&O&", - CFStringRefObj_Convert, &key, - CFStringRefObj_Convert, &applicationID)) - return NULL; - _rv = CFPreferencesCopyAppValue(key, - applicationID); - _res = Py_BuildValue("O&", - CFTypeRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &key, + CFStringRefObj_Convert, &applicationID)) + return NULL; + _rv = CFPreferencesCopyAppValue(key, + applicationID); + _res = Py_BuildValue("O&", + CFTypeRefObj_New, _rv); + return _res; } static PyObject *CF_CFPreferencesGetAppBooleanValue(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - CFStringRef key; - CFStringRef applicationID; - Boolean keyExistsAndHasValidFormat; + PyObject *_res = NULL; + Boolean _rv; + CFStringRef key; + CFStringRef applicationID; + Boolean keyExistsAndHasValidFormat; #ifndef CFPreferencesGetAppBooleanValue - PyMac_PRECHECK(CFPreferencesGetAppBooleanValue); + PyMac_PRECHECK(CFPreferencesGetAppBooleanValue); #endif - if (!PyArg_ParseTuple(_args, "O&O&", - CFStringRefObj_Convert, &key, - CFStringRefObj_Convert, &applicationID)) - return NULL; - _rv = CFPreferencesGetAppBooleanValue(key, - applicationID, - &keyExistsAndHasValidFormat); - _res = Py_BuildValue("ll", - _rv, - keyExistsAndHasValidFormat); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &key, + CFStringRefObj_Convert, &applicationID)) + return NULL; + _rv = CFPreferencesGetAppBooleanValue(key, + applicationID, + &keyExistsAndHasValidFormat); + _res = Py_BuildValue("ll", + _rv, + keyExistsAndHasValidFormat); + return _res; } static PyObject *CF_CFPreferencesGetAppIntegerValue(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; - CFStringRef key; - CFStringRef applicationID; - Boolean keyExistsAndHasValidFormat; + PyObject *_res = NULL; + CFIndex _rv; + CFStringRef key; + CFStringRef applicationID; + Boolean keyExistsAndHasValidFormat; #ifndef CFPreferencesGetAppIntegerValue - PyMac_PRECHECK(CFPreferencesGetAppIntegerValue); + PyMac_PRECHECK(CFPreferencesGetAppIntegerValue); #endif - if (!PyArg_ParseTuple(_args, "O&O&", - CFStringRefObj_Convert, &key, - CFStringRefObj_Convert, &applicationID)) - return NULL; - _rv = CFPreferencesGetAppIntegerValue(key, - applicationID, - &keyExistsAndHasValidFormat); - _res = Py_BuildValue("ll", - _rv, - keyExistsAndHasValidFormat); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &key, + CFStringRefObj_Convert, &applicationID)) + return NULL; + _rv = CFPreferencesGetAppIntegerValue(key, + applicationID, + &keyExistsAndHasValidFormat); + _res = Py_BuildValue("ll", + _rv, + keyExistsAndHasValidFormat); + return _res; } static PyObject *CF_CFPreferencesSetAppValue(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef key; - CFTypeRef value; - CFStringRef applicationID; + PyObject *_res = NULL; + CFStringRef key; + CFTypeRef value; + CFStringRef applicationID; #ifndef CFPreferencesSetAppValue - PyMac_PRECHECK(CFPreferencesSetAppValue); + PyMac_PRECHECK(CFPreferencesSetAppValue); #endif - if (!PyArg_ParseTuple(_args, "O&O&O&", - CFStringRefObj_Convert, &key, - CFTypeRefObj_Convert, &value, - CFStringRefObj_Convert, &applicationID)) - return NULL; - CFPreferencesSetAppValue(key, - value, - applicationID); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&O&O&", + CFStringRefObj_Convert, &key, + CFTypeRefObj_Convert, &value, + CFStringRefObj_Convert, &applicationID)) + return NULL; + CFPreferencesSetAppValue(key, + value, + applicationID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CF_CFPreferencesAddSuitePreferencesToApp(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef applicationID; - CFStringRef suiteID; + PyObject *_res = NULL; + CFStringRef applicationID; + CFStringRef suiteID; #ifndef CFPreferencesAddSuitePreferencesToApp - PyMac_PRECHECK(CFPreferencesAddSuitePreferencesToApp); + PyMac_PRECHECK(CFPreferencesAddSuitePreferencesToApp); #endif - if (!PyArg_ParseTuple(_args, "O&O&", - CFStringRefObj_Convert, &applicationID, - CFStringRefObj_Convert, &suiteID)) - return NULL; - CFPreferencesAddSuitePreferencesToApp(applicationID, - suiteID); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &suiteID)) + return NULL; + CFPreferencesAddSuitePreferencesToApp(applicationID, + suiteID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CF_CFPreferencesRemoveSuitePreferencesFromApp(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef applicationID; - CFStringRef suiteID; + PyObject *_res = NULL; + CFStringRef applicationID; + CFStringRef suiteID; #ifndef CFPreferencesRemoveSuitePreferencesFromApp - PyMac_PRECHECK(CFPreferencesRemoveSuitePreferencesFromApp); + PyMac_PRECHECK(CFPreferencesRemoveSuitePreferencesFromApp); #endif - if (!PyArg_ParseTuple(_args, "O&O&", - CFStringRefObj_Convert, &applicationID, - CFStringRefObj_Convert, &suiteID)) - return NULL; - CFPreferencesRemoveSuitePreferencesFromApp(applicationID, - suiteID); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &suiteID)) + return NULL; + CFPreferencesRemoveSuitePreferencesFromApp(applicationID, + suiteID); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CF_CFPreferencesAppSynchronize(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - CFStringRef applicationID; + PyObject *_res = NULL; + Boolean _rv; + CFStringRef applicationID; #ifndef CFPreferencesAppSynchronize - PyMac_PRECHECK(CFPreferencesAppSynchronize); + PyMac_PRECHECK(CFPreferencesAppSynchronize); #endif - if (!PyArg_ParseTuple(_args, "O&", - CFStringRefObj_Convert, &applicationID)) - return NULL; - _rv = CFPreferencesAppSynchronize(applicationID); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + CFStringRefObj_Convert, &applicationID)) + return NULL; + _rv = CFPreferencesAppSynchronize(applicationID); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFPreferencesCopyValue(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeRef _rv; - CFStringRef key; - CFStringRef applicationID; - CFStringRef userName; - CFStringRef hostName; + PyObject *_res = NULL; + CFTypeRef _rv; + CFStringRef key; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; #ifndef CFPreferencesCopyValue - PyMac_PRECHECK(CFPreferencesCopyValue); + PyMac_PRECHECK(CFPreferencesCopyValue); #endif - if (!PyArg_ParseTuple(_args, "O&O&O&O&", - CFStringRefObj_Convert, &key, - CFStringRefObj_Convert, &applicationID, - CFStringRefObj_Convert, &userName, - CFStringRefObj_Convert, &hostName)) - return NULL; - _rv = CFPreferencesCopyValue(key, - applicationID, - userName, - hostName); - _res = Py_BuildValue("O&", - CFTypeRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&O&O&", + CFStringRefObj_Convert, &key, + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesCopyValue(key, + applicationID, + userName, + hostName); + _res = Py_BuildValue("O&", + CFTypeRefObj_New, _rv); + return _res; } static PyObject *CF_CFPreferencesCopyMultiple(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDictionaryRef _rv; - CFArrayRef keysToFetch; - CFStringRef applicationID; - CFStringRef userName; - CFStringRef hostName; + PyObject *_res = NULL; + CFDictionaryRef _rv; + CFArrayRef keysToFetch; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; #ifndef CFPreferencesCopyMultiple - PyMac_PRECHECK(CFPreferencesCopyMultiple); + PyMac_PRECHECK(CFPreferencesCopyMultiple); #endif - if (!PyArg_ParseTuple(_args, "O&O&O&O&", - CFArrayRefObj_Convert, &keysToFetch, - CFStringRefObj_Convert, &applicationID, - CFStringRefObj_Convert, &userName, - CFStringRefObj_Convert, &hostName)) - return NULL; - _rv = CFPreferencesCopyMultiple(keysToFetch, - applicationID, - userName, - hostName); - _res = Py_BuildValue("O&", - CFDictionaryRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&O&O&", + CFArrayRefObj_Convert, &keysToFetch, + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesCopyMultiple(keysToFetch, + applicationID, + userName, + hostName); + _res = Py_BuildValue("O&", + CFDictionaryRefObj_New, _rv); + return _res; } static PyObject *CF_CFPreferencesSetValue(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef key; - CFTypeRef value; - CFStringRef applicationID; - CFStringRef userName; - CFStringRef hostName; + PyObject *_res = NULL; + CFStringRef key; + CFTypeRef value; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; #ifndef CFPreferencesSetValue - PyMac_PRECHECK(CFPreferencesSetValue); + PyMac_PRECHECK(CFPreferencesSetValue); #endif - if (!PyArg_ParseTuple(_args, "O&O&O&O&O&", - CFStringRefObj_Convert, &key, - CFTypeRefObj_Convert, &value, - CFStringRefObj_Convert, &applicationID, - CFStringRefObj_Convert, &userName, - CFStringRefObj_Convert, &hostName)) - return NULL; - CFPreferencesSetValue(key, - value, - applicationID, - userName, - hostName); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&O&O&O&O&", + CFStringRefObj_Convert, &key, + CFTypeRefObj_Convert, &value, + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + CFPreferencesSetValue(key, + value, + applicationID, + userName, + hostName); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CF_CFPreferencesSetMultiple(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFDictionaryRef keysToSet; - CFArrayRef keysToRemove; - CFStringRef applicationID; - CFStringRef userName; - CFStringRef hostName; + PyObject *_res = NULL; + CFDictionaryRef keysToSet; + CFArrayRef keysToRemove; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; #ifndef CFPreferencesSetMultiple - PyMac_PRECHECK(CFPreferencesSetMultiple); + PyMac_PRECHECK(CFPreferencesSetMultiple); #endif - if (!PyArg_ParseTuple(_args, "O&O&O&O&O&", - CFDictionaryRefObj_Convert, &keysToSet, - CFArrayRefObj_Convert, &keysToRemove, - CFStringRefObj_Convert, &applicationID, - CFStringRefObj_Convert, &userName, - CFStringRefObj_Convert, &hostName)) - return NULL; - CFPreferencesSetMultiple(keysToSet, - keysToRemove, - applicationID, - userName, - hostName); - Py_INCREF(Py_None); - _res = Py_None; - return _res; + if (!PyArg_ParseTuple(_args, "O&O&O&O&O&", + CFDictionaryRefObj_Convert, &keysToSet, + CFArrayRefObj_Convert, &keysToRemove, + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + CFPreferencesSetMultiple(keysToSet, + keysToRemove, + applicationID, + userName, + hostName); + Py_INCREF(Py_None); + _res = Py_None; + return _res; } static PyObject *CF_CFPreferencesSynchronize(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - CFStringRef applicationID; - CFStringRef userName; - CFStringRef hostName; + PyObject *_res = NULL; + Boolean _rv; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; #ifndef CFPreferencesSynchronize - PyMac_PRECHECK(CFPreferencesSynchronize); + PyMac_PRECHECK(CFPreferencesSynchronize); #endif - if (!PyArg_ParseTuple(_args, "O&O&O&", - CFStringRefObj_Convert, &applicationID, - CFStringRefObj_Convert, &userName, - CFStringRefObj_Convert, &hostName)) - return NULL; - _rv = CFPreferencesSynchronize(applicationID, - userName, - hostName); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&O&", + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesSynchronize(applicationID, + userName, + hostName); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFPreferencesCopyApplicationList(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFArrayRef _rv; - CFStringRef userName; - CFStringRef hostName; + PyObject *_res = NULL; + CFArrayRef _rv; + CFStringRef userName; + CFStringRef hostName; #ifndef CFPreferencesCopyApplicationList - PyMac_PRECHECK(CFPreferencesCopyApplicationList); + PyMac_PRECHECK(CFPreferencesCopyApplicationList); #endif - if (!PyArg_ParseTuple(_args, "O&O&", - CFStringRefObj_Convert, &userName, - CFStringRefObj_Convert, &hostName)) - return NULL; - _rv = CFPreferencesCopyApplicationList(userName, - hostName); - _res = Py_BuildValue("O&", - CFArrayRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&", + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesCopyApplicationList(userName, + hostName); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; } static PyObject *CF_CFPreferencesCopyKeyList(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFArrayRef _rv; - CFStringRef applicationID; - CFStringRef userName; - CFStringRef hostName; + PyObject *_res = NULL; + CFArrayRef _rv; + CFStringRef applicationID; + CFStringRef userName; + CFStringRef hostName; #ifndef CFPreferencesCopyKeyList - PyMac_PRECHECK(CFPreferencesCopyKeyList); + PyMac_PRECHECK(CFPreferencesCopyKeyList); #endif - if (!PyArg_ParseTuple(_args, "O&O&O&", - CFStringRefObj_Convert, &applicationID, - CFStringRefObj_Convert, &userName, - CFStringRefObj_Convert, &hostName)) - return NULL; - _rv = CFPreferencesCopyKeyList(applicationID, - userName, - hostName); - _res = Py_BuildValue("O&", - CFArrayRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&O&O&", + CFStringRefObj_Convert, &applicationID, + CFStringRefObj_Convert, &userName, + CFStringRefObj_Convert, &hostName)) + return NULL; + _rv = CFPreferencesCopyKeyList(applicationID, + userName, + hostName); + _res = Py_BuildValue("O&", + CFArrayRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringGetTypeID(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeID _rv; + PyObject *_res = NULL; + CFTypeID _rv; #ifndef CFStringGetTypeID - PyMac_PRECHECK(CFStringGetTypeID); + PyMac_PRECHECK(CFStringGetTypeID); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringGetTypeID(); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFStringCreateWithPascalString(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - Str255 pStr; - CFStringEncoding encoding; + PyObject *_res = NULL; + CFStringRef _rv; + Str255 pStr; + CFStringEncoding encoding; #ifndef CFStringCreateWithPascalString - PyMac_PRECHECK(CFStringCreateWithPascalString); + PyMac_PRECHECK(CFStringCreateWithPascalString); #endif - if (!PyArg_ParseTuple(_args, "O&l", - PyMac_GetStr255, pStr, - &encoding)) - return NULL; - _rv = CFStringCreateWithPascalString((CFAllocatorRef)NULL, - pStr, - encoding); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetStr255, pStr, + &encoding)) + return NULL; + _rv = CFStringCreateWithPascalString((CFAllocatorRef)NULL, + pStr, + encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringCreateWithCString(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - char* cStr; - CFStringEncoding encoding; + PyObject *_res = NULL; + CFStringRef _rv; + char* cStr; + CFStringEncoding encoding; #ifndef CFStringCreateWithCString - PyMac_PRECHECK(CFStringCreateWithCString); + PyMac_PRECHECK(CFStringCreateWithCString); #endif - if (!PyArg_ParseTuple(_args, "sl", - &cStr, - &encoding)) - return NULL; - _rv = CFStringCreateWithCString((CFAllocatorRef)NULL, - cStr, - encoding); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "sl", + &cStr, + &encoding)) + return NULL; + _rv = CFStringCreateWithCString((CFAllocatorRef)NULL, + cStr, + encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringCreateWithCharacters(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - UniChar *chars__in__; - UniCharCount chars__len__; - int chars__in_len__; + PyObject *_res = NULL; + CFStringRef _rv; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; #ifndef CFStringCreateWithCharacters - PyMac_PRECHECK(CFStringCreateWithCharacters); + PyMac_PRECHECK(CFStringCreateWithCharacters); #endif - if (!PyArg_ParseTuple(_args, "u#", - &chars__in__, &chars__in_len__)) - return NULL; - chars__len__ = chars__in_len__; - _rv = CFStringCreateWithCharacters((CFAllocatorRef)NULL, - chars__in__, chars__len__); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + _rv = CFStringCreateWithCharacters((CFAllocatorRef)NULL, + chars__in__, chars__len__); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringCreateWithPascalStringNoCopy(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - Str255 pStr; - CFStringEncoding encoding; + PyObject *_res = NULL; + CFStringRef _rv; + Str255 pStr; + CFStringEncoding encoding; #ifndef CFStringCreateWithPascalStringNoCopy - PyMac_PRECHECK(CFStringCreateWithPascalStringNoCopy); + PyMac_PRECHECK(CFStringCreateWithPascalStringNoCopy); #endif - if (!PyArg_ParseTuple(_args, "O&l", - PyMac_GetStr255, pStr, - &encoding)) - return NULL; - _rv = CFStringCreateWithPascalStringNoCopy((CFAllocatorRef)NULL, - pStr, - encoding, - (CFAllocatorRef)NULL); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&l", + PyMac_GetStr255, pStr, + &encoding)) + return NULL; + _rv = CFStringCreateWithPascalStringNoCopy((CFAllocatorRef)NULL, + pStr, + encoding, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringCreateWithCStringNoCopy(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - char* cStr; - CFStringEncoding encoding; + PyObject *_res = NULL; + CFStringRef _rv; + char* cStr; + CFStringEncoding encoding; #ifndef CFStringCreateWithCStringNoCopy - PyMac_PRECHECK(CFStringCreateWithCStringNoCopy); + PyMac_PRECHECK(CFStringCreateWithCStringNoCopy); #endif - if (!PyArg_ParseTuple(_args, "sl", - &cStr, - &encoding)) - return NULL; - _rv = CFStringCreateWithCStringNoCopy((CFAllocatorRef)NULL, - cStr, - encoding, - (CFAllocatorRef)NULL); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "sl", + &cStr, + &encoding)) + return NULL; + _rv = CFStringCreateWithCStringNoCopy((CFAllocatorRef)NULL, + cStr, + encoding, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringCreateWithCharactersNoCopy(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - UniChar *chars__in__; - UniCharCount chars__len__; - int chars__in_len__; + PyObject *_res = NULL; + CFStringRef _rv; + UniChar *chars__in__; + UniCharCount chars__len__; + int chars__in_len__; #ifndef CFStringCreateWithCharactersNoCopy - PyMac_PRECHECK(CFStringCreateWithCharactersNoCopy); + PyMac_PRECHECK(CFStringCreateWithCharactersNoCopy); #endif - if (!PyArg_ParseTuple(_args, "u#", - &chars__in__, &chars__in_len__)) - return NULL; - chars__len__ = chars__in_len__; - _rv = CFStringCreateWithCharactersNoCopy((CFAllocatorRef)NULL, - chars__in__, chars__len__, - (CFAllocatorRef)NULL); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "u#", + &chars__in__, &chars__in_len__)) + return NULL; + chars__len__ = chars__in_len__; + _rv = CFStringCreateWithCharactersNoCopy((CFAllocatorRef)NULL, + chars__in__, chars__len__, + (CFAllocatorRef)NULL); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringCreateMutable(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFMutableStringRef _rv; - CFIndex maxLength; + PyObject *_res = NULL; + CFMutableStringRef _rv; + CFIndex maxLength; #ifndef CFStringCreateMutable - PyMac_PRECHECK(CFStringCreateMutable); + PyMac_PRECHECK(CFStringCreateMutable); #endif - if (!PyArg_ParseTuple(_args, "l", - &maxLength)) - return NULL; - _rv = CFStringCreateMutable((CFAllocatorRef)NULL, - maxLength); - _res = Py_BuildValue("O&", - CFMutableStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &maxLength)) + return NULL; + _rv = CFStringCreateMutable((CFAllocatorRef)NULL, + maxLength); + _res = Py_BuildValue("O&", + CFMutableStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringCreateMutableCopy(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFMutableStringRef _rv; - CFIndex maxLength; - CFStringRef theString; + PyObject *_res = NULL; + CFMutableStringRef _rv; + CFIndex maxLength; + CFStringRef theString; #ifndef CFStringCreateMutableCopy - PyMac_PRECHECK(CFStringCreateMutableCopy); + PyMac_PRECHECK(CFStringCreateMutableCopy); #endif - if (!PyArg_ParseTuple(_args, "lO&", - &maxLength, - CFStringRefObj_Convert, &theString)) - return NULL; - _rv = CFStringCreateMutableCopy((CFAllocatorRef)NULL, - maxLength, - theString); - _res = Py_BuildValue("O&", - CFMutableStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "lO&", + &maxLength, + CFStringRefObj_Convert, &theString)) + return NULL; + _rv = CFStringCreateMutableCopy((CFAllocatorRef)NULL, + maxLength, + theString); + _res = Py_BuildValue("O&", + CFMutableStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringCreateWithBytes(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - unsigned char *bytes__in__; - long bytes__len__; - int bytes__in_len__; - CFStringEncoding encoding; - Boolean isExternalRepresentation; + PyObject *_res = NULL; + CFStringRef _rv; + unsigned char *bytes__in__; + long bytes__len__; + int bytes__in_len__; + CFStringEncoding encoding; + Boolean isExternalRepresentation; #ifndef CFStringCreateWithBytes - PyMac_PRECHECK(CFStringCreateWithBytes); + PyMac_PRECHECK(CFStringCreateWithBytes); #endif - if (!PyArg_ParseTuple(_args, "s#ll", - &bytes__in__, &bytes__in_len__, - &encoding, - &isExternalRepresentation)) - return NULL; - bytes__len__ = bytes__in_len__; - _rv = CFStringCreateWithBytes((CFAllocatorRef)NULL, - bytes__in__, bytes__len__, - encoding, - isExternalRepresentation); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "s#ll", + &bytes__in__, &bytes__in_len__, + &encoding, + &isExternalRepresentation)) + return NULL; + bytes__len__ = bytes__in_len__; + _rv = CFStringCreateWithBytes((CFAllocatorRef)NULL, + bytes__in__, bytes__len__, + encoding, + isExternalRepresentation); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringGetSystemEncoding(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringEncoding _rv; + PyObject *_res = NULL; + CFStringEncoding _rv; #ifndef CFStringGetSystemEncoding - PyMac_PRECHECK(CFStringGetSystemEncoding); + PyMac_PRECHECK(CFStringGetSystemEncoding); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFStringGetSystemEncoding(); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFStringGetSystemEncoding(); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFStringGetMaximumSizeForEncoding(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFIndex _rv; - CFIndex length; - CFStringEncoding encoding; + PyObject *_res = NULL; + CFIndex _rv; + CFIndex length; + CFStringEncoding encoding; #ifndef CFStringGetMaximumSizeForEncoding - PyMac_PRECHECK(CFStringGetMaximumSizeForEncoding); + PyMac_PRECHECK(CFStringGetMaximumSizeForEncoding); #endif - if (!PyArg_ParseTuple(_args, "ll", - &length, - &encoding)) - return NULL; - _rv = CFStringGetMaximumSizeForEncoding(length, - encoding); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "ll", + &length, + &encoding)) + return NULL; + _rv = CFStringGetMaximumSizeForEncoding(length, + encoding); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFStringIsEncodingAvailable(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - Boolean _rv; - CFStringEncoding encoding; + PyObject *_res = NULL; + Boolean _rv; + CFStringEncoding encoding; #ifndef CFStringIsEncodingAvailable - PyMac_PRECHECK(CFStringIsEncodingAvailable); + PyMac_PRECHECK(CFStringIsEncodingAvailable); #endif - if (!PyArg_ParseTuple(_args, "l", - &encoding)) - return NULL; - _rv = CFStringIsEncodingAvailable(encoding); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringIsEncodingAvailable(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFStringGetNameOfEncoding(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringEncoding encoding; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringEncoding encoding; #ifndef CFStringGetNameOfEncoding - PyMac_PRECHECK(CFStringGetNameOfEncoding); + PyMac_PRECHECK(CFStringGetNameOfEncoding); #endif - if (!PyArg_ParseTuple(_args, "l", - &encoding)) - return NULL; - _rv = CFStringGetNameOfEncoding(encoding); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringGetNameOfEncoding(encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringConvertEncodingToNSStringEncoding(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - UInt32 _rv; - CFStringEncoding encoding; + PyObject *_res = NULL; + UInt32 _rv; + CFStringEncoding encoding; #ifndef CFStringConvertEncodingToNSStringEncoding - PyMac_PRECHECK(CFStringConvertEncodingToNSStringEncoding); + PyMac_PRECHECK(CFStringConvertEncodingToNSStringEncoding); #endif - if (!PyArg_ParseTuple(_args, "l", - &encoding)) - return NULL; - _rv = CFStringConvertEncodingToNSStringEncoding(encoding); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringConvertEncodingToNSStringEncoding(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFStringConvertNSStringEncodingToEncoding(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringEncoding _rv; - UInt32 encoding; + PyObject *_res = NULL; + CFStringEncoding _rv; + UInt32 encoding; #ifndef CFStringConvertNSStringEncodingToEncoding - PyMac_PRECHECK(CFStringConvertNSStringEncodingToEncoding); + PyMac_PRECHECK(CFStringConvertNSStringEncodingToEncoding); #endif - if (!PyArg_ParseTuple(_args, "l", - &encoding)) - return NULL; - _rv = CFStringConvertNSStringEncodingToEncoding(encoding); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringConvertNSStringEncodingToEncoding(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFStringConvertEncodingToWindowsCodepage(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - UInt32 _rv; - CFStringEncoding encoding; + PyObject *_res = NULL; + UInt32 _rv; + CFStringEncoding encoding; #ifndef CFStringConvertEncodingToWindowsCodepage - PyMac_PRECHECK(CFStringConvertEncodingToWindowsCodepage); + PyMac_PRECHECK(CFStringConvertEncodingToWindowsCodepage); #endif - if (!PyArg_ParseTuple(_args, "l", - &encoding)) - return NULL; - _rv = CFStringConvertEncodingToWindowsCodepage(encoding); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringConvertEncodingToWindowsCodepage(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFStringConvertWindowsCodepageToEncoding(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringEncoding _rv; - UInt32 codepage; + PyObject *_res = NULL; + CFStringEncoding _rv; + UInt32 codepage; #ifndef CFStringConvertWindowsCodepageToEncoding - PyMac_PRECHECK(CFStringConvertWindowsCodepageToEncoding); + PyMac_PRECHECK(CFStringConvertWindowsCodepageToEncoding); #endif - if (!PyArg_ParseTuple(_args, "l", - &codepage)) - return NULL; - _rv = CFStringConvertWindowsCodepageToEncoding(codepage); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &codepage)) + return NULL; + _rv = CFStringConvertWindowsCodepageToEncoding(codepage); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFStringConvertEncodingToIANACharSetName(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - CFStringEncoding encoding; + PyObject *_res = NULL; + CFStringRef _rv; + CFStringEncoding encoding; #ifndef CFStringConvertEncodingToIANACharSetName - PyMac_PRECHECK(CFStringConvertEncodingToIANACharSetName); + PyMac_PRECHECK(CFStringConvertEncodingToIANACharSetName); #endif - if (!PyArg_ParseTuple(_args, "l", - &encoding)) - return NULL; - _rv = CFStringConvertEncodingToIANACharSetName(encoding); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringConvertEncodingToIANACharSetName(encoding); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFStringGetMostCompatibleMacStringEncoding(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringEncoding _rv; - CFStringEncoding encoding; + PyObject *_res = NULL; + CFStringEncoding _rv; + CFStringEncoding encoding; #ifndef CFStringGetMostCompatibleMacStringEncoding - PyMac_PRECHECK(CFStringGetMostCompatibleMacStringEncoding); + PyMac_PRECHECK(CFStringGetMostCompatibleMacStringEncoding); #endif - if (!PyArg_ParseTuple(_args, "l", - &encoding)) - return NULL; - _rv = CFStringGetMostCompatibleMacStringEncoding(encoding); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "l", + &encoding)) + return NULL; + _rv = CFStringGetMostCompatibleMacStringEncoding(encoding); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF___CFStringMakeConstantString(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFStringRef _rv; - char* cStr; + PyObject *_res = NULL; + CFStringRef _rv; + char* cStr; #ifndef __CFStringMakeConstantString - PyMac_PRECHECK(__CFStringMakeConstantString); + PyMac_PRECHECK(__CFStringMakeConstantString); #endif - if (!PyArg_ParseTuple(_args, "s", - &cStr)) - return NULL; - _rv = __CFStringMakeConstantString(cStr); - _res = Py_BuildValue("O&", - CFStringRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "s", + &cStr)) + return NULL; + _rv = __CFStringMakeConstantString(cStr); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; } static PyObject *CF_CFURLGetTypeID(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFTypeID _rv; + PyObject *_res = NULL; + CFTypeID _rv; #ifndef CFURLGetTypeID - PyMac_PRECHECK(CFURLGetTypeID); + PyMac_PRECHECK(CFURLGetTypeID); #endif - if (!PyArg_ParseTuple(_args, "")) - return NULL; - _rv = CFURLGetTypeID(); - _res = Py_BuildValue("l", - _rv); - return _res; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFURLGetTypeID(); + _res = Py_BuildValue("l", + _rv); + return _res; } static PyObject *CF_CFURLCreateWithBytes(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - unsigned char *URLBytes__in__; - long URLBytes__len__; - int URLBytes__in_len__; - CFStringEncoding encoding; - CFURLRef baseURL; + PyObject *_res = NULL; + CFURLRef _rv; + unsigned char *URLBytes__in__; + long URLBytes__len__; + int URLBytes__in_len__; + CFStringEncoding encoding; + CFURLRef baseURL; #ifndef CFURLCreateWithBytes - PyMac_PRECHECK(CFURLCreateWithBytes); + PyMac_PRECHECK(CFURLCreateWithBytes); #endif - if (!PyArg_ParseTuple(_args, "s#lO&", - &URLBytes__in__, &URLBytes__in_len__, - &encoding, - OptionalCFURLRefObj_Convert, &baseURL)) - return NULL; - URLBytes__len__ = URLBytes__in_len__; - _rv = CFURLCreateWithBytes((CFAllocatorRef)NULL, - URLBytes__in__, URLBytes__len__, - encoding, - baseURL); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "s#lO&", + &URLBytes__in__, &URLBytes__in_len__, + &encoding, + OptionalCFURLRefObj_Convert, &baseURL)) + return NULL; + URLBytes__len__ = URLBytes__in_len__; + _rv = CFURLCreateWithBytes((CFAllocatorRef)NULL, + URLBytes__in__, URLBytes__len__, + encoding, + baseURL); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CF_CFURLCreateFromFileSystemRepresentation(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - unsigned char *buffer__in__; - long buffer__len__; - int buffer__in_len__; - Boolean isDirectory; + PyObject *_res = NULL; + CFURLRef _rv; + unsigned char *buffer__in__; + long buffer__len__; + int buffer__in_len__; + Boolean isDirectory; #ifndef CFURLCreateFromFileSystemRepresentation - PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentation); + PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentation); #endif - if (!PyArg_ParseTuple(_args, "s#l", - &buffer__in__, &buffer__in_len__, - &isDirectory)) - return NULL; - buffer__len__ = buffer__in_len__; - _rv = CFURLCreateFromFileSystemRepresentation((CFAllocatorRef)NULL, - buffer__in__, buffer__len__, - isDirectory); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "s#l", + &buffer__in__, &buffer__in_len__, + &isDirectory)) + return NULL; + buffer__len__ = buffer__in_len__; + _rv = CFURLCreateFromFileSystemRepresentation((CFAllocatorRef)NULL, + buffer__in__, buffer__len__, + isDirectory); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CF_CFURLCreateFromFileSystemRepresentationRelativeToBase(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - unsigned char *buffer__in__; - long buffer__len__; - int buffer__in_len__; - Boolean isDirectory; - CFURLRef baseURL; + PyObject *_res = NULL; + CFURLRef _rv; + unsigned char *buffer__in__; + long buffer__len__; + int buffer__in_len__; + Boolean isDirectory; + CFURLRef baseURL; #ifndef CFURLCreateFromFileSystemRepresentationRelativeToBase - PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentationRelativeToBase); + PyMac_PRECHECK(CFURLCreateFromFileSystemRepresentationRelativeToBase); #endif - if (!PyArg_ParseTuple(_args, "s#lO&", - &buffer__in__, &buffer__in_len__, - &isDirectory, - OptionalCFURLRefObj_Convert, &baseURL)) - return NULL; - buffer__len__ = buffer__in_len__; - _rv = CFURLCreateFromFileSystemRepresentationRelativeToBase((CFAllocatorRef)NULL, - buffer__in__, buffer__len__, - isDirectory, - baseURL); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "s#lO&", + &buffer__in__, &buffer__in_len__, + &isDirectory, + OptionalCFURLRefObj_Convert, &baseURL)) + return NULL; + buffer__len__ = buffer__in_len__; + _rv = CFURLCreateFromFileSystemRepresentationRelativeToBase((CFAllocatorRef)NULL, + buffer__in__, buffer__len__, + isDirectory, + baseURL); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CF_CFURLCreateFromFSRef(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; - CFURLRef _rv; - FSRef fsRef; + PyObject *_res = NULL; + CFURLRef _rv; + FSRef fsRef; #ifndef CFURLCreateFromFSRef - PyMac_PRECHECK(CFURLCreateFromFSRef); + PyMac_PRECHECK(CFURLCreateFromFSRef); #endif - if (!PyArg_ParseTuple(_args, "O&", - PyMac_GetFSRef, &fsRef)) - return NULL; - _rv = CFURLCreateFromFSRef((CFAllocatorRef)NULL, - &fsRef); - _res = Py_BuildValue("O&", - CFURLRefObj_New, _rv); - return _res; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &fsRef)) + return NULL; + _rv = CFURLCreateFromFSRef((CFAllocatorRef)NULL, + &fsRef); + _res = Py_BuildValue("O&", + CFURLRefObj_New, _rv); + return _res; } static PyObject *CF_toCF(PyObject *_self, PyObject *_args) { - PyObject *_res = NULL; + PyObject *_res = NULL; - CFTypeRef rv; - CFTypeID typeid; + CFTypeRef rv; + CFTypeID typeid; - if (!PyArg_ParseTuple(_args, "O&", PyCF_Python2CF, &rv)) - return NULL; - typeid = CFGetTypeID(rv); + if (!PyArg_ParseTuple(_args, "O&", PyCF_Python2CF, &rv)) + return NULL; + typeid = CFGetTypeID(rv); - if (typeid == CFStringGetTypeID()) - return Py_BuildValue("O&", CFStringRefObj_New, rv); - if (typeid == CFArrayGetTypeID()) - return Py_BuildValue("O&", CFArrayRefObj_New, rv); - if (typeid == CFDictionaryGetTypeID()) - return Py_BuildValue("O&", CFDictionaryRefObj_New, rv); - if (typeid == CFURLGetTypeID()) - return Py_BuildValue("O&", CFURLRefObj_New, rv); + if (typeid == CFStringGetTypeID()) + return Py_BuildValue("O&", CFStringRefObj_New, rv); + if (typeid == CFArrayGetTypeID()) + return Py_BuildValue("O&", CFArrayRefObj_New, rv); + if (typeid == CFDictionaryGetTypeID()) + return Py_BuildValue("O&", CFDictionaryRefObj_New, rv); + if (typeid == CFURLGetTypeID()) + return Py_BuildValue("O&", CFURLRefObj_New, rv); - _res = Py_BuildValue("O&", CFTypeRefObj_New, rv); - return _res; + _res = Py_BuildValue("O&", CFTypeRefObj_New, rv); + return _res; } static PyMethodDef CF_methods[] = { - {"__CFRangeMake", (PyCFunction)CF___CFRangeMake, 1, - PyDoc_STR("(CFIndex loc, CFIndex len) -> (CFRange _rv)")}, - {"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1, - PyDoc_STR("() -> (CFTypeID _rv)")}, - {"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1, - PyDoc_STR("(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)")}, - {"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1, - PyDoc_STR("(CFTypeID type_id) -> (CFStringRef _rv)")}, - {"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1, - PyDoc_STR("() -> (CFTypeID _rv)")}, - {"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1, - PyDoc_STR("(CFIndex capacity) -> (CFMutableArrayRef _rv)")}, - {"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1, - PyDoc_STR("(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)")}, - {"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1, - PyDoc_STR("() -> (CFTypeID _rv)")}, - {"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1, - PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")}, - {"CFDataCreateWithBytesNoCopy", (PyCFunction)CF_CFDataCreateWithBytesNoCopy, 1, - PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")}, - {"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1, - PyDoc_STR("(CFIndex capacity) -> (CFMutableDataRef _rv)")}, - {"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1, - PyDoc_STR("(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)")}, - {"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1, - PyDoc_STR("() -> (CFTypeID _rv)")}, - {"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1, - PyDoc_STR("(CFIndex capacity) -> (CFMutableDictionaryRef _rv)")}, - {"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1, - PyDoc_STR("(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)")}, - {"CFPreferencesCopyAppValue", (PyCFunction)CF_CFPreferencesCopyAppValue, 1, - PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)")}, - {"CFPreferencesGetAppBooleanValue", (PyCFunction)CF_CFPreferencesGetAppBooleanValue, 1, - PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)")}, - {"CFPreferencesGetAppIntegerValue", (PyCFunction)CF_CFPreferencesGetAppIntegerValue, 1, - PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)")}, - {"CFPreferencesSetAppValue", (PyCFunction)CF_CFPreferencesSetAppValue, 1, - PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None")}, - {"CFPreferencesAddSuitePreferencesToApp", (PyCFunction)CF_CFPreferencesAddSuitePreferencesToApp, 1, - PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")}, - {"CFPreferencesRemoveSuitePreferencesFromApp", (PyCFunction)CF_CFPreferencesRemoveSuitePreferencesFromApp, 1, - PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")}, - {"CFPreferencesAppSynchronize", (PyCFunction)CF_CFPreferencesAppSynchronize, 1, - PyDoc_STR("(CFStringRef applicationID) -> (Boolean _rv)")}, - {"CFPreferencesCopyValue", (PyCFunction)CF_CFPreferencesCopyValue, 1, - PyDoc_STR("(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)")}, - {"CFPreferencesCopyMultiple", (PyCFunction)CF_CFPreferencesCopyMultiple, 1, - PyDoc_STR("(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)")}, - {"CFPreferencesSetValue", (PyCFunction)CF_CFPreferencesSetValue, 1, - PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")}, - {"CFPreferencesSetMultiple", (PyCFunction)CF_CFPreferencesSetMultiple, 1, - PyDoc_STR("(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")}, - {"CFPreferencesSynchronize", (PyCFunction)CF_CFPreferencesSynchronize, 1, - PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)")}, - {"CFPreferencesCopyApplicationList", (PyCFunction)CF_CFPreferencesCopyApplicationList, 1, - PyDoc_STR("(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")}, - {"CFPreferencesCopyKeyList", (PyCFunction)CF_CFPreferencesCopyKeyList, 1, - PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")}, - {"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1, - PyDoc_STR("() -> (CFTypeID _rv)")}, - {"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1, - PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, - {"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1, - PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, - {"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1, - PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")}, - {"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1, - PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, - {"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1, - PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, - {"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1, - PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")}, - {"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1, - PyDoc_STR("(CFIndex maxLength) -> (CFMutableStringRef _rv)")}, - {"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1, - PyDoc_STR("(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)")}, - {"CFStringCreateWithBytes", (PyCFunction)CF_CFStringCreateWithBytes, 1, - PyDoc_STR("(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)")}, - {"CFStringGetSystemEncoding", (PyCFunction)CF_CFStringGetSystemEncoding, 1, - PyDoc_STR("() -> (CFStringEncoding _rv)")}, - {"CFStringGetMaximumSizeForEncoding", (PyCFunction)CF_CFStringGetMaximumSizeForEncoding, 1, - PyDoc_STR("(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)")}, - {"CFStringIsEncodingAvailable", (PyCFunction)CF_CFStringIsEncodingAvailable, 1, - PyDoc_STR("(CFStringEncoding encoding) -> (Boolean _rv)")}, - {"CFStringGetNameOfEncoding", (PyCFunction)CF_CFStringGetNameOfEncoding, 1, - PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, - {"CFStringConvertEncodingToNSStringEncoding", (PyCFunction)CF_CFStringConvertEncodingToNSStringEncoding, 1, - PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")}, - {"CFStringConvertNSStringEncodingToEncoding", (PyCFunction)CF_CFStringConvertNSStringEncodingToEncoding, 1, - PyDoc_STR("(UInt32 encoding) -> (CFStringEncoding _rv)")}, - {"CFStringConvertEncodingToWindowsCodepage", (PyCFunction)CF_CFStringConvertEncodingToWindowsCodepage, 1, - PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")}, - {"CFStringConvertWindowsCodepageToEncoding", (PyCFunction)CF_CFStringConvertWindowsCodepageToEncoding, 1, - PyDoc_STR("(UInt32 codepage) -> (CFStringEncoding _rv)")}, - {"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1, - PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, - {"CFStringGetMostCompatibleMacStringEncoding", (PyCFunction)CF_CFStringGetMostCompatibleMacStringEncoding, 1, - PyDoc_STR("(CFStringEncoding encoding) -> (CFStringEncoding _rv)")}, - {"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1, - PyDoc_STR("(char* cStr) -> (CFStringRef _rv)")}, - {"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1, - PyDoc_STR("() -> (CFTypeID _rv)")}, - {"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1, - PyDoc_STR("(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)")}, - {"CFURLCreateFromFileSystemRepresentation", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentation, 1, - PyDoc_STR("(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)")}, - {"CFURLCreateFromFileSystemRepresentationRelativeToBase", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentationRelativeToBase, 1, - PyDoc_STR("(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")}, - {"CFURLCreateFromFSRef", (PyCFunction)CF_CFURLCreateFromFSRef, 1, - PyDoc_STR("(FSRef fsRef) -> (CFURLRef _rv)")}, - {"toCF", (PyCFunction)CF_toCF, 1, - PyDoc_STR("(python_object) -> (CF_object)")}, - {NULL, NULL, 0} + {"__CFRangeMake", (PyCFunction)CF___CFRangeMake, 1, + PyDoc_STR("(CFIndex loc, CFIndex len) -> (CFRange _rv)")}, + {"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1, + PyDoc_STR("(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)")}, + {"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1, + PyDoc_STR("(CFTypeID type_id) -> (CFStringRef _rv)")}, + {"CFArrayGetTypeID", (PyCFunction)CF_CFArrayGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFArrayCreateMutable", (PyCFunction)CF_CFArrayCreateMutable, 1, + PyDoc_STR("(CFIndex capacity) -> (CFMutableArrayRef _rv)")}, + {"CFArrayCreateMutableCopy", (PyCFunction)CF_CFArrayCreateMutableCopy, 1, + PyDoc_STR("(CFIndex capacity, CFArrayRef theArray) -> (CFMutableArrayRef _rv)")}, + {"CFDataGetTypeID", (PyCFunction)CF_CFDataGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFDataCreate", (PyCFunction)CF_CFDataCreate, 1, + PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")}, + {"CFDataCreateWithBytesNoCopy", (PyCFunction)CF_CFDataCreateWithBytesNoCopy, 1, + PyDoc_STR("(Buffer bytes) -> (CFDataRef _rv)")}, + {"CFDataCreateMutable", (PyCFunction)CF_CFDataCreateMutable, 1, + PyDoc_STR("(CFIndex capacity) -> (CFMutableDataRef _rv)")}, + {"CFDataCreateMutableCopy", (PyCFunction)CF_CFDataCreateMutableCopy, 1, + PyDoc_STR("(CFIndex capacity, CFDataRef theData) -> (CFMutableDataRef _rv)")}, + {"CFDictionaryGetTypeID", (PyCFunction)CF_CFDictionaryGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFDictionaryCreateMutable", (PyCFunction)CF_CFDictionaryCreateMutable, 1, + PyDoc_STR("(CFIndex capacity) -> (CFMutableDictionaryRef _rv)")}, + {"CFDictionaryCreateMutableCopy", (PyCFunction)CF_CFDictionaryCreateMutableCopy, 1, + PyDoc_STR("(CFIndex capacity, CFDictionaryRef theDict) -> (CFMutableDictionaryRef _rv)")}, + {"CFPreferencesCopyAppValue", (PyCFunction)CF_CFPreferencesCopyAppValue, 1, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFTypeRef _rv)")}, + {"CFPreferencesGetAppBooleanValue", (PyCFunction)CF_CFPreferencesGetAppBooleanValue, 1, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (Boolean _rv, Boolean keyExistsAndHasValidFormat)")}, + {"CFPreferencesGetAppIntegerValue", (PyCFunction)CF_CFPreferencesGetAppIntegerValue, 1, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID) -> (CFIndex _rv, Boolean keyExistsAndHasValidFormat)")}, + {"CFPreferencesSetAppValue", (PyCFunction)CF_CFPreferencesSetAppValue, 1, + PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID) -> None")}, + {"CFPreferencesAddSuitePreferencesToApp", (PyCFunction)CF_CFPreferencesAddSuitePreferencesToApp, 1, + PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")}, + {"CFPreferencesRemoveSuitePreferencesFromApp", (PyCFunction)CF_CFPreferencesRemoveSuitePreferencesFromApp, 1, + PyDoc_STR("(CFStringRef applicationID, CFStringRef suiteID) -> None")}, + {"CFPreferencesAppSynchronize", (PyCFunction)CF_CFPreferencesAppSynchronize, 1, + PyDoc_STR("(CFStringRef applicationID) -> (Boolean _rv)")}, + {"CFPreferencesCopyValue", (PyCFunction)CF_CFPreferencesCopyValue, 1, + PyDoc_STR("(CFStringRef key, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFTypeRef _rv)")}, + {"CFPreferencesCopyMultiple", (PyCFunction)CF_CFPreferencesCopyMultiple, 1, + PyDoc_STR("(CFArrayRef keysToFetch, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFDictionaryRef _rv)")}, + {"CFPreferencesSetValue", (PyCFunction)CF_CFPreferencesSetValue, 1, + PyDoc_STR("(CFStringRef key, CFTypeRef value, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")}, + {"CFPreferencesSetMultiple", (PyCFunction)CF_CFPreferencesSetMultiple, 1, + PyDoc_STR("(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> None")}, + {"CFPreferencesSynchronize", (PyCFunction)CF_CFPreferencesSynchronize, 1, + PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (Boolean _rv)")}, + {"CFPreferencesCopyApplicationList", (PyCFunction)CF_CFPreferencesCopyApplicationList, 1, + PyDoc_STR("(CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")}, + {"CFPreferencesCopyKeyList", (PyCFunction)CF_CFPreferencesCopyKeyList, 1, + PyDoc_STR("(CFStringRef applicationID, CFStringRef userName, CFStringRef hostName) -> (CFArrayRef _rv)")}, + {"CFStringGetTypeID", (PyCFunction)CF_CFStringGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFStringCreateWithPascalString", (PyCFunction)CF_CFStringCreateWithPascalString, 1, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringCreateWithCString", (PyCFunction)CF_CFStringCreateWithCString, 1, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringCreateWithCharacters", (PyCFunction)CF_CFStringCreateWithCharacters, 1, + PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")}, + {"CFStringCreateWithPascalStringNoCopy", (PyCFunction)CF_CFStringCreateWithPascalStringNoCopy, 1, + PyDoc_STR("(Str255 pStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringCreateWithCStringNoCopy", (PyCFunction)CF_CFStringCreateWithCStringNoCopy, 1, + PyDoc_STR("(char* cStr, CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringCreateWithCharactersNoCopy", (PyCFunction)CF_CFStringCreateWithCharactersNoCopy, 1, + PyDoc_STR("(Buffer chars) -> (CFStringRef _rv)")}, + {"CFStringCreateMutable", (PyCFunction)CF_CFStringCreateMutable, 1, + PyDoc_STR("(CFIndex maxLength) -> (CFMutableStringRef _rv)")}, + {"CFStringCreateMutableCopy", (PyCFunction)CF_CFStringCreateMutableCopy, 1, + PyDoc_STR("(CFIndex maxLength, CFStringRef theString) -> (CFMutableStringRef _rv)")}, + {"CFStringCreateWithBytes", (PyCFunction)CF_CFStringCreateWithBytes, 1, + PyDoc_STR("(Buffer bytes, CFStringEncoding encoding, Boolean isExternalRepresentation) -> (CFStringRef _rv)")}, + {"CFStringGetSystemEncoding", (PyCFunction)CF_CFStringGetSystemEncoding, 1, + PyDoc_STR("() -> (CFStringEncoding _rv)")}, + {"CFStringGetMaximumSizeForEncoding", (PyCFunction)CF_CFStringGetMaximumSizeForEncoding, 1, + PyDoc_STR("(CFIndex length, CFStringEncoding encoding) -> (CFIndex _rv)")}, + {"CFStringIsEncodingAvailable", (PyCFunction)CF_CFStringIsEncodingAvailable, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (Boolean _rv)")}, + {"CFStringGetNameOfEncoding", (PyCFunction)CF_CFStringGetNameOfEncoding, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringConvertEncodingToNSStringEncoding", (PyCFunction)CF_CFStringConvertEncodingToNSStringEncoding, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")}, + {"CFStringConvertNSStringEncodingToEncoding", (PyCFunction)CF_CFStringConvertNSStringEncodingToEncoding, 1, + PyDoc_STR("(UInt32 encoding) -> (CFStringEncoding _rv)")}, + {"CFStringConvertEncodingToWindowsCodepage", (PyCFunction)CF_CFStringConvertEncodingToWindowsCodepage, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (UInt32 _rv)")}, + {"CFStringConvertWindowsCodepageToEncoding", (PyCFunction)CF_CFStringConvertWindowsCodepageToEncoding, 1, + PyDoc_STR("(UInt32 codepage) -> (CFStringEncoding _rv)")}, + {"CFStringConvertEncodingToIANACharSetName", (PyCFunction)CF_CFStringConvertEncodingToIANACharSetName, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringRef _rv)")}, + {"CFStringGetMostCompatibleMacStringEncoding", (PyCFunction)CF_CFStringGetMostCompatibleMacStringEncoding, 1, + PyDoc_STR("(CFStringEncoding encoding) -> (CFStringEncoding _rv)")}, + {"__CFStringMakeConstantString", (PyCFunction)CF___CFStringMakeConstantString, 1, + PyDoc_STR("(char* cStr) -> (CFStringRef _rv)")}, + {"CFURLGetTypeID", (PyCFunction)CF_CFURLGetTypeID, 1, + PyDoc_STR("() -> (CFTypeID _rv)")}, + {"CFURLCreateWithBytes", (PyCFunction)CF_CFURLCreateWithBytes, 1, + PyDoc_STR("(Buffer URLBytes, CFStringEncoding encoding, CFURLRef baseURL) -> (CFURLRef _rv)")}, + {"CFURLCreateFromFileSystemRepresentation", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentation, 1, + PyDoc_STR("(Buffer buffer, Boolean isDirectory) -> (CFURLRef _rv)")}, + {"CFURLCreateFromFileSystemRepresentationRelativeToBase", (PyCFunction)CF_CFURLCreateFromFileSystemRepresentationRelativeToBase, 1, + PyDoc_STR("(Buffer buffer, Boolean isDirectory, CFURLRef baseURL) -> (CFURLRef _rv)")}, + {"CFURLCreateFromFSRef", (PyCFunction)CF_CFURLCreateFromFSRef, 1, + PyDoc_STR("(FSRef fsRef) -> (CFURLRef _rv)")}, + {"toCF", (PyCFunction)CF_toCF, 1, + PyDoc_STR("(python_object) -> (CF_object)")}, + {NULL, NULL, 0} }; @@ -4828,165 +4828,165 @@ static PyMethodDef CF_methods[] = { /* Routines to convert any CF type to/from the corresponding CFxxxObj */ PyObject *CFObj_New(CFTypeRef itself) { - if (itself == NULL) - { - PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); - return NULL; - } - if (CFGetTypeID(itself) == CFArrayGetTypeID()) return CFArrayRefObj_New((CFArrayRef)itself); - if (CFGetTypeID(itself) == CFDictionaryGetTypeID()) return CFDictionaryRefObj_New((CFDictionaryRef)itself); - if (CFGetTypeID(itself) == CFDataGetTypeID()) return CFDataRefObj_New((CFDataRef)itself); - if (CFGetTypeID(itself) == CFStringGetTypeID()) return CFStringRefObj_New((CFStringRef)itself); - if (CFGetTypeID(itself) == CFURLGetTypeID()) return CFURLRefObj_New((CFURLRef)itself); - /* XXXX Or should we use PyCF_CF2Python here?? */ - return CFTypeRefObj_New(itself); + if (itself == NULL) + { + PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL"); + return NULL; + } + if (CFGetTypeID(itself) == CFArrayGetTypeID()) return CFArrayRefObj_New((CFArrayRef)itself); + if (CFGetTypeID(itself) == CFDictionaryGetTypeID()) return CFDictionaryRefObj_New((CFDictionaryRef)itself); + if (CFGetTypeID(itself) == CFDataGetTypeID()) return CFDataRefObj_New((CFDataRef)itself); + if (CFGetTypeID(itself) == CFStringGetTypeID()) return CFStringRefObj_New((CFStringRef)itself); + if (CFGetTypeID(itself) == CFURLGetTypeID()) return CFURLRefObj_New((CFURLRef)itself); + /* XXXX Or should we use PyCF_CF2Python here?? */ + return CFTypeRefObj_New(itself); } int CFObj_Convert(PyObject *v, CFTypeRef *p_itself) { - if (v == Py_None) { *p_itself = NULL; return 1; } - /* Check for other CF objects here */ - - if (!CFTypeRefObj_Check(v) && - !CFArrayRefObj_Check(v) && - !CFMutableArrayRefObj_Check(v) && - !CFDictionaryRefObj_Check(v) && - !CFMutableDictionaryRefObj_Check(v) && - !CFDataRefObj_Check(v) && - !CFMutableDataRefObj_Check(v) && - !CFStringRefObj_Check(v) && - !CFMutableStringRefObj_Check(v) && - !CFURLRefObj_Check(v) ) - { - /* XXXX Or should we use PyCF_Python2CF here?? */ - PyErr_SetString(PyExc_TypeError, "CF object required"); - return 0; - } - *p_itself = ((CFTypeRefObject *)v)->ob_itself; - return 1; + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + + if (!CFTypeRefObj_Check(v) && + !CFArrayRefObj_Check(v) && + !CFMutableArrayRefObj_Check(v) && + !CFDictionaryRefObj_Check(v) && + !CFMutableDictionaryRefObj_Check(v) && + !CFDataRefObj_Check(v) && + !CFMutableDataRefObj_Check(v) && + !CFStringRefObj_Check(v) && + !CFMutableStringRefObj_Check(v) && + !CFURLRefObj_Check(v) ) + { + /* XXXX Or should we use PyCF_Python2CF here?? */ + PyErr_SetString(PyExc_TypeError, "CF object required"); + return 0; + } + *p_itself = ((CFTypeRefObject *)v)->ob_itself; + return 1; } void init_CF(void) { - PyObject *m; - PyObject *d; - - - - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFTypeRef, CFObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFTypeRef, CFObj_Convert); - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFTypeRef, CFTypeRefObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFTypeRef, CFTypeRefObj_Convert); - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFStringRef, CFStringRefObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFStringRef, CFStringRefObj_Convert); - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableStringRef, CFMutableStringRefObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableStringRef, CFMutableStringRefObj_Convert); - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFArrayRef, CFArrayRefObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFArrayRef, CFArrayRefObj_Convert); - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableArrayRef, CFMutableArrayRefObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableArrayRef, CFMutableArrayRefObj_Convert); - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFDictionaryRef, CFDictionaryRefObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFDictionaryRef, CFDictionaryRefObj_Convert); - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableDictionaryRef, CFMutableDictionaryRefObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableDictionaryRef, CFMutableDictionaryRefObj_Convert); - PyMac_INIT_TOOLBOX_OBJECT_NEW(CFURLRef, CFURLRefObj_New); - PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFURLRef, CFURLRefObj_Convert); - - - m = Py_InitModule("_CF", CF_methods); - d = PyModule_GetDict(m); - CF_Error = PyMac_GetOSErrException(); - if (CF_Error == NULL || - PyDict_SetItemString(d, "Error", CF_Error) != 0) - return; - CFTypeRef_Type.ob_type = &PyType_Type; - if (PyType_Ready(&CFTypeRef_Type) < 0) return; - Py_INCREF(&CFTypeRef_Type); - PyModule_AddObject(m, "CFTypeRef", (PyObject *)&CFTypeRef_Type); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - 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); - /* Backward-compatible name */ - Py_INCREF(&CFURLRef_Type); - PyModule_AddObject(m, "CFURLRefType", (PyObject *)&CFURLRef_Type); + PyObject *m; + PyObject *d; + + + + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFTypeRef, CFObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFTypeRef, CFObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFTypeRef, CFTypeRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFTypeRef, CFTypeRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFStringRef, CFStringRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFStringRef, CFStringRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableStringRef, CFMutableStringRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableStringRef, CFMutableStringRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFArrayRef, CFArrayRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFArrayRef, CFArrayRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableArrayRef, CFMutableArrayRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableArrayRef, CFMutableArrayRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFDictionaryRef, CFDictionaryRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFDictionaryRef, CFDictionaryRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFMutableDictionaryRef, CFMutableDictionaryRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFMutableDictionaryRef, CFMutableDictionaryRefObj_Convert); + PyMac_INIT_TOOLBOX_OBJECT_NEW(CFURLRef, CFURLRefObj_New); + PyMac_INIT_TOOLBOX_OBJECT_CONVERT(CFURLRef, CFURLRefObj_Convert); + + + m = Py_InitModule("_CF", CF_methods); + d = PyModule_GetDict(m); + CF_Error = PyMac_GetOSErrException(); + if (CF_Error == NULL || + PyDict_SetItemString(d, "Error", CF_Error) != 0) + return; + CFTypeRef_Type.ob_type = &PyType_Type; + if (PyType_Ready(&CFTypeRef_Type) < 0) return; + Py_INCREF(&CFTypeRef_Type); + PyModule_AddObject(m, "CFTypeRef", (PyObject *)&CFTypeRef_Type); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + 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); + /* Backward-compatible name */ + Py_INCREF(&CFURLRef_Type); + PyModule_AddObject(m, "CFURLRefType", (PyObject *)&CFURLRef_Type); #define _STRINGCONST(name) PyModule_AddObject(m, #name, CFStringRefObj_New(name)) - _STRINGCONST(kCFPreferencesAnyApplication); - _STRINGCONST(kCFPreferencesCurrentApplication); - _STRINGCONST(kCFPreferencesAnyHost); - _STRINGCONST(kCFPreferencesCurrentHost); - _STRINGCONST(kCFPreferencesAnyUser); - _STRINGCONST(kCFPreferencesCurrentUser); + _STRINGCONST(kCFPreferencesAnyApplication); + _STRINGCONST(kCFPreferencesCurrentApplication); + _STRINGCONST(kCFPreferencesAnyHost); + _STRINGCONST(kCFPreferencesCurrentHost); + _STRINGCONST(kCFPreferencesAnyUser); + _STRINGCONST(kCFPreferencesCurrentUser); |