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