Mac/Python/macmain.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 /* Python interpreter main program */
  26
  27 #include "Python.h"
  28 #include "pythonresources.h"
  29 #include "import.h"
  30 #include "marshal.h"
  31 #include "macglue.h"
  32
  33 #include <Memory.h>
  34 #include <Resources.h>
  35 #include <stdio.h>
  36 #include <Events.h>
  37 #include <Windows.h>
  38 #include <Fonts.h>
  39 #include <Balloons.h>
  40 #ifdef USE_APPEARANCE
  41 #include <Gestalt.h>
  42 #include <Appearance.h>
  43 #endif /* USE_APPEARANCE */
  44 #ifdef __MWERKS__
  45 #include <SIOUX.h>
  46 #define USE_SIOUX
  47 #if __profile__ == 1
  48 #include <profiler.h>
  49 #endif
  50 #endif
  51
  52 #ifdef THINK_C
  53 #include <console.h>
  54 #endif
  55
  56 #define STARTUP "PythonStartup"
  57
  58 extern int Py_DebugFlag; /* For parser.c, declared in pythonrun.c */
  59 extern int Py_VerboseFlag; /* For import.c, declared in pythonrun.c */
  60 short PyMac_AppRefNum;  /* RefNum of application resource fork */
  61
  62 /* For Py_GetArgcArgv(); set by main() */
  63 static char **orig_argv;
  64 static int  orig_argc;
  65
  66 PyMac_PrefRecord options;
  67
  68 static void Py_Main Py_PROTO((int, char **)); /* Forward */
  69 void PyMac_Exit Py_PROTO((int)); /* Forward */
  70
  71 static void init_appearance()
  72 {
  73 #ifdef USE_APPEARANCE
  74         OSErr err;
  75         SInt32 response;
  76
  77         err = Gestalt(gestaltAppearanceAttr,&response);
  78         if ( err ) goto no_appearance;
  79         if ( !(response&(1<<gestaltAppearanceExists)) ) goto no_appearance;
  80         /* XXXX Should we check the version? Compat-mode? */
  81         PyMac_AppearanceCompliant = 1;
  82 no_appearance:
  83         return;
  84 #endif /* USE_APPEARANCE */
  85 }
  86 /* Initialize the Mac toolbox world */
  87
  88 static void
  89 init_mac_world()
  90 {
  91 #ifdef THINK_C
  92         printf("\n");
  93 #else
  94         MaxApplZone();
  95         InitGraf(&qd.thePort);
  96         InitFonts();
  97         InitWindows();
  98         TEInit();
  99         InitDialogs((long)0);
 100         InitMenus();
 101         InitCursor();
 102         init_appearance();
 103 #endif
 104 }
 105
 106 /*
 107 ** PyMac_InteractiveOptions - Allow user to set options if option key is pressed
 108 */
 109 static void
 110 PyMac_InteractiveOptions(PyMac_PrefRecord *p, int *argcp, char ***argvp)
 111 {
 112         KeyMap rmap;
 113         unsigned char *map;
 114         short item, type;
 115         ControlHandle handle;
 116         DialogPtr dialog;
 117         Rect rect;
 118         int old_argc = *argcp;
 119         int i;
 120
 121         /*
 122         ** If the preferences disallows interactive options we return,
 123         ** similarly of <option> isn't pressed.
 124         */
 125         if (p->nointopt) return;
 126
 127         GetKeys(rmap);
 128         map = (unsigned char *)rmap;
 129         if ( ( map[0x3a>>3] & (1<<(0x3a&7)) ) == 0 )    /* option key is 3a */
 130                 return;
 131
 132         dialog = GetNewDialog(OPT_DIALOG, NULL, (WindowPtr)-1);
 133         if ( dialog == NULL ) {
 134                 printf("Option dialog not found - cannot set options\n");
 135                 return;
 136         }
 137         SetDialogDefaultItem(dialog, OPT_OK);
 138         SetDialogCancelItem(dialog, OPT_CANCEL);
 139
 140         /* Set default values */
 141 #define SET_OPT_ITEM(num, var) \
 142                 GetDialogItem(dialog, (num), &type, (Handle *)&handle, &rect); \
 143                 SetControlValue(handle, (short)p->var);
 144
 145         SET_OPT_ITEM(OPT_INSPECT, inspect);
 146         SET_OPT_ITEM(OPT_VERBOSE, verbose);
 147         SET_OPT_ITEM(OPT_OPTIMIZE, optimize);
 148         SET_OPT_ITEM(OPT_UNBUFFERED, unbuffered);
 149         SET_OPT_ITEM(OPT_DEBUGGING, debugging);
 150         SET_OPT_ITEM(OPT_KEEPNORMAL, keep_normal);
 151         SET_OPT_ITEM(OPT_KEEPERROR, keep_error);
 152         SET_OPT_ITEM(OPT_OLDEXC, oldexc);
 153         SET_OPT_ITEM(OPT_NOSITE, nosite);
 154         /* The rest are not settable interactively */
 155
 156 #undef SET_OPT_ITEM
 157
 158         while (1) {
 159                 handle = NULL;
 160                 ModalDialog(NULL, &item);
 161                 if ( item == OPT_OK )
 162                         break;
 163                 if ( item == OPT_CANCEL ) {
 164                         DisposeDialog(dialog);
 165                         exit(0);
 166                 }
 167                 if ( item == OPT_HELP ) {
 168                         HMSetBalloons(!HMGetBalloons());
 169                 }
 170                 if ( item == OPT_CMDLINE ) {
 171                         int new_argc, newer_argc;
 172                         char **new_argv, **newer_argv;
 173
 174                         new_argc = ccommand(&new_argv);
 175                         newer_argc = (new_argc-1) + old_argc;
 176                         newer_argv = malloc((newer_argc+1)*sizeof(char *));
 177                         if( !newer_argv )
 178                                 Py_FatalError("Cannot malloc argv\n");
 179                         for(i=0; i<old_argc; i++)
 180                                 newer_argv[i] = (*argvp)[i];
 181                         for(i=old_argc; i<=newer_argc; i++) /* Copy the NULL too */
 182                                 newer_argv[i] = new_argv[i-old_argc+1];
 183                         *argvp = newer_argv;
 184                         *argcp = newer_argc;
 185
 186                         /* XXXX Is it not safe to use free() here, apparently */
 187                 }
 188 #define OPT_ITEM(num, var) \
 189                 if ( item == (num) ) { \
 190                         p->var = !p->var; \
 191                         GetDialogItem(dialog, (num), &type, (Handle *)&handle, &rect); \
 192                         SetControlValue(handle, (short)p->var); \
 193                 }
 194
 195                 OPT_ITEM(OPT_INSPECT, inspect);
 196                 OPT_ITEM(OPT_VERBOSE, verbose);
 197                 OPT_ITEM(OPT_OPTIMIZE, optimize);
 198                 OPT_ITEM(OPT_UNBUFFERED, unbuffered);
 199                 OPT_ITEM(OPT_DEBUGGING, debugging);
 200                 OPT_ITEM(OPT_KEEPNORMAL, keep_normal);
 201                 OPT_ITEM(OPT_KEEPERROR, keep_error);
 202                 OPT_ITEM(OPT_OLDEXC, oldexc);
 203                 OPT_ITEM(OPT_NOSITE, nosite);
 204
 205 #undef OPT_ITEM
 206         }
 207         DisposeDialog(dialog);
 208 }
 209
 210 /*
 211 ** Initialization code, shared by interpreter and applets
 212 */
 213 static void
 214 init_common(int *argcp, char ***argvp, int embedded)
 215 {
 216         /* Remember resource fork refnum, for later */
 217         PyMac_AppRefNum = CurResFile();
 218
 219         /* Initialize toolboxes */
 220         init_mac_world();
 221
 222 #ifdef USE_MAC_SHARED_LIBRARY
 223         /* Add the shared library to the stack of resource files */
 224         (void)PyMac_init_process_location();
 225         PyMac_AddLibResources();
 226 #endif
 227
 228 #if defined(USE_GUSI)
 229         /* Setup GUSI */
 230         GUSIDefaultSetup();
 231         PyMac_SetGUSISpin();
 232         PyMac_SetGUSIOptions();
 233         atexit(PyMac_StopGUSISpin);
 234 #endif
 235
 236 #ifdef USE_SIOUX
 237         /* Set various SIOUX flags. Some are changed later based on options */
 238 /*      SIOUXSettings.standalone = 0;   /* XXXX Attempting to keep sioux from eating events */
 239         SIOUXSettings.asktosaveonclose = 0;
 240         SIOUXSettings.showstatusline = 0;
 241         SIOUXSettings.tabspaces = 4;
 242 #endif
 243
 244         /* Get options from preference file (or from applet resource fork) */
 245         options.keep_error = 1;         /* default-default */
 246         PyMac_PreferenceOptions(&options);
 247
 248         if ( embedded ) {
 249                 static char *emb_argv[] = {"embedded-python", 0};
 250
 251                 *argcp = 1;
 252                 *argvp = emb_argv;
 253         } else {
 254                 /* Create argc/argv. Do it before we go into the options event loop. */
 255                 *argcp = PyMac_GetArgv(argvp, options.noargs);
 256
 257                 /* Do interactive option setting, if allowed and <option> depressed */
 258                 PyMac_InteractiveOptions(&options, argcp, argvp);
 259         }
 260
 261         /* Copy selected options to where the machine-independent stuff wants it */
 262         Py_VerboseFlag = options.verbose;
 263 /*      Py_SuppressPrintingFlag = options.suppress_print; */
 264         Py_OptimizeFlag = options.optimize;
 265         Py_DebugFlag = options.debugging;
 266         Py_NoSiteFlag = options.nosite;
 267         Py_UseClassExceptionsFlag = !(options.oldexc);
 268         if ( options.noargs ) {
 269                 /* don't process events at all without the scripts permission */
 270                 PyMacSchedParams scp;
 271
 272                 PyMac_GetSchedParams(&scp);
 273                 scp.process_events = 0;
 274                 /* Should we disable command-dot as well? */
 275                 PyMac_SetSchedParams(&scp);
 276         }
 277         /* XXXX dispatch oldexc and nosite */
 278
 279         /* Set buffering */
 280         if (options.unbuffered) {
 281 #ifndef MPW
 282                 setbuf(stdout, (char *)NULL);
 283                 setbuf(stderr, (char *)NULL);
 284 #else
 285                 /* On MPW (3.2) unbuffered seems to hang */
 286                 setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
 287                 setvbuf(stderr, (char *)NULL, _IOLBF, BUFSIZ);
 288 #endif
 289         }
 290 #if __profile__ == 1
 291         /* collectSummary or collectDetailed, timebase, #routines, max stack depth */
 292         ProfilerInit(collectSummary, bestTimeBase, 8000, 250);
 293 #endif
 294
 295         /* Tell the rest of python about our argc/argv */
 296         orig_argc = *argcp;     /* For Py_GetArgcArgv() */
 297         orig_argv = *argvp;
 298         Py_SetProgramName((*argvp)[0]);
 299 }
 300
 301 /*
 302 ** Inspection mode after script/applet termination
 303 */
 304 static int
 305 run_inspect()
 306 {
 307         int sts = 0;
 308
 309         if (options.inspect && isatty((int)fileno(stdin)))
 310                 sts = PyRun_AnyFile(stdin, "<stdin>") != 0;
 311         return sts;
 312 }
 313
 314 #ifdef USE_MAC_APPLET_SUPPORT
 315 /* Applet support */
 316
 317 /* Run a compiled Python Python script from 'PYC ' resource __main__ */
 318 static int
 319 run_main_resource()
 320 {
 321         Handle h;
 322         long size;
 323         PyObject *code;
 324         PyObject *result;
 325
 326         h = GetNamedResource('PYC ', "\p__main__");
 327         if (h == NULL) {
 328                 Alert(NOPYC_ALERT, NULL);
 329                 return 1;
 330         }
 331         size = GetResourceSizeOnDisk(h);
 332         HLock(h);
 333         code = PyMarshal_ReadObjectFromString(*h + 8, (int)(size - 8));
 334         HUnlock(h);
 335         ReleaseResource(h);
 336         if (code == NULL) {
 337                 PyErr_Print();
 338                 return 1;
 339         }
 340         result = PyImport_ExecCodeModule("__main__", code);
 341         Py_DECREF(code);
 342         if (result == NULL) {
 343                 PyErr_Print();
 344                 return 1;
 345         }
 346         Py_DECREF(result);
 347         return 0;
 348 }
 349
 350 /* Initialization sequence for applets */
 351 void
 352 PyMac_InitApplet()
 353 {
 354         int argc;
 355         char **argv;
 356         int err;
 357
 358         init_common(&argc, &argv, 0);
 359
 360         Py_Initialize();
 361         PySys_SetArgv(argc, argv);
 362
 363         err = run_main_resource();
 364
 365         err = (run_inspect() || err);
 366
 367         fflush(stderr);
 368         fflush(stdout);
 369         PyMac_Exit(err);
 370         /* XXX Should we bother to Py_Exit(sts)? */
 371 }
 372
 373 /*
 374 ** Hook for embedding python.
 375 */
 376 void
 377 PyMac_Initialize()
 378 {
 379         int argc;
 380         char **argv;
 381
 382         init_common(&argc, &argv, 1);
 383         Py_Initialize();
 384         PySys_SetArgv(argc, argv);
 385 }
 386
 387 #endif /* USE_MAC_APPLET_SUPPORT */
 388
 389 /* For normal application */
 390 void
 391 PyMac_InitApplication()
 392 {
 393         int argc;
 394         char **argv;
 395
 396         init_common(&argc, &argv, 0);
 397
 398         if ( argc > 1 ) {
 399                 /* We're running a script. Attempt to change current directory */
 400                 char curwd[256], *endp;
 401
 402                 strcpy(curwd, argv[1]);
 403                 endp = strrchr(curwd, ':');
 404                 if ( endp && endp > curwd ) {
 405                         *endp = '\0';
 406
 407                         chdir(curwd);
 408 #ifdef USE_GUSI
 409                         /* Change MacOS's idea of wd too */
 410                         PyMac_FixGUSIcd();
 411 #endif
 412                 }
 413         }
 414         Py_Main(argc, argv);
 415 }
 416
 417 /* Main program */
 418
 419 static void
 420 Py_Main(argc, argv)
 421         int argc;
 422         char **argv;
 423 {
 424         int sts;
 425         char *command = NULL;
 426         char *filename = NULL;
 427         FILE *fp = stdin;
 428
 429         filename = argv[1];
 430
 431         if (Py_VerboseFlag ||
 432             command == NULL && filename == NULL && isatty((int)fileno(fp)))
 433                 fprintf(stderr, "Python %s\n%s\n",
 434                         Py_GetVersion(), Py_GetCopyright());
 435
 436         if (filename != NULL) {
 437                 if ((fp = fopen(filename, "r")) == NULL) {
 438                         fprintf(stderr, "%s: can't open file '%s'\n",
 439                                 argv[0], filename);
 440                         PyMac_Exit(2);
 441                 }
 442         }
 443
 444         /* We initialize the menubar here, hoping SIOUX is initialized by now */
 445         PyMac_InitMenuBar();
 446
 447         Py_Initialize();
 448
 449         PySys_SetArgv(argc-1, argv+1);
 450
 451         if (filename == NULL && isatty((int)fileno(fp))) {
 452                 FILE *fp = fopen(STARTUP, "r");
 453                 if (fp != NULL) {
 454                         (void) PyRun_SimpleFile(fp, STARTUP);
 455                         PyErr_Clear();
 456                         fclose(fp);
 457                 }
 458         }
 459         sts = PyRun_AnyFile(
 460                         fp, filename == NULL ? "<stdin>" : filename) != 0;
 461         if (filename != NULL)
 462                 fclose(fp);
 463
 464         if ( filename != NULL || command != NULL )
 465                 sts = (run_inspect() || sts);
 466
 467         Py_Exit(sts);
 468         /*NOTREACHED*/
 469 }
 470
 471 /*
 472 ** Terminate application
 473 */
 474 void
 475 PyMac_Exit(status)
 476         int status;
 477 {
 478         int keep;
 479
 480 #if __profile__ == 1
 481         ProfilerDump("\pPython Profiler Results");
 482         ProfilerTerm();
 483 #endif
 484         if ( status )
 485                 keep = options.keep_error;
 486         else
 487                 keep = options.keep_normal;
 488
 489 #ifdef USE_SIOUX
 490         if (keep) {
 491                 SIOUXSettings.standalone = 1;
 492                 SIOUXSettings.autocloseonquit = 0;
 493                 SIOUXSetTitle("\p\307terminated\310");
 494                 PyMac_RestoreMenuBar();
 495 #ifdef USE_MSL
 496                 /*
 497                 ** Temporary workaround: autocloseonquit clearing does not
 498                 ** currently work for the MSL/GUSI combo.
 499                 */
 500                 while(getchar() > 0);
 501 #endif
 502         }
 503         else
 504                 SIOUXSettings.autocloseonquit = 1;
 505 #endif /* USE_SIOUX */
 506 #ifdef THINK_C
 507         console_options.pause_atexit = keep;
 508 #endif
 509
 510         exit(status);
 511 }
 512
 513 /* Return the program name -- some code out there needs this. */
 514 char *
 515 Py_GetProgramFullPath()
 516 {
 517         return orig_argv[0];
 518 }
 519
 520
 521 /* Make the *original* argc/argv available to other modules.
 522    This is rare, but it is needed by the secureware extension. */
 523
 524 void
 525 Py_GetArgcArgv(argc,argv)
 526         int *argc;
 527         char ***argv;
 528 {
 529         *argc = orig_argc;
 530         *argv = orig_argv;
 531 }
 532
 533 /* More cruft that shouldn't really be here, used in sysmodule.c */
 534
 535 char *
 536 Py_GetPrefix()
 537 {
 538         return PyMac_GetPythonDir();
 539 }
 540
 541 char *
 542 Py_GetExecPrefix()
 543 {
 544         return PyMac_GetPythonDir();
 545 }