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