1/*********************************************************** 2Copyright 1991-1997 by Stichting Mathematisch Centrum, Amsterdam, 3The Netherlands. 4 5 All Rights Reserved 6 7Permission to use, copy, modify, and distribute this software and its 8documentation for any purpose and without fee is hereby granted, 9provided that the above copyright notice appear in all copies and that 10both that copyright notice and this permission notice appear in 11supporting documentation, and that the names of Stichting Mathematisch 12Centrum or CWI not be used in advertising or publicity pertaining to 13distribution of the software without specific, written prior permission. 14 15STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO 16THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 17FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE 18FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 19WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 20ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 21OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 22 23******************************************************************/ 24 25 26#include "Python.h" 27#include "pymactoolbox.h" 28#include <arpa/inet.h> /* for ntohl, htonl */ 29 30 31/* Like strerror() but for Mac OS error numbers */ 32char * 33PyMac_StrError(int err) 34{ 35 static char buf[256]; 36 PyObject *m; 37 PyObject *rv; 38 39 m = PyImport_ImportModuleNoBlock("MacOS"); 40 if (!m) { 41 if (Py_VerboseFlag) 42 PyErr_Print(); 43 PyErr_Clear(); 44 rv = NULL; 45 } 46 else { 47 rv = PyObject_CallMethod(m, "GetErrorString", "i", err); 48 if (!rv) 49 PyErr_Clear(); 50 } 51 if (!rv) { 52 buf[0] = '\0'; 53 } 54 else { 55 char *input = PyString_AsString(rv); 56 if (!input) { 57 PyErr_Clear(); 58 buf[0] = '\0'; 59 } else { 60 strncpy(buf, input, sizeof(buf) - 1); 61 buf[sizeof(buf) - 1] = '\0'; 62 } 63 Py_DECREF(rv); 64 } 65 Py_XDECREF(m); 66 return buf; 67} 68 69/* Exception object shared by all Mac specific modules for Mac OS errors */ 70PyObject *PyMac_OSErrException; 71 72/* Initialize and return PyMac_OSErrException */ 73PyObject * 74PyMac_GetOSErrException(void) 75{ 76 if (PyMac_OSErrException == NULL) 77 PyMac_OSErrException = PyErr_NewException("MacOS.Error", NULL, NULL); 78 return PyMac_OSErrException; 79} 80 81/* Set a MAC-specific error from errno, and return NULL; return None if no error */ 82PyObject * 83PyErr_Mac(PyObject *eobj, int err) 84{ 85 char *msg; 86 PyObject *v; 87 88 if (err == 0 && !PyErr_Occurred()) { 89 Py_INCREF(Py_None); 90 return Py_None; 91 } 92 if (err == -1 && PyErr_Occurred()) 93 return NULL; 94 msg = PyMac_StrError(err); 95 v = Py_BuildValue("(is)", err, msg); 96 PyErr_SetObject(eobj, v); 97 Py_DECREF(v); 98 return NULL; 99} 100 101/* Call PyErr_Mac with PyMac_OSErrException */ 102PyObject * 103PyMac_Error(OSErr err) 104{ 105 return PyErr_Mac(PyMac_GetOSErrException(), err); 106} 107 108 109#if APPLE_SUPPORTS_QUICKTIME 110OSErr 111PyMac_GetFullPathname(FSSpec *fss, char *path, int len) 112{ 113 PyObject *fs, *exc; 114 PyObject *rv = NULL; 115 char *input; 116 OSErr err = noErr; 117 118 *path = '\0'; 119 120 fs = PyMac_BuildFSSpec(fss); 121 if (!fs) 122 goto error; 123 124 rv = PyObject_CallMethod(fs, "as_pathname", ""); 125 if (!rv) 126 goto error; 127 128 input = PyString_AsString(rv); 129 if (!input) 130 goto error; 131 132 strncpy(path, input, len - 1); 133 path[len - 1] = '\0'; 134 135 Py_XDECREF(rv); 136 Py_XDECREF(fs); 137 return err; 138 139 error: 140 exc = PyErr_Occurred(); 141 if (exc && PyErr_GivenExceptionMatches(exc, 142 PyMac_GetOSErrException())) { 143 PyObject *args = PyObject_GetAttrString(exc, "args"); 144 if (args) { 145 char *ignore; 146 PyArg_ParseTuple(args, "is", &err, &ignore); 147 Py_XDECREF(args); 148 } 149 } 150 if (err == noErr) 151 err = -1; 152 PyErr_Clear(); 153 Py_XDECREF(rv); 154 Py_XDECREF(fs); 155 return err; 156} 157#endif /* APPLE_SUPPORTS_QUICKTIME */ 158 159/* Convert a 4-char string object argument to an OSType value */ 160int 161PyMac_GetOSType(PyObject *v, OSType *pr) 162{ 163 uint32_t tmp; 164 if (!PyString_Check(v) || PyString_Size(v) != 4) { 165 PyErr_SetString(PyExc_TypeError, 166 "OSType arg must be string of 4 chars"); 167 return 0; 168 } 169 memcpy((char *)&tmp, PyString_AsString(v), 4); 170 *pr = (OSType)ntohl(tmp); 171 return 1; 172} 173 174/* Convert an OSType value to a 4-char string object */ 175PyObject * 176PyMac_BuildOSType(OSType t) 177{ 178 uint32_t tmp = htonl((uint32_t)t); 179 return PyString_FromStringAndSize((char *)&tmp, 4); 180} 181 182/* Convert an NumVersion value to a 4-element tuple */ 183PyObject * 184PyMac_BuildNumVersion(NumVersion t) 185{ 186 return Py_BuildValue("(hhhh)", t.majorRev, t.minorAndBugRev, t.stage, t.nonRelRev); 187} 188 189 190/* Convert a Python string object to a Str255 */ 191int 192PyMac_GetStr255(PyObject *v, Str255 pbuf) 193{ 194 int len; 195 if (!PyString_Check(v) || (len = PyString_Size(v)) > 255) { 196 PyErr_SetString(PyExc_TypeError, 197 "Str255 arg must be string of at most 255 chars"); 198 return 0; 199 } 200 pbuf[0] = len; 201 memcpy((char *)(pbuf+1), PyString_AsString(v), len); 202 return 1; 203} 204 205/* Convert a Str255 to a Python string object */ 206PyObject * 207PyMac_BuildStr255(Str255 s) 208{ 209 if ( s == NULL ) { 210 PyErr_SetString(PyExc_SystemError, "Str255 pointer is NULL"); 211 return NULL; 212 } 213 return PyString_FromStringAndSize((char *)&s[1], (int)s[0]); 214} 215 216PyObject * 217PyMac_BuildOptStr255(Str255 s) 218{ 219 if ( s == NULL ) { 220 Py_INCREF(Py_None); 221 return Py_None; 222 } 223 return PyString_FromStringAndSize((char *)&s[1], (int)s[0]); 224} 225 226 227 228/* Convert a Python object to a Rect. 229 The object must be a (left, top, right, bottom) tuple. 230 (This differs from the order in the struct but is consistent with 231 the arguments to SetRect(), and also with STDWIN). */ 232int 233PyMac_GetRect(PyObject *v, Rect *r) 234{ 235 return PyArg_Parse(v, "(hhhh)", &r->left, &r->top, &r->right, &r->bottom); 236} 237 238/* Convert a Rect to a Python object */ 239PyObject * 240PyMac_BuildRect(Rect *r) 241{ 242 return Py_BuildValue("(hhhh)", r->left, r->top, r->right, r->bottom); 243} 244 245 246/* Convert a Python object to a Point. 247 The object must be a (h, v) tuple. 248 (This differs from the order in the struct but is consistent with 249 the arguments to SetPoint(), and also with STDWIN). */ 250int 251PyMac_GetPoint(PyObject *v, Point *p) 252{ 253 return PyArg_Parse(v, "(hh)", &p->h, &p->v); 254} 255 256/* Convert a Point to a Python object */ 257PyObject * 258PyMac_BuildPoint(Point p) 259{ 260 return Py_BuildValue("(hh)", p.h, p.v); 261} 262 263 264/* Convert a Python object to an EventRecord. 265 The object must be a (what, message, when, (v, h), modifiers) tuple. */ 266int 267PyMac_GetEventRecord(PyObject *v, EventRecord *e) 268{ 269 return PyArg_Parse(v, "(Hkk(hh)H)", 270 &e->what, 271 &e->message, 272 &e->when, 273 &e->where.h, 274 &e->where.v, 275 &e->modifiers); 276} 277 278/* Convert a Rect to an EventRecord object */ 279PyObject * 280PyMac_BuildEventRecord(EventRecord *e) 281{ 282 return Py_BuildValue("(hll(hh)h)", 283 e->what, 284 e->message, 285 e->when, 286 e->where.h, 287 e->where.v, 288 e->modifiers); 289} 290 291/* Convert Python object to Fixed */ 292int 293PyMac_GetFixed(PyObject *v, Fixed *f) 294{ 295 double d; 296 297 if( !PyArg_Parse(v, "d", &d)) 298 return 0; 299 *f = (Fixed)(d * 0x10000); 300 return 1; 301} 302 303/* Convert a Fixed to a Python object */ 304PyObject * 305PyMac_BuildFixed(Fixed f) 306{ 307 double d; 308 309 d = f; 310 d = d / 0x10000; 311 return Py_BuildValue("d", d); 312} 313 314/* Convert wide to/from Python int or (hi, lo) tuple. XXXX Should use Python longs */ 315int 316PyMac_Getwide(PyObject *v, wide *rv) 317{ 318 if (PyInt_Check(v)) { 319 rv->hi = 0; 320 rv->lo = PyInt_AsLong(v); 321 if( rv->lo & 0x80000000 ) 322 rv->hi = -1; 323 return 1; 324 } 325 return PyArg_Parse(v, "(kk)", &rv->hi, &rv->lo); 326} 327 328 329PyObject * 330PyMac_Buildwide(wide *w) 331{ 332 if ( (w->hi == 0 && (w->lo & 0x80000000) == 0) || 333 (w->hi == -1 && (w->lo & 0x80000000) ) ) 334 return PyInt_FromLong(w->lo); 335 return Py_BuildValue("(ll)", w->hi, w->lo); 336} 337 338#ifdef USE_TOOLBOX_OBJECT_GLUE 339/* 340** Glue together the toolbox objects. 341** 342** Because toolbox modules interdepend on each other, they use each others 343** object types, on MacOSX/MachO this leads to the situation that they 344** cannot be dynamically loaded (or they would all have to be lumped into 345** a single .so, but this would be bad for extensibility). 346** 347** This file defines wrappers for all the _New and _Convert functions, 348** which are the Py_BuildValue and PyArg_ParseTuple helpers. The wrappers 349** check an indirection function pointer, and if it isn't filled in yet 350** they import the appropriate module, whose init routine should fill in 351** the pointer. 352*/ 353 354#define GLUE_NEW(object, routinename, module) \ 355PyObject *(*PyMacGluePtr_##routinename)(object); \ 356\ 357PyObject *routinename(object cobj) { \ 358 if (!PyMacGluePtr_##routinename) { \ 359 if (!PyImport_ImportModule(module)) return NULL; \ 360 if (!PyMacGluePtr_##routinename) { \ 361 PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \ 362 return NULL; \ 363 } \ 364 } \ 365 return (*PyMacGluePtr_##routinename)(cobj); \ 366} 367 368#define GLUE_CONVERT(object, routinename, module) \ 369int (*PyMacGluePtr_##routinename)(PyObject *, object *); \ 370\ 371int routinename(PyObject *pyobj, object *cobj) { \ 372 if (!PyMacGluePtr_##routinename) { \ 373 if (!PyImport_ImportModule(module)) return 0; \ 374 if (!PyMacGluePtr_##routinename) { \ 375 PyErr_SetString(PyExc_ImportError, "Module did not provide routine: " module ": " #routinename); \ 376 return 0; \ 377 } \ 378 } \ 379 return (*PyMacGluePtr_##routinename)(pyobj, cobj); \ 380} 381 382GLUE_NEW(FSSpec *, PyMac_BuildFSSpec, "Carbon.File") 383GLUE_CONVERT(FSSpec, PyMac_GetFSSpec, "Carbon.File") 384GLUE_NEW(FSRef *, PyMac_BuildFSRef, "Carbon.File") 385GLUE_CONVERT(FSRef, PyMac_GetFSRef, "Carbon.File") 386 387GLUE_NEW(AppleEvent *, AEDesc_New, "Carbon.AE") /* XXXX Why by address? */ 388GLUE_NEW(AppleEvent *, AEDesc_NewBorrowed, "Carbon.AE") 389GLUE_CONVERT(AppleEvent, AEDesc_Convert, "Carbon.AE") 390 391GLUE_NEW(Component, CmpObj_New, "Carbon.Cm") 392GLUE_CONVERT(Component, CmpObj_Convert, "Carbon.Cm") 393GLUE_NEW(ComponentInstance, CmpInstObj_New, "Carbon.Cm") 394GLUE_CONVERT(ComponentInstance, CmpInstObj_Convert, "Carbon.Cm") 395 396GLUE_NEW(ControlHandle, CtlObj_New, "Carbon.Ctl") 397GLUE_CONVERT(ControlHandle, CtlObj_Convert, "Carbon.Ctl") 398 399GLUE_NEW(DialogPtr, DlgObj_New, "Carbon.Dlg") 400GLUE_CONVERT(DialogPtr, DlgObj_Convert, "Carbon.Dlg") 401GLUE_NEW(DialogPtr, DlgObj_WhichDialog, "Carbon.Dlg") 402 403GLUE_NEW(DragReference, DragObj_New, "Carbon.Drag") 404GLUE_CONVERT(DragReference, DragObj_Convert, "Carbon.Drag") 405 406GLUE_NEW(ListHandle, ListObj_New, "Carbon.List") 407GLUE_CONVERT(ListHandle, ListObj_Convert, "Carbon.List") 408 409GLUE_NEW(MenuHandle, MenuObj_New, "Carbon.Menu") 410GLUE_CONVERT(MenuHandle, MenuObj_Convert, "Carbon.Menu") 411 412GLUE_NEW(GrafPtr, GrafObj_New, "Carbon.Qd") 413GLUE_CONVERT(GrafPtr, GrafObj_Convert, "Carbon.Qd") 414GLUE_NEW(BitMapPtr, BMObj_New, "Carbon.Qd") 415GLUE_CONVERT(BitMapPtr, BMObj_Convert, "Carbon.Qd") 416GLUE_NEW(RGBColor *, QdRGB_New, "Carbon.Qd") /* XXXX Why? */ 417GLUE_CONVERT(RGBColor, QdRGB_Convert, "Carbon.Qd") 418 419GLUE_NEW(GWorldPtr, GWorldObj_New, "Carbon.Qdoffs") 420GLUE_CONVERT(GWorldPtr, GWorldObj_Convert, "Carbon.Qdoffs") 421 422#if APPLE_SUPPORTS_QUICKTIME 423GLUE_NEW(Track, TrackObj_New, "Carbon.Qt") 424GLUE_CONVERT(Track, TrackObj_Convert, "Carbon.Qt") 425GLUE_NEW(Movie, MovieObj_New, "Carbon.Qt") 426GLUE_CONVERT(Movie, MovieObj_Convert, "Carbon.Qt") 427GLUE_NEW(MovieController, MovieCtlObj_New, "Carbon.Qt") 428GLUE_CONVERT(MovieController, MovieCtlObj_Convert, "Carbon.Qt") 429GLUE_NEW(TimeBase, TimeBaseObj_New, "Carbon.Qt") 430GLUE_CONVERT(TimeBase, TimeBaseObj_Convert, "Carbon.Qt") 431GLUE_NEW(UserData, UserDataObj_New, "Carbon.Qt") 432GLUE_CONVERT(UserData, UserDataObj_Convert, "Carbon.Qt") 433GLUE_NEW(Media, MediaObj_New, "Carbon.Qt") 434GLUE_CONVERT(Media, MediaObj_Convert, "Carbon.Qt") 435#endif /* APPLE_SUPPORTS_QUICKTIME */ 436 437GLUE_NEW(Handle, ResObj_New, "Carbon.Res") 438GLUE_CONVERT(Handle, ResObj_Convert, "Carbon.Res") 439GLUE_NEW(Handle, OptResObj_New, "Carbon.Res") 440GLUE_CONVERT(Handle, OptResObj_Convert, "Carbon.Res") 441 442GLUE_NEW(TEHandle, TEObj_New, "Carbon.TE") 443GLUE_CONVERT(TEHandle, TEObj_Convert, "Carbon.TE") 444 445GLUE_NEW(WindowPtr, WinObj_New, "Carbon.Win") 446GLUE_CONVERT(WindowPtr, WinObj_Convert, "Carbon.Win") 447GLUE_NEW(WindowPtr, WinObj_WhichWindow, "Carbon.Win") 448 449GLUE_CONVERT(CFTypeRef, CFObj_Convert, "Carbon.CF") 450GLUE_NEW(CFTypeRef, CFObj_New, "Carbon.CF") 451 452GLUE_CONVERT(CFTypeRef, CFTypeRefObj_Convert, "Carbon.CF") 453GLUE_NEW(CFTypeRef, CFTypeRefObj_New, "Carbon.CF") 454 455GLUE_CONVERT(CFStringRef, CFStringRefObj_Convert, "Carbon.CF") 456GLUE_NEW(CFStringRef, CFStringRefObj_New, "Carbon.CF") 457GLUE_CONVERT(CFMutableStringRef, CFMutableStringRefObj_Convert, "Carbon.CF") 458GLUE_NEW(CFMutableStringRef, CFMutableStringRefObj_New, "Carbon.CF") 459 460GLUE_CONVERT(CFArrayRef, CFArrayRefObj_Convert, "Carbon.CF") 461GLUE_NEW(CFArrayRef, CFArrayRefObj_New, "Carbon.CF") 462GLUE_CONVERT(CFMutableArrayRef, CFMutableArrayRefObj_Convert, "Carbon.CF") 463GLUE_NEW(CFMutableArrayRef, CFMutableArrayRefObj_New, "Carbon.CF") 464 465GLUE_CONVERT(CFDictionaryRef, CFDictionaryRefObj_Convert, "Carbon.CF") 466GLUE_NEW(CFDictionaryRef, CFDictionaryRefObj_New, "Carbon.CF") 467GLUE_CONVERT(CFMutableDictionaryRef, CFMutableDictionaryRefObj_Convert, "Carbon.CF") 468GLUE_NEW(CFMutableDictionaryRef, CFMutableDictionaryRefObj_New, "Carbon.CF") 469 470GLUE_CONVERT(CFURLRef, CFURLRefObj_Convert, "Carbon.CF") 471GLUE_CONVERT(CFURLRef, OptionalCFURLRefObj_Convert, "Carbon.CF") 472GLUE_NEW(CFURLRef, CFURLRefObj_New, "Carbon.CF") 473 474#endif /* USE_TOOLBOX_OBJECT_GLUE */ 475