Mac/Modules/MacOS.c

   1 /***********************************************************
   2 Copyright 1991-1997 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI not be used in advertising or publicity pertaining to
  13 distribution of the software without specific, written prior permission.
  14
  15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23 ******************************************************************/
  24
  25 /* Macintosh OS-specific interface */
  26
  27 #include "Python.h"
  28 #include "pymactoolbox.h"
  29
  30 #include <Carbon/Carbon.h>
  31 #include <ApplicationServices/ApplicationServices.h>
  32
  33 #ifndef HAVE_MACOS105_SDK
  34 typedef SInt16  FSIORefNum;
  35 #endif
  36
  37 static PyObject *MacOS_Error; /* Exception MacOS.Error */
  38
  39 #define PATHNAMELEN 1024
  40
  41 /* ----------------------------------------------------- */
  42
  43 /* Declarations for objects of type Resource fork */
  44
  45 typedef struct {
  46         PyObject_HEAD
  47         FSIORefNum fRefNum;
  48         int isclosed;
  49 } rfobject;
  50
  51 static PyTypeObject Rftype;
  52
  53
  54
  55 /* ---------------------------------------------------------------- */
  56
  57 static void
  58 do_close(rfobject *self)
  59 {
  60         if (self->isclosed ) return;
  61         (void)FSCloseFork(self->fRefNum);
  62         self->isclosed = 1;
  63 }
  64
  65 static char rf_read__doc__[] =
  66 "Read data from resource fork"
  67 ;
  68
  69 static PyObject *
  70 rf_read(rfobject *self, PyObject *args)
  71 {
  72         long n;
  73         PyObject *v;
  74         OSErr err;
  75         ByteCount n2;
  76
  77         if (self->isclosed) {
  78                 PyErr_SetString(PyExc_ValueError, "Operation on closed file");
  79                 return NULL;
  80         }
  81
  82         if (!PyArg_ParseTuple(args, "l", &n))
  83                 return NULL;
  84
  85         v = PyBytes_FromStringAndSize((char *)NULL, n);
  86         if (v == NULL)
  87                 return NULL;
  88
  89         err = FSReadFork(self->fRefNum, fsAtMark, 0, n, PyString_AsString(v), &n2);
  90         if (err && err != eofErr) {
  91                 PyMac_Error(err);
  92                 Py_DECREF(v);
  93                 return NULL;
  94         }
  95         _PyString_Resize(&v, n2);
  96         return v;
  97 }
  98
  99
 100 static char rf_write__doc__[] =
 101 "Write to resource fork"
 102 ;
 103
 104 static PyObject *
 105 rf_write(rfobject *self, PyObject *args)
 106 {
 107         char *buffer;
 108         long size;
 109         OSErr err;
 110
 111         if (self->isclosed) {
 112                 PyErr_SetString(PyExc_ValueError, "Operation on closed file");
 113                 return NULL;
 114         }
 115         if (!PyArg_ParseTuple(args, "s#", &buffer, &size))
 116                 return NULL;
 117         err = FSWriteFork(self->fRefNum, fsAtMark, 0, size, buffer, NULL);
 118         if (err) {
 119                 PyMac_Error(err);
 120                 return NULL;
 121         }
 122         Py_INCREF(Py_None);
 123         return Py_None;
 124 }
 125
 126
 127 static char rf_seek__doc__[] =
 128 "Set file position"
 129 ;
 130
 131 static PyObject *
 132 rf_seek(rfobject *self, PyObject *args)
 133 {
 134         long amount;
 135         int whence = SEEK_SET;
 136         int mode;
 137         OSErr err;
 138
 139         if (self->isclosed) {
 140                 PyErr_SetString(PyExc_ValueError, "Operation on closed file");
 141                 return NULL;
 142         }
 143         if (!PyArg_ParseTuple(args, "l|i", &amount, &whence)) {
 144                 return NULL;
 145         }
 146
 147         switch (whence) {
 148         case SEEK_CUR:
 149                 mode = fsFromMark;
 150                 break;
 151         case SEEK_END:
 152                 mode = fsFromLEOF;
 153                 break;
 154         case SEEK_SET:
 155                 mode = fsFromStart;
 156                 break;
 157         default:
 158                 PyErr_BadArgument();
 159                 return NULL;
 160         }
 161
 162         err = FSSetForkPosition(self->fRefNum, mode, amount);
 163         if (err != noErr) {
 164                 PyMac_Error(err);
 165                 return NULL;
 166         }
 167         Py_INCREF(Py_None);
 168         return Py_None;
 169 }
 170
 171
 172 static char rf_tell__doc__[] =
 173 "Get file position"
 174 ;
 175
 176 static PyObject *
 177 rf_tell(rfobject *self, PyObject *args)
 178 {
 179         long long where;
 180         OSErr err;
 181
 182         if (self->isclosed) {
 183                 PyErr_SetString(PyExc_ValueError, "Operation on closed file");
 184                 return NULL;
 185         }
 186         if (!PyArg_ParseTuple(args, ""))
 187                 return NULL;
 188
 189         err = FSGetForkPosition(self->fRefNum, &where);
 190         if (err != noErr) {
 191                 PyMac_Error(err);
 192                 return NULL;
 193         }
 194         return PyLong_FromLongLong(where);
 195 }
 196
 197 static char rf_close__doc__[] =
 198 "Close resource fork"
 199 ;
 200
 201 static PyObject *
 202 rf_close(rfobject *self, PyObject *args)
 203 {
 204         if (!PyArg_ParseTuple(args, ""))
 205                 return NULL;
 206         do_close(self);
 207         Py_INCREF(Py_None);
 208         return Py_None;
 209 }
 210
 211
 212 static struct PyMethodDef rf_methods[] = {
 213  {"read",       (PyCFunction)rf_read,   1,      rf_read__doc__},
 214  {"write",      (PyCFunction)rf_write,  1,      rf_write__doc__},
 215  {"seek",       (PyCFunction)rf_seek,   1,      rf_seek__doc__},
 216  {"tell",       (PyCFunction)rf_tell,   1,      rf_tell__doc__},
 217  {"close",      (PyCFunction)rf_close,  1,      rf_close__doc__},
 218
 219         {NULL,          NULL}           /* sentinel */
 220 };
 221
 222 /* ---------- */
 223
 224
 225 static rfobject *
 226 newrfobject(void)
 227 {
 228         rfobject *self;
 229
 230         self = PyObject_NEW(rfobject, &Rftype);
 231         if (self == NULL)
 232                 return NULL;
 233         self->isclosed = 1;
 234         return self;
 235 }
 236
 237
 238 static void
 239 rf_dealloc(rfobject *self)
 240 {
 241         do_close(self);
 242         PyObject_DEL(self);
 243 }
 244
 245 static PyObject *
 246 rf_getattr(rfobject *self, char *name)
 247 {
 248         return Py_FindMethod(rf_methods, (PyObject *)self, name);
 249 }
 250
 251 static char Rftype__doc__[] =
 252 "Resource fork file object"
 253 ;
 254
 255 static PyTypeObject Rftype = {
 256         PyObject_HEAD_INIT(&PyType_Type)
 257         0,                              /*ob_size*/
 258         "MacOS.ResourceFork",           /*tp_name*/
 259         sizeof(rfobject),               /*tp_basicsize*/
 260         0,                              /*tp_itemsize*/
 261         /* methods */
 262         (destructor)rf_dealloc, /*tp_dealloc*/
 263         (printfunc)0,           /*tp_print*/
 264         (getattrfunc)rf_getattr,        /*tp_getattr*/
 265         (setattrfunc)0, /*tp_setattr*/
 266         (cmpfunc)0,             /*tp_compare*/
 267         (reprfunc)0,            /*tp_repr*/
 268         0,                      /*tp_as_number*/
 269         0,              /*tp_as_sequence*/
 270         0,              /*tp_as_mapping*/
 271         (hashfunc)0,            /*tp_hash*/
 272         (ternaryfunc)0,         /*tp_call*/
 273         (reprfunc)0,            /*tp_str*/
 274
 275         /* Space for future expansion */
 276         0L,0L,0L,0L,
 277         Rftype__doc__ /* Documentation string */
 278 };
 279
 280
 281 /* End of code for Resource fork objects */
 282 /* -------------------------------------------------------- */
 283
 284 /*----------------------------------------------------------------------*/
 285 /* Miscellaneous File System Operations */
 286
 287 static char getcrtp_doc[] = "Get MacOS 4-char creator and type for a file";
 288
 289 static PyObject *
 290 MacOS_GetCreatorAndType(PyObject *self, PyObject *args)
 291 {
 292         PyObject *creator, *type, *res;
 293         OSErr err;
 294         FSRef ref;
 295         FSCatalogInfo   cataloginfo;
 296         FileInfo* finfo;
 297
 298         if (!PyArg_ParseTuple(args, "O&", PyMac_GetFSRef, &ref)) {
 299 #ifndef __LP64__
 300                 /* This function is documented to take an FSSpec as well,
 301                  * which only works in 32-bit mode.
 302                  */
 303                 PyErr_Clear();
 304                 FSSpec fss;
 305                 FInfo info;
 306
 307                 if (!PyArg_ParseTuple(args, "O&", PyMac_GetFSSpec, &fss))
 308                         return NULL;
 309
 310                 if ((err = FSpGetFInfo(&fss, &info)) != noErr) {
 311                         return PyErr_Mac(MacOS_Error, err);
 312                 }
 313                 creator = PyString_FromStringAndSize(
 314                                 (char *)&info.fdCreator, 4);
 315                 type = PyString_FromStringAndSize((char *)&info.fdType, 4);
 316                 res = Py_BuildValue("OO", creator, type);
 317                 Py_DECREF(creator);
 318                 Py_DECREF(type);
 319                 return res;
 320 #else   /* __LP64__ */
 321                 return NULL;
 322 #endif  /* __LP64__ */
 323         }
 324
 325         err = FSGetCatalogInfo(&ref,
 326                         kFSCatInfoFinderInfo|kFSCatInfoNodeFlags, &cataloginfo,
 327                         NULL, NULL, NULL);
 328         if (err != noErr) {
 329                 PyErr_Mac(MacOS_Error, err);
 330                 return NULL;
 331         }
 332
 333         if ((cataloginfo.nodeFlags & kFSNodeIsDirectoryMask) != 0) {
 334                 /* Directory: doesn't have type/creator info.
 335                  *
 336                  * The specific error code is for backward compatibility with
 337                  * earlier versions.
 338                  */
 339                 PyErr_Mac(MacOS_Error, fnfErr);
 340                 return NULL;
 341
 342         }
 343         finfo = (FileInfo*)&(cataloginfo.finderInfo);
 344         creator = PyString_FromStringAndSize((char*)&(finfo->fileCreator), 4);
 345         type = PyString_FromStringAndSize((char*)&(finfo->fileType), 4);
 346
 347         res = Py_BuildValue("OO", creator, type);
 348         Py_DECREF(creator);
 349         Py_DECREF(type);
 350         return res;
 351 }
 352
 353 static char setcrtp_doc[] = "Set MacOS 4-char creator and type for a file";
 354
 355 static PyObject *
 356 MacOS_SetCreatorAndType(PyObject *self, PyObject *args)
 357 {
 358         ResType creator, type;
 359         FSRef ref;
 360         FileInfo* finfo;
 361         OSErr err;
 362         FSCatalogInfo   cataloginfo;
 363
 364         if (!PyArg_ParseTuple(args, "O&O&O&",
 365                         PyMac_GetFSRef, &ref, PyMac_GetOSType, &creator, PyMac_GetOSType, &type)) {
 366 #ifndef __LP64__
 367                 /* Try to handle FSSpec arguments, for backward compatibility */
 368                 FSSpec fss;
 369                 FInfo info;
 370
 371                 if (!PyArg_ParseTuple(args, "O&O&O&",
 372                         PyMac_GetFSSpec, &fss, PyMac_GetOSType, &creator, PyMac_GetOSType, &type))
 373                         return NULL;
 374
 375                 if ((err = FSpGetFInfo(&fss, &info)) != noErr)
 376                         return PyErr_Mac(MacOS_Error, err);
 377
 378                 info.fdCreator = creator;
 379                 info.fdType = type;
 380
 381                 if ((err = FSpSetFInfo(&fss, &info)) != noErr)
 382                         return PyErr_Mac(MacOS_Error, err);
 383                 Py_INCREF(Py_None);
 384                 return Py_None;
 385 #else /* __LP64__ */
 386                 return NULL;
 387 #endif /* __LP64__ */
 388         }
 389
 390         err = FSGetCatalogInfo(&ref,
 391                         kFSCatInfoFinderInfo|kFSCatInfoNodeFlags, &cataloginfo,
 392                         NULL, NULL, NULL);
 393         if (err != noErr) {
 394                 PyErr_Mac(MacOS_Error, err);
 395                 return NULL;
 396         }
 397
 398         if ((cataloginfo.nodeFlags & kFSNodeIsDirectoryMask) != 0) {
 399                 /* Directory: doesn't have type/creator info.
 400                  *
 401                  * The specific error code is for backward compatibility with
 402                  * earlier versions.
 403                  */
 404                 PyErr_Mac(MacOS_Error, fnfErr);
 405                 return NULL;
 406
 407         }
 408         finfo = (FileInfo*)&(cataloginfo.finderInfo);
 409         finfo->fileCreator = creator;
 410         finfo->fileType = type;
 411
 412         err = FSSetCatalogInfo(&ref, kFSCatInfoFinderInfo, &cataloginfo);
 413         if (err != noErr) {
 414                 PyErr_Mac(MacOS_Error, fnfErr);
 415                 return NULL;
 416         }
 417
 418         Py_INCREF(Py_None);
 419         return Py_None;
 420 }
 421
 422
 423 static char geterr_doc[] = "Convert OSErr number to string";
 424
 425 static PyObject *
 426 MacOS_GetErrorString(PyObject *self, PyObject *args)
 427 {
 428         int err;
 429         char buf[256];
 430         Handle h;
 431         char *str;
 432         static int errors_loaded;
 433
 434         if (!PyArg_ParseTuple(args, "i", &err))
 435                 return NULL;
 436
 437         h = GetResource('Estr', err);
 438         if (!h && !errors_loaded) {
 439                 /*
 440                 ** Attempt to open the resource file containing the
 441                 ** Estr resources. We ignore all errors. We also try
 442                 ** this only once.
 443                 */
 444                 PyObject *m, *rv;
 445                 errors_loaded = 1;
 446
 447                 m = PyImport_ImportModuleNoBlock("macresource");
 448                 if (!m) {
 449                         if (Py_VerboseFlag)
 450                                 PyErr_Print();
 451                         PyErr_Clear();
 452                 }
 453                 else {
 454                         rv = PyObject_CallMethod(m, "open_error_resource", "");
 455                         if (!rv) {
 456                                 if (Py_VerboseFlag)
 457                                         PyErr_Print();
 458                                 PyErr_Clear();
 459                         }
 460                         else {
 461                                 Py_DECREF(rv);
 462                                 /* And try again... */
 463                                 h = GetResource('Estr', err);
 464                         }
 465                         Py_DECREF(m);
 466                 }
 467         }
 468         /*
 469         ** Whether the code above succeeded or not, we won't try
 470         ** again.
 471         */
 472         errors_loaded = 1;
 473
 474         if (h) {
 475                 HLock(h);
 476                 str = (char *)*h;
 477                 memcpy(buf, str+1, (unsigned char)str[0]);
 478                 buf[(unsigned char)str[0]] = '\0';
 479                 HUnlock(h);
 480                 ReleaseResource(h);
 481         }
 482         else {
 483                 PyOS_snprintf(buf, sizeof(buf), "Mac OS error code %d", err);
 484         }
 485
 486         return Py_BuildValue("s", buf);
 487 }
 488
 489
 490 #ifndef __LP64__
 491
 492 static char splash_doc[] = "Open a splash-screen dialog by resource-id (0=close)";
 493
 494 static PyObject *
 495 MacOS_splash(PyObject *self, PyObject *args)
 496 {
 497         int resid = -1;
 498         static DialogPtr curdialog = NULL;
 499         DialogPtr olddialog;
 500         WindowRef theWindow;
 501         CGrafPtr thePort;
 502 #if 0
 503         short xpos, ypos, width, height, swidth, sheight;
 504 #endif
 505
 506         if (!PyArg_ParseTuple(args, "|i", &resid))
 507                 return NULL;
 508         olddialog = curdialog;
 509         curdialog = NULL;
 510
 511         if ( resid != -1 ) {
 512                 curdialog = GetNewDialog(resid, NULL, (WindowPtr)-1);
 513                 if ( curdialog ) {
 514                         theWindow = GetDialogWindow(curdialog);
 515                         thePort = GetWindowPort(theWindow);
 516 #if 0
 517                         width = thePort->portRect.right - thePort->portRect.left;
 518                         height = thePort->portRect.bottom - thePort->portRect.top;
 519                         swidth = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
 520                         sheight = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top - LMGetMBarHeight();
 521                         xpos = (swidth-width)/2;
 522                         ypos = (sheight-height)/5 + LMGetMBarHeight();
 523                         MoveWindow(theWindow, xpos, ypos, 0);
 524                         ShowWindow(theWindow);
 525 #endif
 526                         DrawDialog(curdialog);
 527                 }
 528         }
 529         if (olddialog)
 530                 DisposeDialog(olddialog);
 531         Py_INCREF(Py_None);
 532         return Py_None;
 533 }
 534
 535 static char DebugStr_doc[] = "Switch to low-level debugger with a message";
 536
 537 static PyObject *
 538 MacOS_DebugStr(PyObject *self, PyObject *args)
 539 {
 540         Str255 message;
 541         PyObject *object = 0;
 542
 543         if (!PyArg_ParseTuple(args, "O&|O", PyMac_GetStr255, message, &object))
 544                 return NULL;
 545
 546         DebugStr(message);
 547         Py_INCREF(Py_None);
 548         return Py_None;
 549 }
 550
 551
 552 static char SysBeep_doc[] = "BEEEEEP!!!";
 553
 554 static PyObject *
 555 MacOS_SysBeep(PyObject *self, PyObject *args)
 556 {
 557         int duration = 6;
 558
 559         if (!PyArg_ParseTuple(args, "|i", &duration))
 560                 return NULL;
 561         SysBeep(duration);
 562         Py_INCREF(Py_None);
 563         return Py_None;
 564 }
 565
 566 #endif /* __LP64__ */
 567
 568 static char WMAvailable_doc[] =
 569         "True if this process can interact with the display."
 570         "Will foreground the application on the first call as a side-effect."
 571         ;
 572
 573 static PyObject *
 574 MacOS_WMAvailable(PyObject *self, PyObject *args)
 575 {
 576         static PyObject *rv = NULL;
 577
 578         if (!PyArg_ParseTuple(args, ""))
 579                 return NULL;
 580         if (!rv) {
 581                 ProcessSerialNumber psn;
 582
 583                 /*
 584                 ** This is a fairly innocuous call to make if we don't have a window
 585                 ** manager, or if we have no permission to talk to it. It will print
 586                 ** a message on stderr, but at least it won't abort the process.
 587                 ** It appears the function caches the result itself, and it's cheap, so
 588                 ** no need for us to cache.
 589                 */
 590 #ifdef kCGNullDirectDisplay
 591                 /* On 10.1 CGMainDisplayID() isn't available, and
 592                 ** kCGNullDirectDisplay isn't defined.
 593                 */
 594                 if (CGMainDisplayID() == 0) {
 595                         rv = Py_False;
 596                 } else {
 597 #else
 598                 {
 599 #endif
 600                         if (GetCurrentProcess(&psn) < 0 ||
 601                                 SetFrontProcess(&psn) < 0) {
 602                                 rv = Py_False;
 603                         } else {
 604                                 rv = Py_True;
 605                         }
 606                 }
 607         }
 608         Py_INCREF(rv);
 609         return rv;
 610 }
 611
 612 static char GetTicks_doc[] = "Return number of ticks since bootup";
 613
 614 static PyObject *
 615 MacOS_GetTicks(PyObject *self, PyObject *args)
 616 {
 617         return Py_BuildValue("i", (int)TickCount());
 618 }
 619
 620 static char openrf_doc[] = "Open resource fork of a file";
 621
 622 static PyObject *
 623 MacOS_openrf(PyObject *self, PyObject *args)
 624 {
 625         OSErr err;
 626         char *mode = "r";
 627         FSRef ref;
 628         SInt8 permission = fsRdPerm;
 629         rfobject *fp;
 630         HFSUniStr255 name;
 631
 632         if (!PyArg_ParseTuple(args, "O&|s", PyMac_GetFSRef, &ref, &mode))
 633                 return NULL;
 634         while (*mode) {
 635                 switch (*mode++) {
 636                 case '*': break;
 637                 case 'r': permission = fsRdPerm; break;
 638                 case 'w': permission = fsWrPerm; break;
 639                 case 'b': break;
 640                 default:
 641                         PyErr_BadArgument();
 642                         return NULL;
 643                 }
 644         }
 645
 646         err = FSGetResourceForkName(&name);
 647         if (err != noErr) {
 648                 PyMac_Error(err);
 649                 return NULL;
 650         }
 651
 652         if ( (fp = newrfobject()) == NULL )
 653                 return NULL;
 654
 655
 656         err = FSOpenFork(&ref, name.length, name.unicode, permission, &fp->fRefNum);
 657         if (err != noErr) {
 658                 Py_DECREF(fp);
 659                 PyMac_Error(err);
 660                 return NULL;
 661         }
 662         fp->isclosed = 0;
 663         return (PyObject *)fp;
 664 }
 665
 666
 667
 668 static PyMethodDef MacOS_Methods[] = {
 669         {"GetCreatorAndType",           MacOS_GetCreatorAndType, 1,     getcrtp_doc},
 670         {"SetCreatorAndType",           MacOS_SetCreatorAndType, 1,     setcrtp_doc},
 671         {"GetErrorString",              MacOS_GetErrorString,   1,      geterr_doc},
 672         {"openrf",                      MacOS_openrf,           1,      openrf_doc},
 673 #ifndef __LP64__
 674         {"splash",                      MacOS_splash,           1,      splash_doc},
 675         {"DebugStr",                    MacOS_DebugStr,         1,      DebugStr_doc},
 676         {"SysBeep",                     MacOS_SysBeep,          1,      SysBeep_doc},
 677 #endif /* __LP64__ */
 678         {"GetTicks",                    MacOS_GetTicks,         1,      GetTicks_doc},
 679         {"WMAvailable",                 MacOS_WMAvailable,              1,      WMAvailable_doc},
 680         {NULL,                          NULL}            /* Sentinel */
 681 };
 682
 683
 684 void
 685 initMacOS(void)
 686 {
 687         PyObject *m, *d;
 688
 689         if (PyErr_WarnPy3k("In 3.x, MacOS is removed.", 1))
 690                 return;
 691
 692         m = Py_InitModule("MacOS", MacOS_Methods);
 693         d = PyModule_GetDict(m);
 694
 695         /* Initialize MacOS.Error exception */
 696         MacOS_Error = PyMac_GetOSErrException();
 697         if (MacOS_Error == NULL || PyDict_SetItemString(d, "Error", MacOS_Error) != 0)
 698                 return;
 699         Rftype.ob_type = &PyType_Type;
 700         Py_INCREF(&Rftype);
 701         if (PyDict_SetItemString(d, "ResourceForkType", (PyObject *)&Rftype) != 0)
 702                 return;
 703         /*
 704         ** This is a hack: the following constant added to the id() of a string
 705         ** object gives you the address of the data. Unfortunately, it is needed for
 706         ** some of the image and sound processing interfaces on the mac:-(
 707         */
 708         {
 709                 PyStringObject *p = 0;
 710                 long off = (long)&(p->ob_sval[0]);
 711
 712                 if( PyDict_SetItemString(d, "string_id_to_buffer", Py_BuildValue("i", off)) != 0)
 713                         return;
 714         }
 715 #define PY_RUNTIMEMODEL "macho"
 716         if (PyDict_SetItemString(d, "runtimemodel",
 717                                 Py_BuildValue("s", PY_RUNTIMEMODEL)) != 0)
 718                 return;
 719 #if defined(WITH_NEXT_FRAMEWORK)
 720 #define PY_LINKMODEL "framework"
 721 #elif defined(Py_ENABLE_SHARED)
 722 #define PY_LINKMODEL "shared"
 723 #else
 724 #define PY_LINKMODEL "static"
 725 #endif
 726         if (PyDict_SetItemString(d, "linkmodel",
 727                                 Py_BuildValue("s", PY_LINKMODEL)) != 0)
 728                 return;
 729
 730 }