diff options
| -rw-r--r-- | Mac/Modules/cf/CFmodule.c | 425 | ||||
| -rw-r--r-- | Mac/Modules/cf/cfscan.py | 83 | ||||
| -rw-r--r-- | Mac/Modules/cf/cfsupport.py | 158 |
3 files changed, 666 insertions, 0 deletions
diff --git a/Mac/Modules/cf/CFmodule.c b/Mac/Modules/cf/CFmodule.c new file mode 100644 index 0000000..ca2ce51 --- /dev/null +++ b/Mac/Modules/cf/CFmodule.c @@ -0,0 +1,425 @@ + +/* =========================== Module CF ============================ */ + +#include "Python.h" + + + +#include "macglue.h" +#include "pymactoolbox.h" + +#ifdef WITHOUT_FRAMEWORKS +#include <CoreFoundation.h> +#else +#include <CoreFoundation.h> +#endif + +/* For now we declare them forward here. They'll go to mactoolbox later */ +extern PyObject *CFTypeRefObj_New(CFTypeRef); +extern int CFTypeRefObj_Convert(PyObject *, CFTypeRef *); +extern PyObject *CFStringRefObj_New(CFStringRef); +extern int CFStringRefObj_Convert(PyObject *, CFStringRef *); + +#ifdef NOTYET_USE_TOOLBOX_OBJECT_GLUE +//extern PyObject *_CFTypeRefObj_New(CFTypeRef); +//extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *); + +//#define CFTypeRefObj_New _CFTypeRefObj_New +//#define CFTypeRefObj_Convert _CFTypeRefObj_Convert +#endif + + +static PyObject *CF_Error; + +/* --------------------- Object type CFTypeRef ---------------------- */ + +PyTypeObject CFTypeRef_Type; + +#define CFTypeRefObj_Check(x) ((x)->ob_type == &CFTypeRef_Type) + +typedef struct CFTypeRefObject { + PyObject_HEAD + CFTypeRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFTypeRefObject; + +PyObject *CFTypeRefObj_New(CFTypeRef itself) +{ + CFTypeRefObject *it; + if (itself == NULL) return PyMac_Error(resNotFound); + CFRetain(itself); + it = PyObject_NEW(CFTypeRefObject, &CFTypeRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + it->ob_freeit = CFRelease; + return (PyObject *)it; +} +CFTypeRefObj_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)) + { + 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); + } + PyMem_DEL(self); +} + +static PyObject *CFTypeRefObj_CFGetTypeID(CFTypeRefObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeID _rv; + 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; + 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; + 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; + 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; + 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; + 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; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _rv = CFCopyDescription(_self->ob_itself); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyMethodDef CFTypeRefObj_methods[] = { + {"CFGetTypeID", (PyCFunction)CFTypeRefObj_CFGetTypeID, 1, + "() -> (CFTypeID _rv)"}, + {"CFRetain", (PyCFunction)CFTypeRefObj_CFRetain, 1, + "() -> (CFTypeRef _rv)"}, + {"CFRelease", (PyCFunction)CFTypeRefObj_CFRelease, 1, + "() -> None"}, + {"CFGetRetainCount", (PyCFunction)CFTypeRefObj_CFGetRetainCount, 1, + "() -> (CFIndex _rv)"}, + {"CFEqual", (PyCFunction)CFTypeRefObj_CFEqual, 1, + "(CFTypeRef cf2) -> (Boolean _rv)"}, + {"CFHash", (PyCFunction)CFTypeRefObj_CFHash, 1, + "() -> (CFHashCode _rv)"}, + {"CFCopyDescription", (PyCFunction)CFTypeRefObj_CFCopyDescription, 1, + "() -> (CFStringRef _rv)"}, + {NULL, NULL, 0} +}; + +PyMethodChain CFTypeRefObj_chain = { CFTypeRefObj_methods, NULL }; + +static PyObject *CFTypeRefObj_getattr(CFTypeRefObject *self, char *name) +{ + return Py_FindMethodInChain(&CFTypeRefObj_chain, (PyObject *)self, name); +} + +#define CFTypeRefObj_setattr NULL + +static int CFTypeRefObj_compare(CFTypeRefObject *self, CFTypeRefObject *other) +{ + /* XXXX Or should we use 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%08.8x for 0x%08.8x>", CFGetTypeID(self->ob_itself), self, self->ob_itself); + return PyString_FromString(buf); +} + +static int CFTypeRefObj_hash(CFTypeRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} + +PyTypeObject CFTypeRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "CFTypeRef", /*tp_name*/ + sizeof(CFTypeRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFTypeRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) CFTypeRefObj_getattr, /*tp_getattr*/ + (setattrfunc) CFTypeRefObj_setattr, /*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*/ +}; + +/* ------------------- End object type CFTypeRef -------------------- */ + + +/* -------------------- Object type CFStringRef --------------------- */ + +PyTypeObject CFStringRef_Type; + +#define CFStringRefObj_Check(x) ((x)->ob_type == &CFStringRef_Type) + +typedef struct CFStringRefObject { + PyObject_HEAD + CFStringRef ob_itself; + void (*ob_freeit)(CFTypeRef ptr); +} CFStringRefObject; + +PyObject *CFStringRefObj_New(CFStringRef itself) +{ + CFStringRefObject *it; + if (itself == NULL) return PyMac_Error(resNotFound); + CFRetain(itself); + it = PyObject_NEW(CFStringRefObject, &CFStringRef_Type); + if (it == NULL) return NULL; + it->ob_itself = itself; + it->ob_freeit = CFRelease; + return (PyObject *)it; +} +CFStringRefObj_Convert(PyObject *v, CFStringRef *p_itself) +{ + + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + + 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); + } + PyMem_DEL(self); +} + +static PyMethodDef CFStringRefObj_methods[] = { + {NULL, NULL, 0} +}; + +PyMethodChain CFStringRefObj_chain = { CFStringRefObj_methods, NULL }; + +static PyObject *CFStringRefObj_getattr(CFStringRefObject *self, char *name) +{ + return Py_FindMethodInChain(&CFStringRefObj_chain, (PyObject *)self, name); +} + +#define CFStringRefObj_setattr NULL + +static int CFStringRefObj_compare(CFStringRefObject *self, CFStringRefObject *other) +{ + /* XXXX Or should we use 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, "<CFTypeRef type-%d object at 0x%08.8x for 0x%08.8x>", CFGetTypeID(self->ob_itself), self, self->ob_itself); + return PyString_FromString(buf); +} + +static int CFStringRefObj_hash(CFStringRefObject *self) +{ + /* XXXX Or should we use CFHash?? */ + return (int)self->ob_itself; +} + +PyTypeObject CFStringRef_Type = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "CFStringRef", /*tp_name*/ + sizeof(CFStringRefObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) CFStringRefObj_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) CFStringRefObj_getattr, /*tp_getattr*/ + (setattrfunc) CFStringRefObj_setattr, /*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*/ +}; + +/* ------------------ End object type CFStringRef ------------------- */ + + +static PyObject *CF_CFAllocatorGetTypeID(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + CFTypeID _rv; + 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; + 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 theType; + if (!PyArg_ParseTuple(_args, "l", + &theType)) + return NULL; + _rv = CFCopyTypeIDDescription(theType); + _res = Py_BuildValue("O&", + CFStringRefObj_New, _rv); + return _res; +} + +static PyMethodDef CF_methods[] = { + {"CFAllocatorGetTypeID", (PyCFunction)CF_CFAllocatorGetTypeID, 1, + "() -> (CFTypeID _rv)"}, + {"CFAllocatorGetPreferredSizeForSize", (PyCFunction)CF_CFAllocatorGetPreferredSizeForSize, 1, + "(CFIndex size, CFOptionFlags hint) -> (CFIndex _rv)"}, + {"CFCopyTypeIDDescription", (PyCFunction)CF_CFCopyTypeIDDescription, 1, + "(CFTypeID theType) -> (CFStringRef _rv)"}, + {NULL, NULL, 0} +}; + + + + +void initCF(void) +{ + PyObject *m; + PyObject *d; + + + + // PyMac_INIT_TOOLBOX_OBJECT_NEW(Track, TrackObj_New); + // PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Track, TrackObj_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; + Py_INCREF(&CFTypeRef_Type); + if (PyDict_SetItemString(d, "CFTypeRefType", (PyObject *)&CFTypeRef_Type) != 0) + Py_FatalError("can't initialize CFTypeRefType"); + CFStringRef_Type.ob_type = &PyType_Type; + Py_INCREF(&CFStringRef_Type); + if (PyDict_SetItemString(d, "CFStringRefType", (PyObject *)&CFStringRef_Type) != 0) + Py_FatalError("can't initialize CFStringRefType"); +} + +/* ========================= End module CF ========================== */ + diff --git a/Mac/Modules/cf/cfscan.py b/Mac/Modules/cf/cfscan.py new file mode 100644 index 0000000..776af5b --- /dev/null +++ b/Mac/Modules/cf/cfscan.py @@ -0,0 +1,83 @@ +# Scan an Apple header file, generating a Python file of generator calls. + +import sys +import os +BGENDIR=os.path.join(sys.prefix, ':Tools:bgen:bgen') +sys.path.append(BGENDIR) +from scantools import Scanner_OSX +from bgenlocations import TOOLBOXDIR + +LONG = "CoreFoundation" +SHORT = "cf" +OBJECTS = ("CFTypeRef", "CFStringRef") + +def main(): + input = [ + "CFBase.h", +### "CFArray.h", +## "CFBag.h", +## "CFBundle.h", +## "CFCharacterSet.h", +### "CFData.h", +## "CFDate.h", +### "CFDictionary.h", +## "CFNumber.h", +## "CFPlugIn.h", +## "CFPreferences.h", +## "CFPropertyList.h", +## "CFSet.h", +### "CFString.h", +## "CFStringEncodingExt.h", +## "CFTimeZone.h", +## "CFURL.h", + ] + output = SHORT + "gen.py" + defsoutput = TOOLBOXDIR + LONG + ".py" + scanner = MyScanner(input, output, defsoutput) + scanner.scan() + scanner.gentypetest(SHORT+"typetest.py") + scanner.close() + print "=== Done scanning and generating, now importing the generated code... ===" + exec "import " + SHORT + "support" + print "=== Done. It's up to you to compile it now! ===" + +class MyScanner(Scanner_OSX): + + def destination(self, type, name, arglist): + classname = "Function" + listname = "functions" + if arglist: + t, n, m = arglist[0] + if t in OBJECTS and m == "InMode": + classname = "Method" + listname = t + "_methods" + return classname, listname + + def writeinitialdefs(self): + self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n") + + def makeblacklistnames(self): + return [ + # Memory allocator functions + "CFAllocatorGetDefault", + "CFAllocatorSetDefault", + "CFAllocatorAllocate", + "CFAllocatorReallocate", + "CFAllocatorDeallocate", + "CFGetAllocator", + ] + + def makegreylist(self): + return [] + + def makeblacklisttypes(self): + return [ + "CFAllocatorContext", + ] + + def makerepairinstructions(self): + return [ + ] + +if __name__ == "__main__": + main() diff --git a/Mac/Modules/cf/cfsupport.py b/Mac/Modules/cf/cfsupport.py new file mode 100644 index 0000000..5d3787a --- /dev/null +++ b/Mac/Modules/cf/cfsupport.py @@ -0,0 +1,158 @@ +# This script generates a Python interface for an Apple Macintosh Manager. +# It uses the "bgen" package to generate C code. +# The function specifications are generated by scanning the mamager's header file, +# using the "scantools" package (customized for this particular manager). + +#error missing SetActionFilter + +import string + +# Declarations that change for each manager +MODNAME = 'CF' # The name of the module + +# The following is *usually* unchanged but may still require tuning +MODPREFIX = MODNAME # The prefix for module-wide routines +INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner +OUTPUTFILE = MODNAME + "module.c" # The file generated by this program + +from macsupport import * + +# Create the type objects + +includestuff = includestuff + """ +#ifdef WITHOUT_FRAMEWORKS +#include <CoreFoundation.h> +#else +#include <CoreFoundation.h> +#endif + +/* For now we declare them forward here. They'll go to mactoolbox later */ +extern PyObject *CFTypeRefObj_New(CFTypeRef); +extern int CFTypeRefObj_Convert(PyObject *, CFTypeRef *); +extern PyObject *CFStringRefObj_New(CFStringRef); +extern int CFStringRefObj_Convert(PyObject *, CFStringRef *); + +#ifdef NOTYET_USE_TOOLBOX_OBJECT_GLUE +//extern PyObject *_CFTypeRefObj_New(CFTypeRef); +//extern int _CFTypeRefObj_Convert(PyObject *, CFTypeRef *); + +//#define CFTypeRefObj_New _CFTypeRefObj_New +//#define CFTypeRefObj_Convert _CFTypeRefObj_Convert +#endif + +""" + +initstuff = initstuff + """ +// PyMac_INIT_TOOLBOX_OBJECT_NEW(Track, TrackObj_New); +// PyMac_INIT_TOOLBOX_OBJECT_CONVERT(Track, TrackObj_Convert); +""" + +Boolean = Type("Boolean", "l") +CFTypeID = Type("CFTypeID", "l") # XXXX a guess, seems better than OSTypeType. +CFHashCode = Type("CFHashCode", "l") +CFIndex = Type("CFIndex", "l") +CFOptionFlags = Type("CFOptionFlags", "l") +## CFStringRef = XXXX +CFAllocatorRef = FakeType("(CFAllocatorRef)NULL") + +# The real objects +CFTypeRef = OpaqueByValueType("CFTypeRef", "CFTypeRefObj") +CFStringRef = OpaqueByValueType("CFStringRef", "CFStringRefObj") + +# Our (opaque) objects + +class MyGlobalObjectDefinition(GlobalObjectDefinition): + def outputCheckNewArg(self): + Output("if (itself == NULL) return PyMac_Error(resNotFound);") + Output("CFRetain(itself);") + def outputStructMembers(self): + GlobalObjectDefinition.outputStructMembers(self) + Output("void (*ob_freeit)(CFTypeRef ptr);") + def outputInitStructMembers(self): + GlobalObjectDefinition.outputInitStructMembers(self) +## Output("it->ob_freeit = NULL;") + Output("it->ob_freeit = CFRelease;") + def outputCheckConvertArg(self): + Out(""" + if (v == Py_None) { *p_itself = NULL; return 1; } + /* Check for other CF objects here */ + """) + def outputCleanupStructMembers(self): + Output("if (self->ob_freeit && self->ob_itself)") + OutLbrace() + Output("self->ob_freeit((CFTypeRef)self->ob_itself);") + OutRbrace() + + def outputCompare(self): + Output() + Output("static int %s_compare(%s *self, %s *other)", self.prefix, self.objecttype, self.objecttype) + OutLbrace() + Output("/* XXXX Or should we use CFEqual?? */") + Output("if ( self->ob_itself > other->ob_itself ) return 1;") + Output("if ( self->ob_itself < other->ob_itself ) return -1;") + Output("return 0;") + OutRbrace() + + def outputHash(self): + Output() + Output("static int %s_hash(%s *self)", self.prefix, self.objecttype) + OutLbrace() + Output("/* XXXX Or should we use CFHash?? */") + Output("return (int)self->ob_itself;") + OutRbrace() + + def outputRepr(self): + Output() + Output("static PyObject * %s_repr(%s *self)", self.prefix, self.objecttype) + OutLbrace() + Output("char buf[100];") + Output("""sprintf(buf, "<CFTypeRef type-%%d object at 0x%%08.8x for 0x%%08.8x>", CFGetTypeID(self->ob_itself), self, self->ob_itself);""") + Output("return PyString_FromString(buf);") + OutRbrace() + +class CFTypeRefObjectDefinition(MyGlobalObjectDefinition): + pass + +class CFStringRefObjectDefinition(MyGlobalObjectDefinition): + basechain = "&CFTypeRefObj_chain" + + def outputRepr(self): + Output() + Output("static PyObject * %s_repr(%s *self)", self.prefix, self.objecttype) + OutLbrace() + Output("char buf[100];") + Output("""sprintf(buf, "<CFString object at 0x%%08.8x for 0x%%08.8x>", CFGetTypeID(self->ob_itself), self, self->ob_itself);""") + Output("return PyString_FromString(buf);") + OutRbrace() + +# From here on it's basically all boiler plate... + +# Create the generator groups and link them +module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff) +CFTypeRef_object = CFTypeRefObjectDefinition('CFTypeRef', 'CFTypeRefObj', 'CFTypeRef') +CFStringRef_object = CFTypeRefObjectDefinition('CFStringRef', 'CFStringRefObj', 'CFStringRef') + +module.addobject(CFTypeRef_object) +module.addobject(CFStringRef_object) + +# Create the generator classes used to populate the lists +Function = OSErrFunctionGenerator +Method = OSErrMethodGenerator + +# Create and populate the lists +functions = [] +CFTypeRef_methods = [] +CFStringRef_methods = [] +execfile(INPUTFILE) + + +# add the populated lists to the generator groups +# (in a different wordl the scan program would generate this) +for f in functions: module.add(f) +for f in CFTypeRef_methods: CFTypeRef_object.add(f) +for f in CFStringRef_methods: CFStringRef_object.add(f) + +# generate output (open the output file as late as possible) +SetOutputFileName(OUTPUTFILE) +module.generate() + |