1 

     2 /* =========================== Module _CF =========================== */

     3 

     4 #include "Python.h"

     5 

     6 

     7 

     8 #include "pymactoolbox.h"

     9 

    10 /* Macro to test whether a weak-loaded CFM function exists */

    11 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\

    12         PyErr_SetString(PyExc_NotImplementedError, \

    13         "Not available in this shared library/OS version"); \

    14         return NULL; \

    15     }} while(0)

    16 

    17 

    18 #include <CoreServices/CoreServices.h>

    19 

    20 #include "pycfbridge.h"

    21 

    22 #ifdef USE_TOOLBOX_OBJECT_GLUE

    23 extern PyObject *_CFObj_New(CFTypeRef);

    24 extern int _CFObj_Convert(PyObject *, CFTypeRef *);

    25 #define CFObj_New _CFObj_New

    26 #define CFObj_Convert _CFObj_Convert

    27 

    28 extern PyObject *_CFTypeRefObj_New(CFTypeRef);

    29 extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *);

    30 #define CFTypeRefObj_New _CFTypeRefObj_New

    31 #define CFTypeRefObj_Convert _CFTypeRefObj_Convert

    32 

    33 extern PyObject *_CFStringRefObj_New(CFStringRef);

    34 extern int _CFStringRefObj_Convert(PyObject *, CFStringRef *);

    35 #define CFStringRefObj_New _CFStringRefObj_New

    36 #define CFStringRefObj_Convert _CFStringRefObj_Convert

    37 

    38 extern PyObject *_CFMutableStringRefObj_New(CFMutableStringRef);

    39 extern int _CFMutableStringRefObj_Convert(PyObject *, CFMutableStringRef *);

    40 #define CFMutableStringRefObj_New _CFMutableStringRefObj_New

    41 #define CFMutableStringRefObj_Convert _CFMutableStringRefObj_Convert

    42 

    43 extern PyObject *_CFArrayRefObj_New(CFArrayRef);

    44 extern int _CFArrayRefObj_Convert(PyObject *, CFArrayRef *);

    45 #define CFArrayRefObj_New _CFArrayRefObj_New

    46 #define CFArrayRefObj_Convert _CFArrayRefObj_Convert

    47 

    48 extern PyObject *_CFMutableArrayRefObj_New(CFMutableArrayRef);

    49 extern int _CFMutableArrayRefObj_Convert(PyObject *, CFMutableArrayRef *);

    50 #define CFMutableArrayRefObj_New _CFMutableArrayRefObj_New

    51 #define CFMutableArrayRefObj_Convert _CFMutableArrayRefObj_Convert

    52 

    53 extern PyObject *_CFDataRefObj_New(CFDataRef);

    54 extern int _CFDataRefObj_Convert(PyObject *, CFDataRef *);

    55 #define CFDataRefObj_New _CFDataRefObj_New

    56 #define CFDataRefObj_Convert _CFDataRefObj_Convert

    57 

    58 extern PyObject *_CFMutableDataRefObj_New(CFMutableDataRef);

    59 extern int _CFMutableDataRefObj_Convert(PyObject *, CFMutableDataRef *);

    60 #define CFMutableDataRefObj_New _CFMutableDataRefObj_New

    61 #define CFMutableDataRefObj_Convert _CFMutableDataRefObj_Convert

    62 

    63 extern PyObject *_CFDictionaryRefObj_New(CFDictionaryRef);

    64 extern int _CFDictionaryRefObj_Convert(PyObject *, CFDictionaryRef *);

    65 #define CFDictionaryRefObj_New _CFDictionaryRefObj_New

    66 #define CFDictionaryRefObj_Convert _CFDictionaryRefObj_Convert

    67 

    68 extern PyObject *_CFMutableDictionaryRefObj_New(CFMutableDictionaryRef);

    69 extern int _CFMutableDictionaryRefObj_Convert(PyObject *, CFMutableDictionaryRef *);

    70 #define CFMutableDictionaryRefObj_New _CFMutableDictionaryRefObj_New

    71 #define CFMutableDictionaryRefObj_Convert _CFMutableDictionaryRefObj_Convert

    72 

    73 extern PyObject *_CFURLRefObj_New(CFURLRef);

    74 extern int _CFURLRefObj_Convert(PyObject *, CFURLRef *);

    75 extern int _OptionalCFURLRefObj_Convert(PyObject *, CFURLRef *);

    76 #define CFURLRefObj_New _CFURLRefObj_New

    77 #define CFURLRefObj_Convert _CFURLRefObj_Convert

    78 #define OptionalCFURLRefObj_Convert _OptionalCFURLRefObj_Convert

    79 #endif

    80 

    81 /*

    82 ** Parse/generate CFRange records

    83 */

    84 PyObject *CFRange_New(CFRange *itself)

    85 {

    86 

    87         return Py_BuildValue("ll", (long)itself->location, (long)itself->length);

    88 }

    89 

    90 int

    91 CFRange_Convert(PyObject *v, CFRange *p_itself)

    92 {

    93         long location, length;

    94 

    95         if( !PyArg_ParseTuple(v, "ll", &location, &length) )

    96                 return 0;

    97         p_itself->location = (CFIndex)location;

    98         p_itself->length = (CFIndex)length;

    99         return 1;

   100 }

   101 

   102 /* Optional CFURL argument or None (passed as NULL) */

   103 int

   104 OptionalCFURLRefObj_Convert(PyObject *v, CFURLRef *p_itself)

   105 {

   106     if ( v == Py_None ) {

   107         p_itself = NULL;

   108         return 1;

   109     }

   110     return CFURLRefObj_Convert(v, p_itself);

   111 }

   112 

   113 static PyObject *CF_Error;

   114 

   115 /* --------------------- Object type CFTypeRef ---------------------- */

   116 

   117 PyTypeObject CFTypeRef_Type;

   118 

   119 #define CFTypeRefObj_Check(x) ((x)->ob_type == &CFTypeRef_Type || PyObject_TypeCheck((x), &CFTypeRef_Type))

   120 

   121 typedef struct CFTypeRefObject {

   122 	PyObject_HEAD

   123 	CFTypeRef ob_itself;

   124 	void (*ob_freeit)(CFTypeRef ptr);

   125 } CFTypeRefObject;

   126 

   127 PyObject *CFTypeRefObj_New(CFTypeRef itself)

   128 {

   129 	CFTypeRefObject *it;

   130 	if (itself == NULL)

   131 	{

   132 		PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");

   133 		return NULL;

   134 	}

   135 	it = PyObject_NEW(CFTypeRefObject, &CFTypeRef_Type);

   136 	if (it == NULL) return NULL;

   137 	it->ob_itself = itself;

   138 	it->ob_freeit = CFRelease;

   139 	return (PyObject *)it;

   140 }

   141 

   142 int CFTypeRefObj_Convert(PyObject *v, CFTypeRef *p_itself)

   143 {

   144 

   145 	if (v == Py_None) { *p_itself = NULL; return 1; }

   146 	/* Check for other CF objects here */

   147 

   148 	if (!CFTypeRefObj_Check(v))

   149 	{

   150 		PyErr_SetString(PyExc_TypeError, "CFTypeRef required");

   151 		return 0;

   152 	}

   153 	*p_itself = ((CFTypeRefObject *)v)->ob_itself;

   154 	return 1;

   155 }

   156 

   157 static void CFTypeRefObj_dealloc(CFTypeRefObject *self)

   158 {

   159 	if (self->ob_freeit && self->ob_itself)

   160 	{

   161 		self->ob_freeit((CFTypeRef)self->ob_itself);

   162 		self->ob_itself = NULL;

   163 	}

   164 	self->ob_type->tp_free((PyObject *)self);

   165 }

   166 

   167 static PyObject *CFTypeRefObj_CFGetTypeID(CFTypeRefObject *_self, PyObject *_args)

   168 {

   169 	PyObject *_res = NULL;

   170 	CFTypeID _rv;

   171 #ifndef CFGetTypeID

   172 	PyMac_PRECHECK(CFGetTypeID);

   173 #endif

   174 	if (!PyArg_ParseTuple(_args, ""))

   175 		return NULL;

   176 	_rv = CFGetTypeID(_self->ob_itself);

   177 	_res = Py_BuildValue("l",

   178 	                     _rv);

   179 	return _res;

   180 }

   181 

   182 static PyObject *CFTypeRefObj_CFRetain(CFTypeRefObject *_self, PyObject *_args)

   183 {

   184 	PyObject *_res = NULL;

   185 	CFTypeRef _rv;

   186 #ifndef CFRetain

   187 	PyMac_PRECHECK(CFRetain);

   188 #endif

   189 	if (!PyArg_ParseTuple(_args, ""))

   190 		return NULL;

   191 	_rv = CFRetain(_self->ob_itself);

   192 	_res = Py_BuildValue("O&",

   193 	                     CFTypeRefObj_New, _rv);

   194 	return _res;

   195 }

   196 

   197 static PyObject *CFTypeRefObj_CFRelease(CFTypeRefObject *_self, PyObject *_args)

   198 {

   199 	PyObject *_res = NULL;

   200 #ifndef CFRelease

   201 	PyMac_PRECHECK(CFRelease);

   202 #endif

   203 	if (!PyArg_ParseTuple(_args, ""))

   204 		return NULL;

   205 	CFRelease(_self->ob_itself);

   206 	Py_INCREF(Py_None);

   207 	_res = Py_None;

   208 	return _res;

   209 }

   210 

   211 static PyObject *CFTypeRefObj_CFGetRetainCount(CFTypeRefObject *_self, PyObject *_args)

   212 {

   213 	PyObject *_res = NULL;

   214 	CFIndex _rv;

   215 #ifndef CFGetRetainCount

   216 	PyMac_PRECHECK(CFGetRetainCount);

   217 #endif

   218 	if (!PyArg_ParseTuple(_args, ""))

   219 		return NULL;

   220 	_rv = CFGetRetainCount(_self->ob_itself);

   221 	_res = Py_BuildValue("l",

   222 	                     _rv);

   223 	return _res;

   224 }

   225 

   226 static PyObject *CFTypeRefObj_CFEqual(CFTypeRefObject *_self, PyObject *_args)

   227 {

   228 	PyObject *_res = NULL;

   229 	Boolean _rv;

   230 	CFTypeRef cf2;

   231 #ifndef CFEqual

   232 	PyMac_PRECHECK(CFEqual);

   233 #endif

   234 	if (!PyArg_ParseTuple(_args, "O&",

   235 	                      CFTypeRefObj_Convert, &cf2))

   236 		return NULL;

   237 	_rv = CFEqual(_self->ob_itself,

   238 	              cf2);

   239 	_res = Py_BuildValue("l",

   240 	                     _rv);

   241 	return _res;

   242 }

   243 

   244 static PyObject *CFTypeRefObj_CFHash(CFTypeRefObject *_self, PyObject *_args)

   245 {

   246 	PyObject *_res = NULL;

   247 	CFHashCode _rv;

   248 #ifndef CFHash

   249 	PyMac_PRECHECK(CFHash);

   250 #endif

   251 	if (!PyArg_ParseTuple(_args, ""))

   252 		return NULL;

   253 	_rv = CFHash(_self->ob_itself);

   254 	_res = Py_BuildValue("l",

   255 	                     _rv);

   256 	return _res;

   257 }

   258 

   259 static PyObject *CFTypeRefObj_CFCopyDescription(CFTypeRefObject *_self, PyObject *_args)

   260 {

   261 	PyObject *_res = NULL;

   262 	CFStringRef _rv;

   263 #ifndef CFCopyDescription

   264 	PyMac_PRECHECK(CFCopyDescription);

   265 #endif

   266 	if (!PyArg_ParseTuple(_args, ""))

   267 		return NULL;

   268 	_rv = CFCopyDescription(_self->ob_itself);

   269 	_res = Py_BuildValue("O&",

   270 	                     CFStringRefObj_New, _rv);

   271 	return _res;

   272 }

   273 

   274 static PyObject *CFTypeRefObj_CFPropertyListCreateXMLData(CFTypeRefObject *_self, PyObject *_args)

   275 {

   276 	PyObject *_res = NULL;

   277 	CFDataRef _rv;

   278 	if (!PyArg_ParseTuple(_args, ""))

   279 		return NULL;

   280 	_rv = CFPropertyListCreateXMLData((CFAllocatorRef)NULL,

   281 	                                  _self->ob_itself);

   282 	_res = Py_BuildValue("O&",

   283 	                     CFDataRefObj_New, _rv);

   284 	return _res;

   285 }

   286 

   287 static PyObject *CFTypeRefObj_CFPropertyListCreateDeepCopy(CFTypeRefObject *_self, PyObject *_args)

   288 {

   289 	PyObject *_res = NULL;

   290 	CFTypeRef _rv;

   291 	CFOptionFlags mutabilityOption;

   292 	if (!PyArg_ParseTuple(_args, "l",

   293 	                      &mutabilityOption))

   294 		return NULL;

   295 	_rv = CFPropertyListCreateDeepCopy((CFAllocatorRef)NULL,

   296 	                                   _self->ob_itself,

   297 	                                   mutabilityOption);

   298 	_res = Py_BuildValue("O&",

   299 	                     CFTypeRefObj_New, _rv);

   300 	return _res;

   301 }

   302 

   303 static PyObject *CFTypeRefObj_CFShow(CFTypeRefObject *_self, PyObject *_args)

   304 {

   305 	PyObject *_res = NULL;

   306 #ifndef CFShow

   307 	PyMac_PRECHECK(CFShow);

   308 #endif

   309 	if (!PyArg_ParseTuple(_args, ""))

   310 		return NULL;

   311 	CFShow(_self->ob_itself);

   312 	Py_INCREF(Py_None);

   313 	_res = Py_None;

   314 	return _res;

   315 }

   316 

   317 static PyObject *CFTypeRefObj_CFPropertyListCreateFromXMLData(CFTypeRefObject *_self, PyObject *_args)

   318 {

   319 	PyObject *_res = NULL;

   320 

   321 	CFTypeRef _rv;

   322 	CFOptionFlags mutabilityOption;

   323 	CFStringRef errorString;

   324 	if (!PyArg_ParseTuple(_args, "l",

   325 	                      &mutabilityOption))

   326 	        return NULL;

   327 	_rv = CFPropertyListCreateFromXMLData((CFAllocatorRef)NULL,

   328 	                                      _self->ob_itself,

   329 	                                      mutabilityOption,

   330 	                                      &errorString);

   331 	if (errorString)

   332 	        CFRelease(errorString);

   333 	if (_rv == NULL) {

   334 	        PyErr_SetString(PyExc_RuntimeError, "Parse error in XML data");

   335 	        return NULL;

   336 	}

   337 	_res = Py_BuildValue("O&",

   338 	                     CFTypeRefObj_New, _rv);

   339 	return _res;

   340 

   341 }

   342 

   343 static PyObject *CFTypeRefObj_toPython(CFTypeRefObject *_self, PyObject *_args)

   344 {

   345 	PyObject *_res = NULL;

   346 

   347 	_res = PyCF_CF2Python(_self->ob_itself);

   348 	return _res;

   349 

   350 }

   351 

   352 static PyMethodDef CFTypeRefObj_methods[] = {

   353 	{"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1,

   354 	 PyDoc_STR("() -> (CFTypeID _rv)")},

   355 	{"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1,

   356 	 PyDoc_STR("() -> (CFTypeRef _rv)")},

   357 	{"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1,

   358 	 PyDoc_STR("() -> None")},

   359 	{"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1,

   360 	 PyDoc_STR("() -> (CFIndex _rv)")},

   361 	{"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1,

   362 	 PyDoc_STR("(CFTypeRef cf2) -> (Boolean _rv)")},

   363 	{"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1,

   364 	 PyDoc_STR("() -> (CFHashCode _rv)")},

   365 	{"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1,

   366 	 PyDoc_STR("() -> (CFStringRef _rv)")},

   367 	{"CFPropertyListCreateXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateXMLData, 1,

   368 	 PyDoc_STR("() -> (CFDataRef _rv)")},

   369 	{"CFPropertyListCreateDeepCopy", (PyCFunction)CFTypeRefObj_CFPropertyListCreateDeepCopy, 1,

   370 	 PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRef _rv)")},

   371 	{"CFShow", (PyCFunction)CFTypeRefObj_CFShow, 1,

   372 	 PyDoc_STR("() -> None")},

   373 	{"CFPropertyListCreateFromXMLData", (PyCFunction)CFTypeRefObj_CFPropertyListCreateFromXMLData, 1,

   374 	 PyDoc_STR("(CFOptionFlags mutabilityOption) -> (CFTypeRefObj)")},

   375 	{"toPython", (PyCFunction)CFTypeRefObj_toPython, 1,

   376 	 PyDoc_STR("() -> (python_object)")},

   377 	{NULL, NULL, 0}

   378 };

   379 

   380 #define CFTypeRefObj_getsetlist NULL

   381 

   382 

   383 static int CFTypeRefObj_compare(CFTypeRefObject *self, CFTypeRefObject *other)

   384 {

   385 	/* XXXX Or should we use CFEqual?? */

   386 	if ( self->ob_itself > other->ob_itself ) return 1;

   387 	if ( self->ob_itself < other->ob_itself ) return -1;

   388 	return 0;

   389 }

   390 

   391 static PyObject * CFTypeRefObj_repr(CFTypeRefObject *self)

   392 {

   393 	char buf[100];

   394 	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);

   395 	return PyString_FromString(buf);

   396 }

   397 

   398 static int CFTypeRefObj_hash(CFTypeRefObject *self)

   399 {

   400 	/* XXXX Or should we use CFHash?? */

   401 	return (int)self->ob_itself;

   402 }

   403 static int CFTypeRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

   404 {

   405 	CFTypeRef itself;

   406 	char *kw[] = {"itself", 0};

   407 

   408 	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))

   409 	{

   410 		((CFTypeRefObject *)_self)->ob_itself = itself;

   411 		return 0;

   412 	}

   413 	return -1;

   414 }

   415 

   416 #define CFTypeRefObj_tp_alloc PyType_GenericAlloc

   417 

   418 static PyObject *CFTypeRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   419 {

   420 	PyObject *self;

   421 	if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;

   422 	((CFTypeRefObject *)self)->ob_itself = NULL;

   423 	((CFTypeRefObject *)self)->ob_freeit = CFRelease;

   424 	return self;

   425 }

   426 

   427 #define CFTypeRefObj_tp_free PyObject_Del

   428 

   429 

   430 PyTypeObject CFTypeRef_Type = {

   431 	PyObject_HEAD_INIT(NULL)

   432 	0, /*ob_size*/

   433 	"_CF.CFTypeRef", /*tp_name*/

   434 	sizeof(CFTypeRefObject), /*tp_basicsize*/

   435 	0, /*tp_itemsize*/

   436 	/* methods */

   437 	(destructor) CFTypeRefObj_dealloc, /*tp_dealloc*/

   438 	0, /*tp_print*/

   439 	(getattrfunc)0, /*tp_getattr*/

   440 	(setattrfunc)0, /*tp_setattr*/

   441 	(cmpfunc) CFTypeRefObj_compare, /*tp_compare*/

   442 	(reprfunc) CFTypeRefObj_repr, /*tp_repr*/

   443 	(PyNumberMethods *)0, /* tp_as_number */

   444 	(PySequenceMethods *)0, /* tp_as_sequence */

   445 	(PyMappingMethods *)0, /* tp_as_mapping */

   446 	(hashfunc) CFTypeRefObj_hash, /*tp_hash*/

   447 	0, /*tp_call*/

   448 	0, /*tp_str*/

   449 	PyObject_GenericGetAttr, /*tp_getattro*/

   450 	PyObject_GenericSetAttr, /*tp_setattro */

   451 	0, /*tp_as_buffer*/

   452 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   453 	0, /*tp_doc*/

   454 	0, /*tp_traverse*/

   455 	0, /*tp_clear*/

   456 	0, /*tp_richcompare*/

   457 	0, /*tp_weaklistoffset*/

   458 	0, /*tp_iter*/

   459 	0, /*tp_iternext*/

   460 	CFTypeRefObj_methods, /* tp_methods */

   461 	0, /*tp_members*/

   462 	CFTypeRefObj_getsetlist, /*tp_getset*/

   463 	0, /*tp_base*/

   464 	0, /*tp_dict*/

   465 	0, /*tp_descr_get*/

   466 	0, /*tp_descr_set*/

   467 	0, /*tp_dictoffset*/

   468 	CFTypeRefObj_tp_init, /* tp_init */

   469 	CFTypeRefObj_tp_alloc, /* tp_alloc */

   470 	CFTypeRefObj_tp_new, /* tp_new */

   471 	CFTypeRefObj_tp_free, /* tp_free */

   472 };

   473 

   474 /* ------------------- End object type CFTypeRef -------------------- */

   475 

   476 

   477 /* --------------------- Object type CFArrayRef --------------------- */

   478 

   479 PyTypeObject CFArrayRef_Type;

   480 

   481 #define CFArrayRefObj_Check(x) ((x)->ob_type == &CFArrayRef_Type || PyObject_TypeCheck((x), &CFArrayRef_Type))

   482 

   483 typedef struct CFArrayRefObject {

   484 	PyObject_HEAD

   485 	CFArrayRef ob_itself;

   486 	void (*ob_freeit)(CFTypeRef ptr);

   487 } CFArrayRefObject;

   488 

   489 PyObject *CFArrayRefObj_New(CFArrayRef itself)

   490 {

   491 	CFArrayRefObject *it;

   492 	if (itself == NULL)

   493 	{

   494 		PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");

   495 		return NULL;

   496 	}

   497 	it = PyObject_NEW(CFArrayRefObject, &CFArrayRef_Type);

   498 	if (it == NULL) return NULL;

   499 	/* XXXX Should we tp_init or tp_new our basetype? */

   500 	it->ob_itself = itself;

   501 	it->ob_freeit = CFRelease;

   502 	return (PyObject *)it;

   503 }

   504 

   505 int CFArrayRefObj_Convert(PyObject *v, CFArrayRef *p_itself)

   506 {

   507 

   508 	if (v == Py_None) { *p_itself = NULL; return 1; }

   509 	/* Check for other CF objects here */

   510 

   511 	if (!CFArrayRefObj_Check(v))

   512 	{

   513 		PyErr_SetString(PyExc_TypeError, "CFArrayRef required");

   514 		return 0;

   515 	}

   516 	*p_itself = ((CFArrayRefObject *)v)->ob_itself;

   517 	return 1;

   518 }

   519 

   520 static void CFArrayRefObj_dealloc(CFArrayRefObject *self)

   521 {

   522 	if (self->ob_freeit && self->ob_itself)

   523 	{

   524 		self->ob_freeit((CFTypeRef)self->ob_itself);

   525 		self->ob_itself = NULL;

   526 	}

   527 	CFTypeRef_Type.tp_dealloc((PyObject *)self);

   528 }

   529 

   530 static PyObject *CFArrayRefObj_CFArrayCreateCopy(CFArrayRefObject *_self, PyObject *_args)

   531 {

   532 	PyObject *_res = NULL;

   533 	CFArrayRef _rv;

   534 	if (!PyArg_ParseTuple(_args, ""))

   535 		return NULL;

   536 	_rv = CFArrayCreateCopy((CFAllocatorRef)NULL,

   537 	                        _self->ob_itself);

   538 	_res = Py_BuildValue("O&",

   539 	                     CFArrayRefObj_New, _rv);

   540 	return _res;

   541 }

   542 

   543 static PyObject *CFArrayRefObj_CFArrayGetCount(CFArrayRefObject *_self, PyObject *_args)

   544 {

   545 	PyObject *_res = NULL;

   546 	CFIndex _rv;

   547 #ifndef CFArrayGetCount

   548 	PyMac_PRECHECK(CFArrayGetCount);

   549 #endif

   550 	if (!PyArg_ParseTuple(_args, ""))

   551 		return NULL;

   552 	_rv = CFArrayGetCount(_self->ob_itself);

   553 	_res = Py_BuildValue("l",

   554 	                     _rv);

   555 	return _res;

   556 }

   557 

   558 static PyObject *CFArrayRefObj_CFStringCreateByCombiningStrings(CFArrayRefObject *_self, PyObject *_args)

   559 {

   560 	PyObject *_res = NULL;

   561 	CFStringRef _rv;

   562 	CFStringRef separatorString;

   563 	if (!PyArg_ParseTuple(_args, "O&",

   564 	                      CFStringRefObj_Convert, &separatorString))

   565 		return NULL;

   566 	_rv = CFStringCreateByCombiningStrings((CFAllocatorRef)NULL,

   567 	                                       _self->ob_itself,

   568 	                                       separatorString);

   569 	_res = Py_BuildValue("O&",

   570 	                     CFStringRefObj_New, _rv);

   571 	return _res;

   572 }

   573 

   574 static PyMethodDef CFArrayRefObj_methods[] = {

   575 	{"CFArrayCreateCopy", (PyCFunction)CFArrayRefObj_CFArrayCreateCopy, 1,

   576 	 PyDoc_STR("() -> (CFArrayRef _rv)")},

   577 	{"CFArrayGetCount", (PyCFunction)CFArrayRefObj_CFArrayGetCount, 1,

   578 	 PyDoc_STR("() -> (CFIndex _rv)")},

   579 	{"CFStringCreateByCombiningStrings", (PyCFunction)CFArrayRefObj_CFStringCreateByCombiningStrings, 1,

   580 	 PyDoc_STR("(CFStringRef separatorString) -> (CFStringRef _rv)")},

   581 	{NULL, NULL, 0}

   582 };

   583 

   584 #define CFArrayRefObj_getsetlist NULL

   585 

   586 

   587 static int CFArrayRefObj_compare(CFArrayRefObject *self, CFArrayRefObject *other)

   588 {

   589 	/* XXXX Or should we use CFEqual?? */

   590 	if ( self->ob_itself > other->ob_itself ) return 1;

   591 	if ( self->ob_itself < other->ob_itself ) return -1;

   592 	return 0;

   593 }

   594 

   595 static PyObject * CFArrayRefObj_repr(CFArrayRefObject *self)

   596 {

   597 	char buf[100];

   598 	sprintf(buf, "<CFArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);

   599 	return PyString_FromString(buf);

   600 }

   601 

   602 static int CFArrayRefObj_hash(CFArrayRefObject *self)

   603 {

   604 	/* XXXX Or should we use CFHash?? */

   605 	return (int)self->ob_itself;

   606 }

   607 static int CFArrayRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

   608 {

   609 	CFArrayRef itself;

   610 	char *kw[] = {"itself", 0};

   611 

   612 	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFArrayRefObj_Convert, &itself))

   613 	{

   614 		((CFArrayRefObject *)_self)->ob_itself = itself;

   615 		return 0;

   616 	}

   617 

   618 	/* Any CFTypeRef descendent is allowed as initializer too */

   619 	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))

   620 	{

   621 		((CFArrayRefObject *)_self)->ob_itself = itself;

   622 		return 0;

   623 	}

   624 	return -1;

   625 }

   626 

   627 #define CFArrayRefObj_tp_alloc PyType_GenericAlloc

   628 

   629 static PyObject *CFArrayRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   630 {

   631 	PyObject *self;

   632 	if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;

   633 	((CFArrayRefObject *)self)->ob_itself = NULL;

   634 	((CFArrayRefObject *)self)->ob_freeit = CFRelease;

   635 	return self;

   636 }

   637 

   638 #define CFArrayRefObj_tp_free PyObject_Del

   639 

   640 

   641 PyTypeObject CFArrayRef_Type = {

   642 	PyObject_HEAD_INIT(NULL)

   643 	0, /*ob_size*/

   644 	"_CF.CFArrayRef", /*tp_name*/

   645 	sizeof(CFArrayRefObject), /*tp_basicsize*/

   646 	0, /*tp_itemsize*/

   647 	/* methods */

   648 	(destructor) CFArrayRefObj_dealloc, /*tp_dealloc*/

   649 	0, /*tp_print*/

   650 	(getattrfunc)0, /*tp_getattr*/

   651 	(setattrfunc)0, /*tp_setattr*/

   652 	(cmpfunc) CFArrayRefObj_compare, /*tp_compare*/

   653 	(reprfunc) CFArrayRefObj_repr, /*tp_repr*/

   654 	(PyNumberMethods *)0, /* tp_as_number */

   655 	(PySequenceMethods *)0, /* tp_as_sequence */

   656 	(PyMappingMethods *)0, /* tp_as_mapping */

   657 	(hashfunc) CFArrayRefObj_hash, /*tp_hash*/

   658 	0, /*tp_call*/

   659 	0, /*tp_str*/

   660 	PyObject_GenericGetAttr, /*tp_getattro*/

   661 	PyObject_GenericSetAttr, /*tp_setattro */

   662 	0, /*tp_as_buffer*/

   663 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   664 	0, /*tp_doc*/

   665 	0, /*tp_traverse*/

   666 	0, /*tp_clear*/

   667 	0, /*tp_richcompare*/

   668 	0, /*tp_weaklistoffset*/

   669 	0, /*tp_iter*/

   670 	0, /*tp_iternext*/

   671 	CFArrayRefObj_methods, /* tp_methods */

   672 	0, /*tp_members*/

   673 	CFArrayRefObj_getsetlist, /*tp_getset*/

   674 	0, /*tp_base*/

   675 	0, /*tp_dict*/

   676 	0, /*tp_descr_get*/

   677 	0, /*tp_descr_set*/

   678 	0, /*tp_dictoffset*/

   679 	CFArrayRefObj_tp_init, /* tp_init */

   680 	CFArrayRefObj_tp_alloc, /* tp_alloc */

   681 	CFArrayRefObj_tp_new, /* tp_new */

   682 	CFArrayRefObj_tp_free, /* tp_free */

   683 };

   684 

   685 /* ------------------- End object type CFArrayRef ------------------- */

   686 

   687 

   688 /* ----------------- Object type CFMutableArrayRef ------------------ */

   689 

   690 PyTypeObject CFMutableArrayRef_Type;

   691 

   692 #define CFMutableArrayRefObj_Check(x) ((x)->ob_type == &CFMutableArrayRef_Type || PyObject_TypeCheck((x), &CFMutableArrayRef_Type))

   693 

   694 typedef struct CFMutableArrayRefObject {

   695 	PyObject_HEAD

   696 	CFMutableArrayRef ob_itself;

   697 	void (*ob_freeit)(CFTypeRef ptr);

   698 } CFMutableArrayRefObject;

   699 

   700 PyObject *CFMutableArrayRefObj_New(CFMutableArrayRef itself)

   701 {

   702 	CFMutableArrayRefObject *it;

   703 	if (itself == NULL)

   704 	{

   705 		PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");

   706 		return NULL;

   707 	}

   708 	it = PyObject_NEW(CFMutableArrayRefObject, &CFMutableArrayRef_Type);

   709 	if (it == NULL) return NULL;

   710 	/* XXXX Should we tp_init or tp_new our basetype? */

   711 	it->ob_itself = itself;

   712 	it->ob_freeit = CFRelease;

   713 	return (PyObject *)it;

   714 }

   715 

   716 int CFMutableArrayRefObj_Convert(PyObject *v, CFMutableArrayRef *p_itself)

   717 {

   718 

   719 	if (v == Py_None) { *p_itself = NULL; return 1; }

   720 	/* Check for other CF objects here */

   721 

   722 	if (!CFMutableArrayRefObj_Check(v))

   723 	{

   724 		PyErr_SetString(PyExc_TypeError, "CFMutableArrayRef required");

   725 		return 0;

   726 	}

   727 	*p_itself = ((CFMutableArrayRefObject *)v)->ob_itself;

   728 	return 1;

   729 }

   730 

   731 static void CFMutableArrayRefObj_dealloc(CFMutableArrayRefObject *self)

   732 {

   733 	if (self->ob_freeit && self->ob_itself)

   734 	{

   735 		self->ob_freeit((CFTypeRef)self->ob_itself);

   736 		self->ob_itself = NULL;

   737 	}

   738 	CFArrayRef_Type.tp_dealloc((PyObject *)self);

   739 }

   740 

   741 static PyObject *CFMutableArrayRefObj_CFArrayRemoveValueAtIndex(CFMutableArrayRefObject *_self, PyObject *_args)

   742 {

   743 	PyObject *_res = NULL;

   744 	CFIndex idx;

   745 #ifndef CFArrayRemoveValueAtIndex

   746 	PyMac_PRECHECK(CFArrayRemoveValueAtIndex);

   747 #endif

   748 	if (!PyArg_ParseTuple(_args, "l",

   749 	                      &idx))

   750 		return NULL;

   751 	CFArrayRemoveValueAtIndex(_self->ob_itself,

   752 	                          idx);

   753 	Py_INCREF(Py_None);

   754 	_res = Py_None;

   755 	return _res;

   756 }

   757 

   758 static PyObject *CFMutableArrayRefObj_CFArrayRemoveAllValues(CFMutableArrayRefObject *_self, PyObject *_args)

   759 {

   760 	PyObject *_res = NULL;

   761 #ifndef CFArrayRemoveAllValues

   762 	PyMac_PRECHECK(CFArrayRemoveAllValues);

   763 #endif

   764 	if (!PyArg_ParseTuple(_args, ""))

   765 		return NULL;

   766 	CFArrayRemoveAllValues(_self->ob_itself);

   767 	Py_INCREF(Py_None);

   768 	_res = Py_None;

   769 	return _res;

   770 }

   771 

   772 static PyObject *CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices(CFMutableArrayRefObject *_self, PyObject *_args)

   773 {

   774 	PyObject *_res = NULL;

   775 	CFIndex idx1;

   776 	CFIndex idx2;

   777 #ifndef CFArrayExchangeValuesAtIndices

   778 	PyMac_PRECHECK(CFArrayExchangeValuesAtIndices);

   779 #endif

   780 	if (!PyArg_ParseTuple(_args, "ll",

   781 	                      &idx1,

   782 	                      &idx2))

   783 		return NULL;

   784 	CFArrayExchangeValuesAtIndices(_self->ob_itself,

   785 	                               idx1,

   786 	                               idx2);

   787 	Py_INCREF(Py_None);

   788 	_res = Py_None;

   789 	return _res;

   790 }

   791 

   792 static PyObject *CFMutableArrayRefObj_CFArrayAppendArray(CFMutableArrayRefObject *_self, PyObject *_args)

   793 {

   794 	PyObject *_res = NULL;

   795 	CFArrayRef otherArray;

   796 	CFRange otherRange;

   797 #ifndef CFArrayAppendArray

   798 	PyMac_PRECHECK(CFArrayAppendArray);

   799 #endif

   800 	if (!PyArg_ParseTuple(_args, "O&O&",

   801 	                      CFArrayRefObj_Convert, &otherArray,

   802 	                      CFRange_Convert, &otherRange))

   803 		return NULL;

   804 	CFArrayAppendArray(_self->ob_itself,

   805 	                   otherArray,

   806 	                   otherRange);

   807 	Py_INCREF(Py_None);

   808 	_res = Py_None;

   809 	return _res;

   810 }

   811 

   812 static PyMethodDef CFMutableArrayRefObj_methods[] = {

   813 	{"CFArrayRemoveValueAtIndex", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveValueAtIndex, 1,

   814 	 PyDoc_STR("(CFIndex idx) -> None")},

   815 	{"CFArrayRemoveAllValues", (PyCFunction)CFMutableArrayRefObj_CFArrayRemoveAllValues, 1,

   816 	 PyDoc_STR("() -> None")},

   817 	{"CFArrayExchangeValuesAtIndices", (PyCFunction)CFMutableArrayRefObj_CFArrayExchangeValuesAtIndices, 1,

   818 	 PyDoc_STR("(CFIndex idx1, CFIndex idx2) -> None")},

   819 	{"CFArrayAppendArray", (PyCFunction)CFMutableArrayRefObj_CFArrayAppendArray, 1,

   820 	 PyDoc_STR("(CFArrayRef otherArray, CFRange otherRange) -> None")},

   821 	{NULL, NULL, 0}

   822 };

   823 

   824 #define CFMutableArrayRefObj_getsetlist NULL

   825 

   826 

   827 static int CFMutableArrayRefObj_compare(CFMutableArrayRefObject *self, CFMutableArrayRefObject *other)

   828 {

   829 	/* XXXX Or should we use CFEqual?? */

   830 	if ( self->ob_itself > other->ob_itself ) return 1;

   831 	if ( self->ob_itself < other->ob_itself ) return -1;

   832 	return 0;

   833 }

   834 

   835 static PyObject * CFMutableArrayRefObj_repr(CFMutableArrayRefObject *self)

   836 {

   837 	char buf[100];

   838 	sprintf(buf, "<CFMutableArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);

   839 	return PyString_FromString(buf);

   840 }

   841 

   842 static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self)

   843 {

   844 	/* XXXX Or should we use CFHash?? */

   845 	return (int)self->ob_itself;

   846 }

   847 static int CFMutableArrayRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

   848 {

   849 	CFMutableArrayRef itself;

   850 	char *kw[] = {"itself", 0};

   851 

   852 	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFMutableArrayRefObj_Convert, &itself))

   853 	{

   854 		((CFMutableArrayRefObject *)_self)->ob_itself = itself;

   855 		return 0;

   856 	}

   857 

   858 	/* Any CFTypeRef descendent is allowed as initializer too */

   859 	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))

   860 	{

   861 		((CFMutableArrayRefObject *)_self)->ob_itself = itself;

   862 		return 0;

   863 	}

   864 	return -1;

   865 }

   866 

   867 #define CFMutableArrayRefObj_tp_alloc PyType_GenericAlloc

   868 

   869 static PyObject *CFMutableArrayRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

   870 {

   871 	PyObject *self;

   872 	if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;

   873 	((CFMutableArrayRefObject *)self)->ob_itself = NULL;

   874 	((CFMutableArrayRefObject *)self)->ob_freeit = CFRelease;

   875 	return self;

   876 }

   877 

   878 #define CFMutableArrayRefObj_tp_free PyObject_Del

   879 

   880 

   881 PyTypeObject CFMutableArrayRef_Type = {

   882 	PyObject_HEAD_INIT(NULL)

   883 	0, /*ob_size*/

   884 	"_CF.CFMutableArrayRef", /*tp_name*/

   885 	sizeof(CFMutableArrayRefObject), /*tp_basicsize*/

   886 	0, /*tp_itemsize*/

   887 	/* methods */

   888 	(destructor) CFMutableArrayRefObj_dealloc, /*tp_dealloc*/

   889 	0, /*tp_print*/

   890 	(getattrfunc)0, /*tp_getattr*/

   891 	(setattrfunc)0, /*tp_setattr*/

   892 	(cmpfunc) CFMutableArrayRefObj_compare, /*tp_compare*/

   893 	(reprfunc) CFMutableArrayRefObj_repr, /*tp_repr*/

   894 	(PyNumberMethods *)0, /* tp_as_number */

   895 	(PySequenceMethods *)0, /* tp_as_sequence */

   896 	(PyMappingMethods *)0, /* tp_as_mapping */

   897 	(hashfunc) CFMutableArrayRefObj_hash, /*tp_hash*/

   898 	0, /*tp_call*/

   899 	0, /*tp_str*/

   900 	PyObject_GenericGetAttr, /*tp_getattro*/

   901 	PyObject_GenericSetAttr, /*tp_setattro */

   902 	0, /*tp_as_buffer*/

   903 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

   904 	0, /*tp_doc*/

   905 	0, /*tp_traverse*/

   906 	0, /*tp_clear*/

   907 	0, /*tp_richcompare*/

   908 	0, /*tp_weaklistoffset*/

   909 	0, /*tp_iter*/

   910 	0, /*tp_iternext*/

   911 	CFMutableArrayRefObj_methods, /* tp_methods */

   912 	0, /*tp_members*/

   913 	CFMutableArrayRefObj_getsetlist, /*tp_getset*/

   914 	0, /*tp_base*/

   915 	0, /*tp_dict*/

   916 	0, /*tp_descr_get*/

   917 	0, /*tp_descr_set*/

   918 	0, /*tp_dictoffset*/

   919 	CFMutableArrayRefObj_tp_init, /* tp_init */

   920 	CFMutableArrayRefObj_tp_alloc, /* tp_alloc */

   921 	CFMutableArrayRefObj_tp_new, /* tp_new */

   922 	CFMutableArrayRefObj_tp_free, /* tp_free */

   923 };

   924 

   925 /* --------------- End object type CFMutableArrayRef ---------------- */

   926 

   927 

   928 /* ------------------ Object type CFDictionaryRef ------------------- */

   929 

   930 PyTypeObject CFDictionaryRef_Type;

   931 

   932 #define CFDictionaryRefObj_Check(x) ((x)->ob_type == &CFDictionaryRef_Type || PyObject_TypeCheck((x), &CFDictionaryRef_Type))

   933 

   934 typedef struct CFDictionaryRefObject {

   935 	PyObject_HEAD

   936 	CFDictionaryRef ob_itself;

   937 	void (*ob_freeit)(CFTypeRef ptr);

   938 } CFDictionaryRefObject;

   939 

   940 PyObject *CFDictionaryRefObj_New(CFDictionaryRef itself)

   941 {

   942 	CFDictionaryRefObject *it;

   943 	if (itself == NULL)

   944 	{

   945 		PyErr_SetString(PyExc_RuntimeError, "cannot wrap NULL");

   946 		return NULL;

   947 	}

   948 	it = PyObject_NEW(CFDictionaryRefObject, &CFDictionaryRef_Type);

   949 	if (it == NULL) return NULL;

   950 	/* XXXX Should we tp_init or tp_new our basetype? */

   951 	it->ob_itself = itself;

   952 	it->ob_freeit = CFRelease;

   953 	return (PyObject *)it;

   954 }

   955 

   956 int CFDictionaryRefObj_Convert(PyObject *v, CFDictionaryRef *p_itself)

   957 {

   958 

   959 	if (v == Py_None) { *p_itself = NULL; return 1; }

   960 	/* Check for other CF objects here */

   961 

   962 	if (!CFDictionaryRefObj_Check(v))

   963 	{

   964 		PyErr_SetString(PyExc_TypeError, "CFDictionaryRef required");

   965 		return 0;

   966 	}

   967 	*p_itself = ((CFDictionaryRefObject *)v)->ob_itself;

   968 	return 1;

   969 }

   970 

   971 static void CFDictionaryRefObj_dealloc(CFDictionaryRefObject *self)

   972 {

   973 	if (self->ob_freeit && self->ob_itself)

   974 	{

   975 		self->ob_freeit((CFTypeRef)self->ob_itself);

   976 		self->ob_itself = NULL;

   977 	}

   978 	CFTypeRef_Type.tp_dealloc((PyObject *)self);

   979 }

   980 

   981 static PyObject *CFDictionaryRefObj_CFDictionaryCreateCopy(CFDictionaryRefObject *_self, PyObject *_args)

   982 {

   983 	PyObject *_res = NULL;

   984 	CFDictionaryRef _rv;

   985 	if (!PyArg_ParseTuple(_args, ""))

   986 		return NULL;

   987 	_rv = CFDictionaryCreateCopy((CFAllocatorRef)NULL,

   988 	                             _self->ob_itself);

   989 	_res = Py_BuildValue("O&",

   990 	                     CFDictionaryRefObj_New, _rv);

   991 	return _res;

   992 }

   993 

   994 static PyObject *CFDictionaryRefObj_CFDictionaryGetCount(CFDictionaryRefObject *_self, PyObject *_args)

   995 {

   996 	PyObject *_res = NULL;

   997 	CFIndex _rv;

   998 #ifndef CFDictionaryGetCount

   999 	PyMac_PRECHECK(CFDictionaryGetCount);

  1000 #endif

  1001 	if (!PyArg_ParseTuple(_args, ""))

  1002 		return NULL;

  1003 	_rv = CFDictionaryGetCount(_self->ob_itself);

  1004 	_res = Py_BuildValue("l",

  1005 	                     _rv);

  1006 	return _res;

  1007 }

  1008 

  1009 static PyMethodDef CFDictionaryRefObj_methods[] = {

  1010 	{"CFDictionaryCreateCopy", (PyCFunction)CFDictionaryRefObj_CFDictionaryCreateCopy, 1,

  1011 	 PyDoc_STR("() -> (CFDictionaryRef _rv)")},

  1012 	{"CFDictionaryGetCount", (PyCFunction)CFDictionaryRefObj_CFDictionaryGetCount, 1,

  1013 	 PyDoc_STR("() -> (CFIndex _rv)")},

  1014 	{NULL, NULL, 0}

  1015 };

  1016 

  1017 #define CFDictionaryRefObj_getsetlist NULL

  1018 

  1019 

  1020 static int CFDictionaryRefObj_compare(CFDictionaryRefObject *self, CFDictionaryRefObject *other)

  1021 {

  1022 	/* XXXX Or should we use CFEqual?? */

  1023 	if ( self->ob_itself > other->ob_itself ) return 1;

  1024 	if ( self->ob_itself < other->ob_itself ) return -1;

  1025 	return 0;

  1026 }

  1027 

  1028 static PyObject * CFDictionaryRefObj_repr(CFDictionaryRefObject *self)

  1029 {

  1030 	char buf[100];

  1031 	sprintf(buf, "<CFDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);

  1032 	return PyString_FromString(buf);

  1033 }

  1034 

  1035 static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self)

  1036 {

  1037 	/* XXXX Or should we use CFHash?? */

  1038 	return (int)self->ob_itself;

  1039 }

  1040 static int CFDictionaryRefObj_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds)

  1041 {

  1042 	CFDictionaryRef itself;

  1043 	char *kw[] = {"itself", 0};

  1044 

  1045 	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFDictionaryRefObj_Convert, &itself))

  1046 	{

  1047 		((CFDictionaryRefObject *)_self)->ob_itself = itself;

  1048 		return 0;

  1049 	}

  1050 

  1051 	/* Any CFTypeRef descendent is allowed as initializer too */

  1052 	if (PyArg_ParseTupleAndKeywords(_args, _kwds, "O&", kw, CFTypeRefObj_Convert, &itself))

  1053 	{

  1054 		((CFDictionaryRefObject *)_self)->ob_itself = itself;

  1055 		return 0;

  1056 	}

  1057 	return -1;

  1058 }

  1059 

  1060 #define CFDictionaryRefObj_tp_alloc PyType_GenericAlloc

  1061 

  1062 static PyObject *CFDictionaryRefObj_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds)

  1063 {

  1064 	PyObject *self;

  1065 	if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;

  1066 	((CFDictionaryRefObject *)self)->ob_itself = NULL;

  1067 	((CFDictionaryRefObject *)self)->ob_freeit = CFRelease;

  1068 	return self;

  1069 }

  1070 

  1071 #define CFDictionaryRefObj_tp_free PyObject_Del

  1072 

  1073 

  1074 PyTypeObject CFDictionaryRef_Type = {

  1075 	PyObject_HEAD_INIT(NULL)

  1076 	0, /*ob_size*/

  1077 	"_CF.CFDictionaryRef", /*tp_name*/

  1078 	sizeof(CFDictionaryRefObject), /*tp_basicsize*/

  1079 	0, /*tp_itemsize*/

  1080 	/* methods */

  1081 	(destructor) CFDictionaryRefObj_dealloc, /*tp_dealloc*/

  1082 	0, /*tp_print*/

  1083 	(getattrfunc)0, /*tp_getattr*/

  1084 	(setattrfunc)0, /*tp_setattr*/

  1085 	(cmpfunc) CFDictionaryRefObj_compare, /*tp_compare*/

  1086 	(reprfunc) CFDictionaryRefObj_repr, /*tp_repr*/

  1087 	(PyNumberMethods *)0, /* tp_as_number */

  1088 	(PySequenceMethods *)0, /* tp_as_sequence */

  1089 	(PyMappingMethods *)0, /* tp_as_mapping */

  1090 	(hashfunc) CFDictionaryRefObj_hash, /*tp_hash*/

  1091 	0, /*tp_call*/

  1092 	0, /*tp_str*/

  1093 	PyObject_GenericGetAttr, /*tp_getattro*/

  1094 	PyObject_GenericSetAttr, /*tp_setattro */

  1095 	0, /*tp_as_buffer*/

  1096 	Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */

  1097 	0, /*tp_doc*/

  1098 	0, /*tp_traverse*/

  1099 	0, /*tp_clear*/

  1100 	0, /*tp_richcompare*/

  1101 	0, /*tp_weaklistoffset*/

  1102 	0, /*tp_iter*/

  1103 	0, /*tp_iternext*/

  1104 	CFDictionaryRefObj_methods, /* tp_methods */

  1105 	0, /*tp_members*/

  1106 	CFDictionaryRefObj_getsetlist, /*tp_getset*/

  1107 	0, /*tp_base*/

  1108 	0, /*tp_dict*/

  1109 	0, /*tp_descr_get*/

  1110 	0, /*tp_descr_set*/

  1111 	0, /*tp_dictoffset*/

  1112 	CFDictionaryRefObj_tp_init, /* tp_init */

  1113 	CFDictionaryRefObj_tp_alloc, /* tp_alloc */

  1114 	CFDictionaryRefObj_tp_new, /* tp_new */

  1115 	CFDictionaryRefObj_tp_free, /* tp_free */

  1116 };

  1117 

  1118 /* ---------------- End object type CFDictionaryRef ----------------- */

  1119 

  1120 

  1121 /* --------------- Object type CFMutableDictionaryRef --------------- */

  1122 

  1123 PyTypeObject CFMutableDictionaryRef_Type;

  1124 

  1125 #define CFMutableDictionaryRefObj_Check(x) ((x)->ob_type == &CFMutableDictionaryRef_Type || PyObject_TypeCheck((x), &CFMutableDictionaryRef_Type))

  1126 

  1127 typedef struct CFMutableDictionaryRefObject {

  1128 	PyObject_HEAD

  1129 	CFMutableDictionaryRef ob_itself;

  1130 	void (*ob_freeit)(CFTypeRef ptr);

  1131 } CFMutableDictionaryRefObject;

  1132 

  1133 PyObject *CFMutableDictionaryRefObj_New(CFMutableDictionaryRef itself)

  1134 {

  1135 	CFMutableDictionaryRefObject *it;