diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Python/mactoolboxglue.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Python/mactoolboxglue.c Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,474 @@ +/*********************************************************** +Copyright 1991-1997 by Stichting Mathematisch Centrum, Amsterdam, +The Netherlands. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +******************************************************************/ + + +#include "Python.h" +#include "pymactoolbox.h" +#include /* for ntohl, htonl */ + + +/* Like strerror() but for Mac OS error numbers */ +char * +PyMac_StrError(int err) +{ + static char buf[256]; + PyObject *m; + PyObject *rv; + + m = PyImport_ImportModuleNoBlock("MacOS"); + if (!m) { + if (Py_VerboseFlag) + PyErr_Print(); + PyErr_Clear(); + rv = NULL; + } + else { + rv = PyObject_CallMethod(m, "GetErrorString", "i", err); + if (!rv) + PyErr_Clear(); + } + if (!rv) { + buf[0] = '\0'; + } + else { + char *input = PyString_AsString(rv); + if (!input) { + PyErr_Clear(); + buf[0] = '\0'; + } else { + strncpy(buf, input, sizeof(buf) - 1); + buf[sizeof(buf) - 1] = '\0'; + } + Py_DECREF(rv); + } + Py_XDECREF(m); + return buf; +} + +/* Exception object shared by all Mac specific modules for Mac OS errors */ +PyObject *PyMac_OSErrException; + +/* Initialize and return PyMac_OSErrException */ +PyObject * +PyMac_GetOSErrException(void) +{ + if (PyMac_OSErrException == NULL) + PyMac_OSErrException = PyErr_NewException("MacOS.Error", NULL, NULL); + return PyMac_OSErrException; +} + +/* Set a MAC-specific error from errno, and return NULL; return None if no error */ +PyObject * +PyErr_Mac(PyObject *eobj, int err) +{ + char *msg; + PyObject *v; + + if (err == 0 && !PyErr_Occurred()) { + Py_INCREF(Py_None); + return Py_None; + } + if (err == -1 && PyErr_Occurred()) + return NULL; + msg = PyMac_StrError(err); + v = Py_BuildValue("(is)", err, msg); + PyErr_SetObject(eobj, v); + Py_DECREF(v); + return NULL; +} + +/* Call PyErr_Mac with PyMac_OSErrException */ +PyObject * +PyMac_Error(OSErr err) +{ + return PyErr_Mac(PyMac_GetOSErrException(), err); +} + + +#ifndef __LP64__ +OSErr +PyMac_GetFullPathname(FSSpec *fss, char *path, int len) +{ + PyObject *fs, *exc; + PyObject *rv = NULL; + char *input; + OSErr err = noErr; + + *path = '\0'; + + fs = PyMac_BuildFSSpec(fss); + if (!fs) + goto error; + + rv = PyObject_CallMethod(fs, "as_pathname", ""); + if (!rv) + goto error; + + input = PyString_AsString(rv); + if (!input) + goto error; + + strncpy(path, input, len - 1); + path[len - 1] = '\0'; + + Py_XDECREF(rv); + Py_XDECREF(fs); + return err; + + error: + exc = PyErr_Occurred(); + if (exc && PyErr_GivenExceptionMatches(exc, + PyMac_GetOSErrException())) { + PyObject *args = PyObject_GetAttrString(exc, "args"); + if (args) { + char *ignore; + PyArg_ParseTuple(args, "is", &err, &ignore); + Py_XDECREF(args); + } + } + if (err == noErr) + err = -1; + PyErr_Clear(); + Py_XDECREF(rv); + Py_XDECREF(fs); + return err; +} +#endif /* !__LP64__ */ + +/* Convert a 4-char string object argument to an OSType value */ +int +PyMac_GetOSType(PyObject *v, OSType *pr) +{ + uint32_t tmp; + if (!PyString_Check(v) || PyString_Size(v) != 4) { + PyErr_SetString(PyExc_TypeError, + "OSType arg must be string of 4 chars"); + return 0; + } + memcpy((char *)&tmp, PyString_AsString(v), 4); + *pr = (OSType)ntohl(tmp); + return 1; +} + +/* Convert an OSType value to a 4-char string object */ +PyObject * +PyMac_BuildOSType(OSType t) +{ + uint32_t tmp = htonl((uint32_t)t); + return PyString_FromStringAndSize((char *)&tmp, 4); +} + +/* Convert an NumVersion value to a 4-element tuple */ +PyObject * +PyMac_BuildNumVersion(NumVersion t) +{ + return Py_BuildValue("(hhhh)", t.majorRev, t.minorAndBugRev, t.stage, t.nonRelRev); +} + + +/* Convert a Python string object to a Str255 */ +int +PyMac_GetStr255(PyObject *v, Str255 pbuf) +{ + int len; + if (!PyString_Check(v) || (len = PyString_Size(v)) > 255) { + PyErr_SetString(PyExc_TypeError, + "Str255 arg must be string of at most 255 chars"); + return 0; + } + pbuf[0] = len; + memcpy((char *)(pbuf+1), PyString_AsString(v), len); + return 1; +} + +/* Convert a Str255 to a Python string object */ +PyObject * +PyMac_BuildStr255(Str255 s) +{ + if ( s == NULL ) { + PyErr_SetString(PyExc_SystemError, "Str255 pointer is NULL"); + return NULL; + } + return PyString_FromStringAndSize((char *)&s[1], (int)s[0]); +} + +PyObject * +PyMac_BuildOptStr255(Str255 s) +{ + if ( s == NULL ) { + Py_INCREF(Py_None); + return Py_None; + } + return PyString_FromStringAndSize((char *)&s[1], (int)s[0]); +} + + + +/* Convert a Python object to a Rect. + The object must be a (left, top, right, bottom) tuple. + (This differs from the order in the struct but is consistent with + the arguments to SetRect(), and also with STDWIN). */ +int +PyMac_GetRect(PyObject *v, Rect *r) +{ + return PyArg_Parse(v, "(hhhh)", &r->left, &r->top, &r->right, &r->bottom); +} + +/* Convert a Rect to a Python object */ +PyObject * +PyMac_BuildRect(Rect *r) +{ + return Py_BuildValue("(hhhh)", r->left, r->top, r->right, r->bottom); +} + + +/* Convert a Python object to a Point. + The object must be a (h, v) tuple. + (This differs from the order in the struct but is consistent with + the arguments to SetPoint(), and also with STDWIN). */ +int +PyMac_GetPoint(PyObject *v, Point *p) +{ + return PyArg_Parse(v, "(hh)", &p->h, &p->v); +} + +/* Convert a Point to a Python object */ +PyObject * +PyMac_BuildPoint(Point p) +{ + return Py_BuildValue("(hh)", p.h, p.v); +} + + +/* Convert a Python object to an EventRecord. + The object must be a (what, message, when, (v, h), modifiers) tuple. */ +int +PyMac_GetEventRecord(PyObject *v, EventRecord *e) +{ + return PyArg_Parse(v, "(Hkk(hh)H)", + &e->what, + &e->message, + &e->when, + &e->where.h, + &e->where.v, + &e->modifiers); +} + +/* Convert a Rect to an EventRecord object */ +PyObject * +PyMac_BuildEventRecord(EventRecord *e) +{ + return Py_BuildValue("(hll(hh)h)", + e->what, + e->message, + e->when, + e->where.h, + e->where.v, + e->modifiers); +} + +/* Convert Python object to Fixed */ +int +PyMac_GetFixed(PyObject *v, Fixed *f) +{ + double d; + + if( !PyArg_Parse(v, "d", &d)) + return 0; + *f = (Fixed)(d * 0x10000); + return 1; +} + +/* Convert a Fixed to a Python object */ +PyObject * +PyMac_BuildFixed(Fixed f) +{ + double d; + + d = f; + d = d / 0x10000; + return Py_BuildValue("d", d); +} + +/* Convert wide to/from Python int or (hi, lo) tuple. XXXX Should use Python longs */ +int +PyMac_Getwide(PyObject *v, wide *rv) +{ + if (PyInt_Check(v)) { + rv->hi = 0; + rv->lo = PyInt_AsLong(v); + if( rv->lo & 0x80000000 ) + rv->hi = -1; + return 1; + } + return PyArg_Parse(v, "(kk)", &rv->hi, &rv->lo); +} + + +PyObject * +PyMac_Buildwide(wide *w) +{ + if ( (w->hi == 0 && (w->lo & 0x80000000) == 0) || + (w->hi == -1 && (w->lo & 0x80000000) ) ) + return PyInt_FromLong(w->lo); + return Py_BuildValue("(ll)", w->hi, w->lo); +} + +#ifdef USE_TOOLBOX_OBJECT_GLUE +/* +** Glue together the toolbox objects. +** +** Because toolbox modules interdepend on each other, they use each others +** object types, on MacOSX/MachO this leads to the situation that they +** cannot be dynamically loaded (or they would all have to be lumped into +** a single .so, but this would be bad for extensibility). +** +** This file defines wrappers for all the _New and _Convert functions, +** which are the Py_BuildValue and PyArg_ParseTuple helpers. The wrappers +** check an indirection function pointer, and if it isn't filled in yet +** they import the appropriate module, whose init routine should fill in +** the pointer. +*/ + +#define GLUE_NEW(object, routinename, module) \ +PyObject *(*PyMacGluePtr_##routinename)(object); \ +\ +PyObject *routinename(object cobj) { \ + if (!PyMacGluePtr_##routinename) { \ + if (!PyImport_ImportModule(module)) return NULL; \ + if (!PyMacGluePtr_##routinename) { \ + PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \ + return NULL; \ + } \ + } \ + return (*PyMacGluePtr_##routinename)(cobj); \ +} + +#define GLUE_CONVERT(object, routinename, module) \ +int (*PyMacGluePtr_##routinename)(PyObject *, object *); \ +\ +int routinename(PyObject *pyobj, object *cobj) { \ + if (!PyMacGluePtr_##routinename) { \ + if (!PyImport_ImportModule(module)) return 0; \ + if (!PyMacGluePtr_##routinename) { \ + PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \ + return 0; \ + } \ + } \ + return (*PyMacGluePtr_##routinename)(pyobj, cobj); \ +} + +GLUE_NEW(FSSpec *, PyMac_BuildFSSpec, "Carbon.File") +GLUE_CONVERT(FSSpec, PyMac_GetFSSpec, "Carbon.File") +GLUE_NEW(FSRef *, PyMac_BuildFSRef, "Carbon.File") +GLUE_CONVERT(FSRef, PyMac_GetFSRef, "Carbon.File") + +GLUE_NEW(AppleEvent *, AEDesc_New, "Carbon.AE") /* XXXX Why by address? */ +GLUE_NEW(AppleEvent *, AEDesc_NewBorrowed, "Carbon.AE") +GLUE_CONVERT(AppleEvent, AEDesc_Convert, "Carbon.AE") + +GLUE_NEW(Component, CmpObj_New, "Carbon.Cm") +GLUE_CONVERT(Component, CmpObj_Convert, "Carbon.Cm") +GLUE_NEW(ComponentInstance, CmpInstObj_New, "Carbon.Cm") +GLUE_CONVERT(ComponentInstance, CmpInstObj_Convert, "Carbon.Cm") + +GLUE_NEW(ControlHandle, CtlObj_New, "Carbon.Ctl") +GLUE_CONVERT(ControlHandle, CtlObj_Convert, "Carbon.Ctl") + +GLUE_NEW(DialogPtr, DlgObj_New, "Carbon.Dlg") +GLUE_CONVERT(DialogPtr, DlgObj_Convert, "Carbon.Dlg") +GLUE_NEW(DialogPtr, DlgObj_WhichDialog, "Carbon.Dlg") + +GLUE_NEW(DragReference, DragObj_New, "Carbon.Drag") +GLUE_CONVERT(DragReference, DragObj_Convert, "Carbon.Drag") + +GLUE_NEW(ListHandle, ListObj_New, "Carbon.List") +GLUE_CONVERT(ListHandle, ListObj_Convert, "Carbon.List") + +GLUE_NEW(MenuHandle, MenuObj_New, "Carbon.Menu") +GLUE_CONVERT(MenuHandle, MenuObj_Convert, "Carbon.Menu") + +GLUE_NEW(GrafPtr, GrafObj_New, "Carbon.Qd") +GLUE_CONVERT(GrafPtr, GrafObj_Convert, "Carbon.Qd") +GLUE_NEW(BitMapPtr, BMObj_New, "Carbon.Qd") +GLUE_CONVERT(BitMapPtr, BMObj_Convert, "Carbon.Qd") +GLUE_NEW(RGBColor *, QdRGB_New, "Carbon.Qd") /* XXXX Why? */ +GLUE_CONVERT(RGBColor, QdRGB_Convert, "Carbon.Qd") + +GLUE_NEW(GWorldPtr, GWorldObj_New, "Carbon.Qdoffs") +GLUE_CONVERT(GWorldPtr, GWorldObj_Convert, "Carbon.Qdoffs") + +#ifndef __LP64__ +GLUE_NEW(Track, TrackObj_New, "Carbon.Qt") +GLUE_CONVERT(Track, TrackObj_Convert, "Carbon.Qt") +GLUE_NEW(Movie, MovieObj_New, "Carbon.Qt") +GLUE_CONVERT(Movie, MovieObj_Convert, "Carbon.Qt") +GLUE_NEW(MovieController, MovieCtlObj_New, "Carbon.Qt") +GLUE_CONVERT(MovieController, MovieCtlObj_Convert, "Carbon.Qt") +GLUE_NEW(TimeBase, TimeBaseObj_New, "Carbon.Qt") +GLUE_CONVERT(TimeBase, TimeBaseObj_Convert, "Carbon.Qt") +GLUE_NEW(UserData, UserDataObj_New, "Carbon.Qt") +GLUE_CONVERT(UserData, UserDataObj_Convert, "Carbon.Qt") +GLUE_NEW(Media, MediaObj_New, "Carbon.Qt") +GLUE_CONVERT(Media, MediaObj_Convert, "Carbon.Qt") +#endif /* !__LP64__ */ + +GLUE_NEW(Handle, ResObj_New, "Carbon.Res") +GLUE_CONVERT(Handle, ResObj_Convert, "Carbon.Res") +GLUE_NEW(Handle, OptResObj_New, "Carbon.Res") +GLUE_CONVERT(Handle, OptResObj_Convert, "Carbon.Res") + +GLUE_NEW(TEHandle, TEObj_New, "Carbon.TE") +GLUE_CONVERT(TEHandle, TEObj_Convert, "Carbon.TE") + +GLUE_NEW(WindowPtr, WinObj_New, "Carbon.Win") +GLUE_CONVERT(WindowPtr, WinObj_Convert, "Carbon.Win") +GLUE_NEW(WindowPtr, WinObj_WhichWindow, "Carbon.Win") + +GLUE_CONVERT(CFTypeRef, CFObj_Convert, "Carbon.CF") +GLUE_NEW(CFTypeRef, CFObj_New, "Carbon.CF") + +GLUE_CONVERT(CFTypeRef, CFTypeRefObj_Convert, "Carbon.CF") +GLUE_NEW(CFTypeRef, CFTypeRefObj_New, "Carbon.CF") + +GLUE_CONVERT(CFStringRef, CFStringRefObj_Convert, "Carbon.CF") +GLUE_NEW(CFStringRef, CFStringRefObj_New, "Carbon.CF") +GLUE_CONVERT(CFMutableStringRef, CFMutableStringRefObj_Convert, "Carbon.CF") +GLUE_NEW(CFMutableStringRef, CFMutableStringRefObj_New, "Carbon.CF") + +GLUE_CONVERT(CFArrayRef, CFArrayRefObj_Convert, "Carbon.CF") +GLUE_NEW(CFArrayRef, CFArrayRefObj_New, "Carbon.CF") +GLUE_CONVERT(CFMutableArrayRef, CFMutableArrayRefObj_Convert, "Carbon.CF") +GLUE_NEW(CFMutableArrayRef, CFMutableArrayRefObj_New, "Carbon.CF") + +GLUE_CONVERT(CFDictionaryRef, CFDictionaryRefObj_Convert, "Carbon.CF") +GLUE_NEW(CFDictionaryRef, CFDictionaryRefObj_New, "Carbon.CF") +GLUE_CONVERT(CFMutableDictionaryRef, CFMutableDictionaryRefObj_Convert, "Carbon.CF") +GLUE_NEW(CFMutableDictionaryRef, CFMutableDictionaryRefObj_New, "Carbon.CF") + +GLUE_CONVERT(CFURLRef, CFURLRefObj_Convert, "Carbon.CF") +GLUE_CONVERT(CFURLRef, OptionalCFURLRefObj_Convert, "Carbon.CF") +GLUE_NEW(CFURLRef, CFURLRefObj_New, "Carbon.CF") + +#endif /* USE_TOOLBOX_OBJECT_GLUE */