Modules/main.c

   1 /* Python interpreter main program */
   2
   3 #include "Python.h"
   4 #include "osdefs.h"
   5 #include "code.h" /* For CO_FUTURE_DIVISION */
   6 #include "import.h"
   7
   8 #ifdef __VMS
   9 #include <unixlib.h>
  10 #endif
  11
  12 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
  13 #ifdef HAVE_FCNTL_H
  14 #include <fcntl.h>
  15 #endif
  16 #endif
  17
  18 #if (defined(PYOS_OS2) && !defined(PYCC_GCC)) || defined(MS_WINDOWS)
  19 #define PYTHONHOMEHELP "<prefix>\\lib"
  20 #else
  21 #if defined(PYOS_OS2) && defined(PYCC_GCC)
  22 #define PYTHONHOMEHELP "<prefix>/Lib"
  23 #else
  24 #define PYTHONHOMEHELP "<prefix>/pythonX.X"
  25 #endif
  26 #endif
  27
  28 #include "pygetopt.h"
  29
  30 #define COPYRIGHT \
  31     "Type \"help\", \"copyright\", \"credits\" or \"license\" " \
  32     "for more information."
  33
  34 #ifdef __cplusplus
  35 extern "C" {
  36 #endif
  37
  38 /* For Py_GetArgcArgv(); set by main() */
  39 static char **orig_argv;
  40 static int  orig_argc;
  41
  42 /* command line options */
  43 #define BASE_OPTS "3bBc:dEhiJm:OQ:sStuUvVW:xX?"
  44
  45 #ifndef RISCOS
  46 #define PROGRAM_OPTS BASE_OPTS
  47 #else /*RISCOS*/
  48 /* extra option saying that we are running under a special task window
  49    frontend; especially my_readline will behave different */
  50 #define PROGRAM_OPTS BASE_OPTS "w"
  51 /* corresponding flag */
  52 extern int Py_RISCOSWimpFlag;
  53 #endif /*RISCOS*/
  54
  55 /* Short usage message (with %s for argv0) */
  56 static char *usage_line =
  57 "usage: %s [option] ... [-c cmd | -m mod | file | -] [arg] ...\n";
  58
  59 /* Long usage message, split into parts < 512 bytes */
  60 static char *usage_1 = "\
  61 Options and arguments (and corresponding environment variables):\n\
  62 -B     : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x\n\
  63 -c cmd : program passed in as string (terminates option list)\n\
  64 -d     : debug output from parser; also PYTHONDEBUG=x\n\
  65 -E     : ignore PYTHON* environment variables (such as PYTHONPATH)\n\
  66 -h     : print this help message and exit (also --help)\n\
  67 -i     : inspect interactively after running script; forces a prompt even\n\
  68 ";
  69 static char *usage_2 = "\
  70          if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\
  71 -m mod : run library module as a script (terminates option list)\n\
  72 -O     : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x\n\
  73 -OO    : remove doc-strings in addition to the -O optimizations\n\
  74 -Q arg : division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew\n\
  75 -s     : don't add user site directory to sys.path; also PYTHONNOUSERSITE\n\
  76 -S     : don't imply 'import site' on initialization\n\
  77 -t     : issue warnings about inconsistent tab usage (-tt: issue errors)\n\
  78 ";
  79 static char *usage_3 = "\
  80 -u     : unbuffered binary stdout and stderr; also PYTHONUNBUFFERED=x\n\
  81          see man page for details on internal buffering relating to '-u'\n\
  82 -v     : verbose (trace import statements); also PYTHONVERBOSE=x\n\
  83          can be supplied multiple times to increase verbosity\n\
  84 -V     : print the Python version number and exit (also --version)\n\
  85 -W arg : warning control; arg is action:message:category:module:lineno\n\
  86 -x     : skip first line of source, allowing use of non-Unix forms of #!cmd\n\
  87 ";
  88 static char *usage_4 = "\
  89 -3     : warn about Python 3.x incompatibilities that 2to3 cannot trivially fix\n\
  90 file   : program read from script file\n\
  91 -      : program read from stdin (default; interactive mode if a tty)\n\
  92 arg ...: arguments passed to program in sys.argv[1:]\n\n\
  93 Other environment variables:\n\
  94 PYTHONSTARTUP: file executed on interactive startup (no default)\n\
  95 PYTHONPATH   : '%c'-separated list of directories prefixed to the\n\
  96                default module search path.  The result is sys.path.\n\
  97 ";
  98 static char *usage_5 = "\
  99 PYTHONHOME   : alternate <prefix> directory (or <prefix>%c<exec_prefix>).\n\
 100                The default module search path uses %s.\n\
 101 PYTHONCASEOK : ignore case in 'import' statements (Windows).\n\
 102 PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.\n\
 103 ";
 104
 105
 106 static int
 107 usage(int exitcode, char* program)
 108 {
 109         FILE *f = exitcode ? stderr : stdout;
 110
 111         fprintf(f, usage_line, program);
 112         if (exitcode)
 113                 fprintf(f, "Try `python -h' for more information.\n");
 114         else {
 115                 fputs(usage_1, f);
 116                 fputs(usage_2, f);
 117                 fputs(usage_3, f);
 118                 fprintf(f, usage_4, DELIM);
 119                 fprintf(f, usage_5, DELIM, PYTHONHOMEHELP);
 120         }
 121 #if defined(__VMS)
 122         if (exitcode == 0) {
 123                 /* suppress 'error' message */
 124                 return 1;
 125         }
 126         else {
 127                 /* STS$M_INHIB_MSG + SS$_ABORT */
 128                 return 0x1000002c;
 129         }
 130 #else
 131         return exitcode;
 132 #endif
 133         /*NOTREACHED*/
 134 }
 135
 136 static void RunStartupFile(PyCompilerFlags *cf)
 137 {
 138         char *startup = Py_GETENV("PYTHONSTARTUP");
 139         if (startup != NULL && startup[0] != '\0') {
 140                 FILE *fp = fopen(startup, "r");
 141                 if (fp != NULL) {
 142                         (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
 143                         PyErr_Clear();
 144                         fclose(fp);
 145                } else {
 146                         int save_errno;
 147                         save_errno = errno;
 148                         PySys_WriteStderr("Could not open PYTHONSTARTUP\n");
 149                         errno = save_errno;
 150                         PyErr_SetFromErrnoWithFilename(PyExc_IOError,
 151                                                        startup);
 152                         PyErr_Print();
 153                         PyErr_Clear();
 154                 }
 155         }
 156 }
 157
 158
 159 static int RunModule(char *module, int set_argv0)
 160 {
 161         PyObject *runpy, *runmodule, *runargs, *result;
 162         runpy = PyImport_ImportModule("runpy");
 163         if (runpy == NULL) {
 164                 fprintf(stderr, "Could not import runpy module\n");
 165                 return -1;
 166         }
 167         runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main");
 168         if (runmodule == NULL) {
 169                 fprintf(stderr, "Could not access runpy._run_module_as_main\n");
 170                 Py_DECREF(runpy);
 171                 return -1;
 172         }
 173         runargs = Py_BuildValue("(si)", module, set_argv0);
 174         if (runargs == NULL) {
 175                 fprintf(stderr,
 176                         "Could not create arguments for runpy._run_module_as_main\n");
 177                 Py_DECREF(runpy);
 178                 Py_DECREF(runmodule);
 179                 return -1;
 180         }
 181         result = PyObject_Call(runmodule, runargs, NULL);
 182         if (result == NULL) {
 183                 PyErr_Print();
 184         }
 185         Py_DECREF(runpy);
 186         Py_DECREF(runmodule);
 187         Py_DECREF(runargs);
 188         if (result == NULL) {
 189                 return -1;
 190         }
 191         Py_DECREF(result);
 192         return 0;
 193 }
 194
 195 static int RunMainFromImporter(char *filename)
 196 {
 197         PyObject *argv0 = NULL, *importer = NULL;
 198
 199         if ((argv0 = PyString_FromString(filename)) &&
 200             (importer = PyImport_GetImporter(argv0)) &&
 201             (importer->ob_type != &PyNullImporter_Type))
 202         {
 203                  /* argv0 is usable as an import source, so
 204                         put it in sys.path[0] and import __main__ */
 205                 PyObject *sys_path = NULL;
 206                 if ((sys_path = PySys_GetObject("path")) &&
 207                     !PyList_SetItem(sys_path, 0, argv0))
 208                 {
 209                         Py_INCREF(argv0);
 210                         Py_DECREF(importer);
 211                         sys_path = NULL;
 212                         return RunModule("__main__", 0) != 0;
 213                 }
 214         }
 215         Py_XDECREF(argv0);
 216         Py_XDECREF(importer);
 217         if (PyErr_Occurred()) {
 218                 PyErr_Print();
 219                 return 1;
 220         }
 221         return -1;
 222 }
 223
 224
 225 /* Main program */
 226
 227 int
 228 Py_Main(int argc, char **argv)
 229 {
 230         int c;
 231         int sts;
 232         char *command = NULL;
 233         char *filename = NULL;
 234         char *module = NULL;
 235         FILE *fp = stdin;
 236         char *p;
 237         int unbuffered = 0;
 238         int skipfirstline = 0;
 239         int stdin_is_interactive = 0;
 240         int help = 0;
 241         int version = 0;
 242         int saw_unbuffered_flag = 0;
 243         PyCompilerFlags cf;
 244
 245         cf.cf_flags = 0;
 246
 247         orig_argc = argc;       /* For Py_GetArgcArgv() */
 248         orig_argv = argv;
 249
 250 #ifdef RISCOS
 251         Py_RISCOSWimpFlag = 0;
 252 #endif
 253
 254         PySys_ResetWarnOptions();
 255
 256         while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
 257                 if (c == 'c') {
 258                         /* -c is the last option; following arguments
 259                            that look like options are left for the
 260                            command to interpret. */
 261                         command = (char *)malloc(strlen(_PyOS_optarg) + 2);
 262                         if (command == NULL)
 263                                 Py_FatalError(
 264                                    "not enough memory to copy -c argument");
 265                         strcpy(command, _PyOS_optarg);
 266                         strcat(command, "\n");
 267                         break;
 268                 }
 269
 270                 if (c == 'm') {
 271                         /* -m is the last option; following arguments
 272                            that look like options are left for the
 273                            module to interpret. */
 274                         module = (char *)malloc(strlen(_PyOS_optarg) + 2);
 275                         if (module == NULL)
 276                                 Py_FatalError(
 277                                    "not enough memory to copy -m argument");
 278                         strcpy(module, _PyOS_optarg);
 279                         break;
 280                 }
 281
 282                 switch (c) {
 283                 case 'b':
 284                         Py_BytesWarningFlag++;
 285                         break;
 286
 287                 case 'd':
 288                         Py_DebugFlag++;
 289                         break;
 290
 291                 case '3':
 292                         Py_Py3kWarningFlag++;
 293                         if (!Py_DivisionWarningFlag)
 294                                 Py_DivisionWarningFlag = 1;
 295                         break;
 296
 297                 case 'Q':
 298                         if (strcmp(_PyOS_optarg, "old") == 0) {
 299                                 Py_DivisionWarningFlag = 0;
 300                                 break;
 301                         }
 302                         if (strcmp(_PyOS_optarg, "warn") == 0) {
 303                                 Py_DivisionWarningFlag = 1;
 304                                 break;
 305                         }
 306                         if (strcmp(_PyOS_optarg, "warnall") == 0) {
 307                                 Py_DivisionWarningFlag = 2;
 308                                 break;
 309                         }
 310                         if (strcmp(_PyOS_optarg, "new") == 0) {
 311                                 /* This only affects __main__ */
 312                                 cf.cf_flags |= CO_FUTURE_DIVISION;
 313                                 /* And this tells the eval loop to treat
 314                                    BINARY_DIVIDE as BINARY_TRUE_DIVIDE */
 315                                 _Py_QnewFlag = 1;
 316                                 break;
 317                         }
 318                         fprintf(stderr,
 319                                 "-Q option should be `-Qold', "
 320                                 "`-Qwarn', `-Qwarnall', or `-Qnew' only\n");
 321                         return usage(2, argv[0]);
 322                         /* NOTREACHED */
 323
 324                 case 'i':
 325                         Py_InspectFlag++;
 326                         Py_InteractiveFlag++;
 327                         break;
 328
 329                 /* case 'J': reserved for Jython */
 330
 331                 case 'O':
 332                         Py_OptimizeFlag++;
 333                         break;
 334
 335                 case 'B':
 336                         Py_DontWriteBytecodeFlag++;
 337                         break;
 338
 339                 case 's':
 340                         Py_NoUserSiteDirectory++;
 341                         break;
 342
 343                 case 'S':
 344                         Py_NoSiteFlag++;
 345                         break;
 346
 347                 case 'E':
 348                         Py_IgnoreEnvironmentFlag++;
 349                         break;
 350
 351                 case 't':
 352                         Py_TabcheckFlag++;
 353                         break;
 354
 355                 case 'u':
 356                         unbuffered++;
 357                         saw_unbuffered_flag = 1;
 358                         break;
 359
 360                 case 'v':
 361                         Py_VerboseFlag++;
 362                         break;
 363
 364 #ifdef RISCOS
 365                 case 'w':
 366                         Py_RISCOSWimpFlag = 1;
 367                         break;
 368 #endif
 369
 370                 case 'x':
 371                         skipfirstline = 1;
 372                         break;
 373
 374                 /* case 'X': reserved for implementation-specific arguments */
 375
 376                 case 'U':
 377                         Py_UnicodeFlag++;
 378                         break;
 379                 case 'h':
 380                 case '?':
 381                         help++;
 382                         break;
 383                 case 'V':
 384                         version++;
 385                         break;
 386
 387                 case 'W':
 388                         PySys_AddWarnOption(_PyOS_optarg);
 389                         break;
 390
 391                 /* This space reserved for other options */
 392
 393                 default:
 394                         return usage(2, argv[0]);
 395                         /*NOTREACHED*/
 396
 397                 }
 398         }
 399
 400         if (help)
 401                 return usage(0, argv[0]);
 402
 403         if (version) {
 404                 fprintf(stderr, "Python %s\n", PY_VERSION);
 405                 return 0;
 406         }
 407
 408         if (Py_Py3kWarningFlag && !Py_TabcheckFlag)
 409                 /* -3 implies -t (but not -tt) */
 410                 Py_TabcheckFlag = 1;
 411
 412         if (!Py_InspectFlag &&
 413             (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
 414                 Py_InspectFlag = 1;
 415         if (!saw_unbuffered_flag &&
 416             (p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0')
 417                 unbuffered = 1;
 418
 419         if (!Py_NoUserSiteDirectory &&
 420             (p = Py_GETENV("PYTHONNOUSERSITE")) && *p != '\0')
 421                 Py_NoUserSiteDirectory = 1;
 422
 423         if (command == NULL && module == NULL && _PyOS_optind < argc &&
 424             strcmp(argv[_PyOS_optind], "-") != 0)
 425         {
 426 #ifdef __VMS
 427                 filename = decc$translate_vms(argv[_PyOS_optind]);
 428                 if (filename == (char *)0 || filename == (char *)-1)
 429                         filename = argv[_PyOS_optind];
 430
 431 #else
 432                 filename = argv[_PyOS_optind];
 433 #endif
 434         }
 435
 436         stdin_is_interactive = Py_FdIsInteractive(stdin, (char *)0);
 437
 438         if (unbuffered) {
 439 #if defined(MS_WINDOWS) || defined(__CYGWIN__)
 440                 _setmode(fileno(stdin), O_BINARY);
 441                 _setmode(fileno(stdout), O_BINARY);
 442 #endif
 443 #ifdef HAVE_SETVBUF
 444                 setvbuf(stdin,  (char *)NULL, _IONBF, BUFSIZ);
 445                 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
 446                 setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);
 447 #else /* !HAVE_SETVBUF */
 448                 setbuf(stdin,  (char *)NULL);
 449                 setbuf(stdout, (char *)NULL);
 450                 setbuf(stderr, (char *)NULL);
 451 #endif /* !HAVE_SETVBUF */
 452         }
 453         else if (Py_InteractiveFlag) {
 454 #ifdef MS_WINDOWS
 455                 /* Doesn't have to have line-buffered -- use unbuffered */
 456                 /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
 457                 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
 458 #else /* !MS_WINDOWS */
 459 #ifdef HAVE_SETVBUF
 460                 setvbuf(stdin,  (char *)NULL, _IOLBF, BUFSIZ);
 461                 setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
 462 #endif /* HAVE_SETVBUF */
 463 #endif /* !MS_WINDOWS */
 464                 /* Leave stderr alone - it should be unbuffered anyway. */
 465         }
 466 #ifdef __VMS
 467         else {
 468                 setvbuf (stdout, (char *)NULL, _IOLBF, BUFSIZ);
 469         }
 470 #endif /* __VMS */
 471
 472 #ifdef __APPLE__
 473         /* On MacOS X, when the Python interpreter is embedded in an
 474            application bundle, it gets executed by a bootstrapping script
 475            that does os.execve() with an argv[0] that's different from the
 476            actual Python executable. This is needed to keep the Finder happy,
 477            or rather, to work around Apple's overly strict requirements of
 478            the process name. However, we still need a usable sys.executable,
 479            so the actual executable path is passed in an environment variable.
 480            See Lib/plat-mac/bundlebuiler.py for details about the bootstrap
 481            script. */
 482         if ((p = Py_GETENV("PYTHONEXECUTABLE")) && *p != '\0')
 483                 Py_SetProgramName(p);
 484         else
 485                 Py_SetProgramName(argv[0]);
 486 #else
 487         Py_SetProgramName(argv[0]);
 488 #endif
 489         Py_Initialize();
 490
 491         if (Py_VerboseFlag ||
 492             (command == NULL && filename == NULL && module == NULL && stdin_is_interactive)) {
 493                 fprintf(stderr, "Python %s on %s\n",
 494                         Py_GetVersion(), Py_GetPlatform());
 495                 if (!Py_NoSiteFlag)
 496                         fprintf(stderr, "%s\n", COPYRIGHT);
 497         }
 498
 499         if (command != NULL) {
 500                 /* Backup _PyOS_optind and force sys.argv[0] = '-c' */
 501                 _PyOS_optind--;
 502                 argv[_PyOS_optind] = "-c";
 503         }
 504
 505         if (module != NULL) {
 506                 /* Backup _PyOS_optind and force sys.argv[0] = '-c'
 507                    so that PySys_SetArgv correctly sets sys.path[0] to ''*/
 508                 _PyOS_optind--;
 509                 argv[_PyOS_optind] = "-c";
 510         }
 511
 512         PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind);
 513
 514         if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) &&
 515             isatty(fileno(stdin))) {
 516                 PyObject *v;
 517                 v = PyImport_ImportModule("readline");
 518                 if (v == NULL)
 519                         PyErr_Clear();
 520                 else
 521                         Py_DECREF(v);
 522         }
 523
 524         if (command) {
 525                 sts = PyRun_SimpleStringFlags(command, &cf) != 0;
 526                 free(command);
 527         } else if (module) {
 528                 sts = RunModule(module, 1);
 529                 free(module);
 530         }
 531         else {
 532
 533                 if (filename == NULL && stdin_is_interactive) {
 534                         Py_InspectFlag = 0; /* do exit on SystemExit */
 535                         RunStartupFile(&cf);
 536                 }
 537                 /* XXX */
 538
 539                 sts = -1;       /* keep track of whether we've already run __main__ */
 540
 541                 if (filename != NULL) {
 542                         sts = RunMainFromImporter(filename);
 543                 }
 544
 545                 if (sts==-1 && filename!=NULL) {
 546                         if ((fp = fopen(filename, "r")) == NULL) {
 547                                 fprintf(stderr, "%s: can't open file '%s': [Errno %d] %s\n",
 548                                         argv[0], filename, errno, strerror(errno));
 549
 550                                 return 2;
 551                         }
 552                         else if (skipfirstline) {
 553                                 int ch;
 554                                 /* Push back first newline so line numbers
 555                                    remain the same */
 556                                 while ((ch = getc(fp)) != EOF) {
 557                                         if (ch == '\n') {
 558                                                 (void)ungetc(ch, fp);
 559                                                 break;
 560                                         }
 561                                 }
 562                         }
 563                         {
 564                                 /* XXX: does this work on Win/Win64? (see posix_fstat) */
 565                                 struct stat sb;
 566                                 if (fstat(fileno(fp), &sb) == 0 &&
 567                                     S_ISDIR(sb.st_mode)) {
 568                                         fprintf(stderr, "%s: '%s' is a directory, cannot continue\n", argv[0], filename);
 569                                         fclose(fp);
 570                                         return 1;
 571                                 }
 572                         }
 573                 }
 574
 575                 if (sts==-1) {
 576                         sts = PyRun_AnyFileExFlags(
 577                                 fp,
 578                                 filename == NULL ? "<stdin>" : filename,
 579                                 filename != NULL, &cf) != 0;
 580                 }
 581
 582         }
 583
 584         /* Check this environment variable at the end, to give programs the
 585          * opportunity to set it from Python.
 586          */
 587         if (!Py_InspectFlag &&
 588             (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
 589         {
 590                 Py_InspectFlag = 1;
 591         }
 592
 593         if (Py_InspectFlag && stdin_is_interactive &&
 594             (filename != NULL || command != NULL || module != NULL)) {
 595                 Py_InspectFlag = 0;
 596                 /* XXX */
 597                 sts = PyRun_AnyFileFlags(stdin, "<stdin>", &cf) != 0;
 598         }
 599
 600         Py_Finalize();
 601 #ifdef RISCOS
 602         if (Py_RISCOSWimpFlag)
 603                 fprintf(stderr, "\x0cq\x0c"); /* make frontend quit */
 604 #endif
 605
 606 #ifdef __INSURE__
 607         /* Insure++ is a memory analysis tool that aids in discovering
 608          * memory leaks and other memory problems.  On Python exit, the
 609          * interned string dictionary is flagged as being in use at exit
 610          * (which it is).  Under normal circumstances, this is fine because
 611          * the memory will be automatically reclaimed by the system.  Under
 612          * memory debugging, it's a huge source of useless noise, so we
 613          * trade off slower shutdown for less distraction in the memory
 614          * reports.  -baw
 615          */
 616         _Py_ReleaseInternedStrings();
 617 #endif /* __INSURE__ */
 618
 619         return sts;
 620 }
 621
 622 /* this is gonna seem *real weird*, but if you put some other code between
 623    Py_Main() and Py_GetArgcArgv() you will need to adjust the test in the
 624    while statement in Misc/gdbinit:ppystack */
 625
 626 /* Make the *original* argc/argv available to other modules.
 627    This is rare, but it is needed by the secureware extension. */
 628
 629 void
 630 Py_GetArgcArgv(int *argc, char ***argv)
 631 {
 632         *argc = orig_argc;
 633         *argv = orig_argv;
 634 }
 635
 636 #ifdef __cplusplus
 637 }
 638 #endif
 639