1 /* Python interpreter main program */ 2 3 #include "Python.h" 4 #include "osdefs.h" 5 6 #include <locale.h> 7 8 #if defined(MS_WINDOWS) || defined(__CYGWIN__) 9 #include <windows.h> 10 #ifdef HAVE_IO_H 11 #include <io.h> 12 #endif 13 #ifdef HAVE_FCNTL_H 14 #include <fcntl.h> 15 #endif 16 #endif 17 18 #ifdef _MSC_VER 19 #include <crtdbg.h> 20 #endif 21 22 #if defined(MS_WINDOWS) 23 #define PYTHONHOMEHELP "<prefix>\\lib" 24 #else 25 #define PYTHONHOMEHELP "<prefix>/pythonX.X" 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 wchar_t **orig_argv; 40 static int orig_argc; 41 42 /* command line options */ 43 #define BASE_OPTS L"bBc:dEhiIJm:OqRsStuvVW:xX:?" 44 45 #define PROGRAM_OPTS BASE_OPTS 46 47 /* Short usage message (with %s for argv0) */ 48 static const char usage_line[] = 49 "usage: %ls [option] ... [-c cmd | -m mod | file | -] [arg] ...\n"; 50 51 /* Long usage message, split into parts < 512 bytes */ 52 static const char usage_1[] = "\ 53 Options and arguments (and corresponding environment variables):\n\ 54 -b : issue warnings about str(bytes_instance), str(bytearray_instance)\n\ 55 and comparing bytes/bytearray with str. (-bb: issue errors)\n\ 56 -B : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x\n\ 57 -c cmd : program passed in as string (terminates option list)\n\ 58 -d : debug output from parser; also PYTHONDEBUG=x\n\ 59 -E : ignore PYTHON* environment variables (such as PYTHONPATH)\n\ 60 -h : print this help message and exit (also --help)\n\ 61 "; 62 static const char usage_2[] = "\ 63 -i : inspect interactively after running script; forces a prompt even\n\ 64 if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\ 65 -I : isolate Python from the user's environment (implies -E and -s)\n\ 66 -m mod : run library module as a script (terminates option list)\n\ 67 -O : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x\n\ 68 -OO : remove doc-strings in addition to the -O optimizations\n\ 69 -q : don't print version and copyright messages on interactive startup\n\ 70 -s : don't add user site directory to sys.path; also PYTHONNOUSERSITE\n\ 71 -S : don't imply 'import site' on initialization\n\ 72 "; 73 static const char usage_3[] = "\ 74 -u : unbuffered binary stdout and stderr, stdin always buffered;\n\ 75 also PYTHONUNBUFFERED=x\n\ 76 see man page for details on internal buffering relating to '-u'\n\ 77 -v : verbose (trace import statements); also PYTHONVERBOSE=x\n\ 78 can be supplied multiple times to increase verbosity\n\ 79 -V : print the Python version number and exit (also --version)\n\ 80 when given twice, print more information about the build\n\ 81 -W arg : warning control; arg is action:message:category:module:lineno\n\ 82 also PYTHONWARNINGS=arg\n\ 83 -x : skip first line of source, allowing use of non-Unix forms of #!cmd\n\ 84 -X opt : set implementation-specific option\n\ 85 "; 86 static const char usage_4[] = "\ 87 file : program read from script file\n\ 88 - : program read from stdin (default; interactive mode if a tty)\n\ 89 arg ...: arguments passed to program in sys.argv[1:]\n\n\ 90 Other environment variables:\n\ 91 PYTHONSTARTUP: file executed on interactive startup (no default)\n\ 92 PYTHONPATH : '%lc'-separated list of directories prefixed to the\n\ 93 default module search path. The result is sys.path.\n\ 94 "; 95 static const char usage_5[] = 96 "PYTHONHOME : alternate <prefix> directory (or <prefix>%lc<exec_prefix>).\n" 97 " The default module search path uses %s.\n" 98 "PYTHONCASEOK : ignore case in 'import' statements (Windows).\n" 99 "PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.\n" 100 "PYTHONFAULTHANDLER: dump the Python traceback on fatal errors.\n"; 101 static const char usage_6[] = 102 "PYTHONHASHSEED: if this variable is set to 'random', a random value is used\n" 103 " to seed the hashes of str, bytes and datetime objects. It can also be\n" 104 " set to an integer in the range [0,4294967295] to get hash values with a\n" 105 " predictable seed.\n" 106 "PYTHONMALLOC: set the Python memory allocators and/or install debug hooks\n" 107 " on Python memory allocators. Use PYTHONMALLOC=debug to install debug\n" 108 " hooks.\n"; 109 110 static int 111 usage(int exitcode, const wchar_t* program) 112 { 113 FILE *f = exitcode ? stderr : stdout; 114 115 fprintf(f, usage_line, program); 116 if (exitcode) 117 fprintf(f, "Try `python -h' for more information.\n"); 118 else { 119 fputs(usage_1, f); 120 fputs(usage_2, f); 121 fputs(usage_3, f); 122 fprintf(f, usage_4, (wint_t)DELIM); 123 fprintf(f, usage_5, (wint_t)DELIM, PYTHONHOMEHELP); 124 fputs(usage_6, f); 125 } 126 return exitcode; 127 } 128 129 static void RunStartupFile(PyCompilerFlags *cf) 130 { 131 char *startup = Py_GETENV("PYTHONSTARTUP"); 132 if (startup != NULL && startup[0] != '\0') { 133 FILE *fp = _Py_fopen(startup, "r"); 134 if (fp != NULL) { 135 (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf); 136 PyErr_Clear(); 137 fclose(fp); 138 } else { 139 int save_errno; 140 141 save_errno = errno; 142 PySys_WriteStderr("Could not open PYTHONSTARTUP\n"); 143 errno = save_errno; 144 PyErr_SetFromErrnoWithFilename(PyExc_IOError, 145 startup); 146 PyErr_Print(); 147 PyErr_Clear(); 148 } 149 } 150 } 151 152 static void RunInteractiveHook(void) 153 { 154 PyObject *sys, *hook, *result; 155 sys = PyImport_ImportModule("sys"); 156 if (sys == NULL) 157 goto error; 158 hook = PyObject_GetAttrString(sys, "__interactivehook__"); 159 Py_DECREF(sys); 160 if (hook == NULL) 161 PyErr_Clear(); 162 else { 163 result = PyObject_CallObject(hook, NULL); 164 Py_DECREF(hook); 165 if (result == NULL) 166 goto error; 167 else 168 Py_DECREF(result); 169 } 170 return; 171 172 error: 173 PySys_WriteStderr("Failed calling sys.__interactivehook__\n"); 174 PyErr_Print(); 175 PyErr_Clear(); 176 } 177 178 179 static int RunModule(wchar_t *modname, int set_argv0) 180 { 181 PyObject *module, *runpy, *runmodule, *runargs, *result; 182 runpy = PyImport_ImportModule("runpy"); 183 if (runpy == NULL) { 184 fprintf(stderr, "Could not import runpy module\n"); 185 PyErr_Print(); 186 return -1; 187 } 188 runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main"); 189 if (runmodule == NULL) { 190 fprintf(stderr, "Could not access runpy._run_module_as_main\n"); 191 PyErr_Print(); 192 Py_DECREF(runpy); 193 return -1; 194 } 195 module = PyUnicode_FromWideChar(modname, wcslen(modname)); 196 if (module == NULL) { 197 fprintf(stderr, "Could not convert module name to unicode\n"); 198 PyErr_Print(); 199 Py_DECREF(runpy); 200 Py_DECREF(runmodule); 201 return -1; 202 } 203 runargs = Py_BuildValue("(Oi)", module, set_argv0); 204 if (runargs == NULL) { 205 fprintf(stderr, 206 "Could not create arguments for runpy._run_module_as_main\n"); 207 PyErr_Print(); 208 Py_DECREF(runpy); 209 Py_DECREF(runmodule); 210 Py_DECREF(module); 211 return -1; 212 } 213 result = PyObject_Call(runmodule, runargs, NULL); 214 if (result == NULL) { 215 PyErr_Print(); 216 } 217 Py_DECREF(runpy); 218 Py_DECREF(runmodule); 219 Py_DECREF(module); 220 Py_DECREF(runargs); 221 if (result == NULL) { 222 return -1; 223 } 224 Py_DECREF(result); 225 return 0; 226 } 227 228 static PyObject * 229 AsImportPathEntry(wchar_t *filename) 230 { 231 PyObject *sys_path0 = NULL, *importer; 232 233 sys_path0 = PyUnicode_FromWideChar(filename, wcslen(filename)); 234 if (sys_path0 == NULL) 235 goto error; 236 237 importer = PyImport_GetImporter(sys_path0); 238 if (importer == NULL) 239 goto error; 240 241 if (importer == Py_None) { 242 Py_DECREF(sys_path0); 243 Py_DECREF(importer); 244 return NULL; 245 } 246 Py_DECREF(importer); 247 return sys_path0; 248 249 error: 250 Py_XDECREF(sys_path0); 251 PySys_WriteStderr("Failed checking if argv[0] is an import path entry\n"); 252 PyErr_Print(); 253 PyErr_Clear(); 254 return NULL; 255 } 256 257 258 static int 259 RunMainFromImporter(PyObject *sys_path0) 260 { 261 PyObject *sys_path; 262 int sts; 263 264 /* Assume sys_path0 has already been checked by AsImportPathEntry, 265 * so put it in sys.path[0] and import __main__ */ 266 sys_path = PySys_GetObject("path"); 267 if (sys_path == NULL) { 268 PyErr_SetString(PyExc_RuntimeError, "unable to get sys.path"); 269 goto error; 270 } 271 sts = PyList_Insert(sys_path, 0, sys_path0); 272 if (sts) { 273 sys_path0 = NULL; 274 goto error; 275 } 276 277 sts = RunModule(L"__main__", 0); 278 return sts != 0; 279 280 error: 281 Py_XDECREF(sys_path0); 282 PyErr_Print(); 283 return 1; 284 } 285 286 static int 287 run_command(wchar_t *command, PyCompilerFlags *cf) 288 { 289 PyObject *unicode, *bytes; 290 int ret; 291 292 unicode = PyUnicode_FromWideChar(command, -1); 293 if (unicode == NULL) 294 goto error; 295 bytes = PyUnicode_AsUTF8String(unicode); 296 Py_DECREF(unicode); 297 if (bytes == NULL) 298 goto error; 299 ret = PyRun_SimpleStringFlags(PyBytes_AsString(bytes), cf); 300 Py_DECREF(bytes); 301 return ret != 0; 302 303 error: 304 PySys_WriteStderr("Unable to decode the command from the command line:\n"); 305 PyErr_Print(); 306 return 1; 307 } 308 309 static int 310 run_file(FILE *fp, const wchar_t *filename, PyCompilerFlags *p_cf) 311 { 312 PyObject *unicode, *bytes = NULL; 313 char *filename_str; 314 int run; 315 316 /* call pending calls like signal handlers (SIGINT) */ 317 if (Py_MakePendingCalls() == -1) { 318 PyErr_Print(); 319 return 1; 320 } 321 322 if (filename) { 323 unicode = PyUnicode_FromWideChar(filename, wcslen(filename)); 324 if (unicode != NULL) { 325 bytes = PyUnicode_EncodeFSDefault(unicode); 326 Py_DECREF(unicode); 327 } 328 if (bytes != NULL) 329 filename_str = PyBytes_AsString(bytes); 330 else { 331 PyErr_Clear(); 332 filename_str = "<encoding error>"; 333 } 334 } 335 else 336 filename_str = "<stdin>"; 337 338 run = PyRun_AnyFileExFlags(fp, filename_str, filename != NULL, p_cf); 339 Py_XDECREF(bytes); 340 return run != 0; 341 } 342 343 344 /* Main program */ 345 346 int 347 Py_Main(int argc, wchar_t **argv) 348 { 349 int c; 350 int sts; 351 wchar_t *command = NULL; 352 wchar_t *filename = NULL; 353 wchar_t *module = NULL; 354 FILE *fp = stdin; 355 char *p; 356 #ifdef MS_WINDOWS 357 wchar_t *wp; 358 #endif 359 int skipfirstline = 0; 360 int stdin_is_interactive = 0; 361 int help = 0; 362 int version = 0; 363 int saw_unbuffered_flag = 0; 364 char *opt; 365 PyCompilerFlags cf; 366 PyObject *main_importer_path = NULL; 367 PyObject *warning_option = NULL; 368 PyObject *warning_options = NULL; 369 370 cf.cf_flags = 0; 371 372 orig_argc = argc; /* For Py_GetArgcArgv() */ 373 orig_argv = argv; 374 375 /* Hash randomization needed early for all string operations 376 (including -W and -X options). */ 377 _PyOS_opterr = 0; /* prevent printing the error in 1st pass */ 378 while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) { 379 if (c == 'm' || c == 'c') { 380 /* -c / -m is the last option: following arguments are 381 not interpreter options. */ 382 break; 383 } 384 if (c == 'E') { 385 Py_IgnoreEnvironmentFlag++; 386 break; 387 } 388 } 389 390 opt = Py_GETENV("PYTHONMALLOC"); 391 if (_PyMem_SetupAllocators(opt) < 0) { 392 fprintf(stderr, 393 "Error in PYTHONMALLOC: unknown allocator \"%s\"!\n", opt); 394 exit(1); 395 } 396 397 Py_HashRandomizationFlag = 1; 398 _PyRandom_Init(); 399 400 PySys_ResetWarnOptions(); 401 _PyOS_ResetGetOpt(); 402 403 while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) { 404 if (c == 'c') { 405 size_t len; 406 /* -c is the last option; following arguments 407 that look like options are left for the 408 command to interpret. */ 409 410 len = wcslen(_PyOS_optarg) + 1 + 1; 411 command = (wchar_t *)PyMem_RawMalloc(sizeof(wchar_t) * len); 412 if (command == NULL) 413 Py_FatalError( 414 "not enough memory to copy -c argument"); 415 wcscpy(command, _PyOS_optarg); 416 command[len - 2] = '\n'; 417 command[len - 1] = 0; 418 break; 419 } 420 421 if (c == 'm') { 422 /* -m is the last option; following arguments 423 that look like options are left for the 424 module to interpret. */ 425 module = _PyOS_optarg; 426 break; 427 } 428 429 switch (c) { 430 case 'b': 431 Py_BytesWarningFlag++; 432 break; 433 434 case 'd': 435 Py_DebugFlag++; 436 break; 437 438 case 'i': 439 Py_InspectFlag++; 440 Py_InteractiveFlag++; 441 break; 442 443 case 'I': 444 Py_IsolatedFlag++; 445 Py_NoUserSiteDirectory++; 446 Py_IgnoreEnvironmentFlag++; 447 break; 448 449 /* case 'J': reserved for Jython */ 450 451 case 'O': 452 Py_OptimizeFlag++; 453 break; 454 455 case 'B': 456 Py_DontWriteBytecodeFlag++; 457 break; 458 459 case 's': 460 Py_NoUserSiteDirectory++; 461 break; 462 463 case 'S': 464 Py_NoSiteFlag++; 465 break; 466 467 case 'E': 468 /* Already handled above */ 469 break; 470 471 case 't': 472 /* ignored for backwards compatibility */ 473 break; 474 475 case 'u': 476 Py_UnbufferedStdioFlag = 1; 477 saw_unbuffered_flag = 1; 478 break; 479 480 case 'v': 481 Py_VerboseFlag++; 482 break; 483 484 case 'x': 485 skipfirstline = 1; 486 break; 487 488 case 'h': 489 case '?': 490 help++; 491 break; 492 493 case 'V': 494 version++; 495 break; 496 497 case 'W': 498 if (warning_options == NULL) 499 warning_options = PyList_New(0); 500 if (warning_options == NULL) 501 Py_FatalError("failure in handling of -W argument"); 502 warning_option = PyUnicode_FromWideChar(_PyOS_optarg, -1); 503 if (warning_option == NULL) 504 Py_FatalError("failure in handling of -W argument"); 505 if (PyList_Append(warning_options, warning_option) == -1) 506 Py_FatalError("failure in handling of -W argument"); 507 Py_DECREF(warning_option); 508 break; 509 510 case 'X': 511 PySys_AddXOption(_PyOS_optarg); 512 break; 513 514 case 'q': 515 Py_QuietFlag++; 516 break; 517 518 case 'R': 519 /* Ignored */ 520 break; 521 522 /* This space reserved for other options */ 523 524 default: 525 return usage(2, argv[0]); 526 /*NOTREACHED*/ 527 528 } 529 } 530 531 if (help) 532 return usage(0, argv[0]); 533 534 if (version) { 535 printf("Python %s\n", version >= 2 ? Py_GetVersion() : PY_VERSION); 536 return 0; 537 } 538 539 if (!Py_InspectFlag && 540 (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') 541 Py_InspectFlag = 1; 542 if (!saw_unbuffered_flag && 543 (p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0') 544 Py_UnbufferedStdioFlag = 1; 545 546 if (!Py_NoUserSiteDirectory && 547 (p = Py_GETENV("PYTHONNOUSERSITE")) && *p != '\0') 548 Py_NoUserSiteDirectory = 1; 549 550 #ifdef MS_WINDOWS 551 if (!Py_IgnoreEnvironmentFlag && (wp = _wgetenv(L"PYTHONWARNINGS")) && 552 *wp != L'\0') { 553 wchar_t *buf, *warning, *context = NULL; 554 555 buf = (wchar_t *)PyMem_RawMalloc((wcslen(wp) + 1) * sizeof(wchar_t)); 556 if (buf == NULL) 557 Py_FatalError( 558 "not enough memory to copy PYTHONWARNINGS"); 559 wcscpy(buf, wp); 560 for (warning = wcstok_s(buf, L",", &context); 561 warning != NULL; 562 warning = wcstok_s(NULL, L",", &context)) { 563 PySys_AddWarnOption(warning); 564 } 565 PyMem_RawFree(buf); 566 } 567 #else 568 if ((p = Py_GETENV("PYTHONWARNINGS")) && *p != '\0') { 569 char *buf, *oldloc; 570 PyObject *unicode; 571 572 /* settle for strtok here as there's no one standard 573 C89 wcstok */ 574 buf = (char *)PyMem_RawMalloc(strlen(p) + 1); 575 if (buf == NULL) 576 Py_FatalError( 577 "not enough memory to copy PYTHONWARNINGS"); 578 strcpy(buf, p); 579 oldloc = _PyMem_RawStrdup(setlocale(LC_ALL, NULL)); 580 setlocale(LC_ALL, ""); 581 for (p = strtok(buf, ","); p != NULL; p = strtok(NULL, ",")) { 582 #ifdef __APPLE__ 583 /* Use utf-8 on Mac OS X */ 584 unicode = PyUnicode_FromString(p); 585 #else 586 unicode = PyUnicode_DecodeLocale(p, "surrogateescape"); 587 #endif 588 if (unicode == NULL) { 589 /* ignore errors */ 590 PyErr_Clear(); 591 continue; 592 } 593 PySys_AddWarnOptionUnicode(unicode); 594 Py_DECREF(unicode); 595 } 596 setlocale(LC_ALL, oldloc); 597 PyMem_RawFree(oldloc); 598 PyMem_RawFree(buf); 599 } 600 #endif 601 if (warning_options != NULL) { 602 Py_ssize_t i; 603 for (i = 0; i < PyList_GET_SIZE(warning_options); i++) { 604 PySys_AddWarnOptionUnicode(PyList_GET_ITEM(warning_options, i)); 605 } 606 } 607 608 if (command == NULL && module == NULL && _PyOS_optind < argc && 609 wcscmp(argv[_PyOS_optind], L"-") != 0) 610 { 611 filename = argv[_PyOS_optind]; 612 } 613 614 stdin_is_interactive = Py_FdIsInteractive(stdin, (char *)0); 615 616 #if defined(MS_WINDOWS) || defined(__CYGWIN__) 617 /* don't translate newlines (\r\n <=> \n) */ 618 _setmode(fileno(stdin), O_BINARY); 619 _setmode(fileno(stdout), O_BINARY); 620 _setmode(fileno(stderr), O_BINARY); 621 #endif 622 623 if (Py_UnbufferedStdioFlag) { 624 #ifdef HAVE_SETVBUF 625 setvbuf(stdin, (char *)NULL, _IONBF, BUFSIZ); 626 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ); 627 setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ); 628 #else /* !HAVE_SETVBUF */ 629 setbuf(stdin, (char *)NULL); 630 setbuf(stdout, (char *)NULL); 631 setbuf(stderr, (char *)NULL); 632 #endif /* !HAVE_SETVBUF */ 633 } 634 else if (Py_InteractiveFlag) { 635 #ifdef MS_WINDOWS 636 /* Doesn't have to have line-buffered -- use unbuffered */ 637 /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */ 638 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ); 639 #else /* !MS_WINDOWS */ 640 #ifdef HAVE_SETVBUF 641 setvbuf(stdin, (char *)NULL, _IOLBF, BUFSIZ); 642 setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ); 643 #endif /* HAVE_SETVBUF */ 644 #endif /* !MS_WINDOWS */ 645 /* Leave stderr alone - it should be unbuffered anyway. */ 646 } 647 648 #ifdef __APPLE__ 649 /* On MacOS X, when the Python interpreter is embedded in an 650 application bundle, it gets executed by a bootstrapping script 651 that does os.execve() with an argv[0] that's different from the 652 actual Python executable. This is needed to keep the Finder happy, 653 or rather, to work around Apple's overly strict requirements of 654 the process name. However, we still need a usable sys.executable, 655 so the actual executable path is passed in an environment variable. 656 See Lib/plat-mac/bundlebuiler.py for details about the bootstrap 657 script. */ 658 if ((p = Py_GETENV("PYTHONEXECUTABLE")) && *p != '\0') { 659 wchar_t* buffer; 660 size_t len = strlen(p) + 1; 661 662 buffer = PyMem_RawMalloc(len * sizeof(wchar_t)); 663 if (buffer == NULL) { 664 Py_FatalError( 665 "not enough memory to copy PYTHONEXECUTABLE"); 666 } 667 668 mbstowcs(buffer, p, len); 669 Py_SetProgramName(buffer); 670 /* buffer is now handed off - do not free */ 671 } else { 672 #ifdef WITH_NEXT_FRAMEWORK 673 char* pyvenv_launcher = getenv("__PYVENV_LAUNCHER__"); 674 675 if (pyvenv_launcher && *pyvenv_launcher) { 676 /* Used by Mac/Tools/pythonw.c to forward 677 * the argv0 of the stub executable 678 */ 679 wchar_t* wbuf = Py_DecodeLocale(pyvenv_launcher, NULL); 680 681 if (wbuf == NULL) { 682 Py_FatalError("Cannot decode __PYVENV_LAUNCHER__"); 683 } 684 Py_SetProgramName(wbuf); 685 686 /* Don't free wbuf, the argument to Py_SetProgramName 687 * must remain valid until Py_FinalizeEx is called. 688 */ 689 } else { 690 Py_SetProgramName(argv[0]); 691 } 692 #else 693 Py_SetProgramName(argv[0]); 694 #endif 695 } 696 #else 697 Py_SetProgramName(argv[0]); 698 #endif 699 Py_Initialize(); 700 Py_XDECREF(warning_options); 701 702 if (!Py_QuietFlag && (Py_VerboseFlag || 703 (command == NULL && filename == NULL && 704 module == NULL && stdin_is_interactive))) { 705 fprintf(stderr, "Python %s on %s\n", 706 Py_GetVersion(), Py_GetPlatform()); 707 if (!Py_NoSiteFlag) 708 fprintf(stderr, "%s\n", COPYRIGHT); 709 } 710 711 if (command != NULL) { 712 /* Backup _PyOS_optind and force sys.argv[0] = '-c' */ 713 _PyOS_optind--; 714 argv[_PyOS_optind] = L"-c"; 715 } 716 717 if (module != NULL) { 718 /* Backup _PyOS_optind and force sys.argv[0] = '-m'*/ 719 _PyOS_optind--; 720 argv[_PyOS_optind] = L"-m"; 721 } 722 723 if (filename != NULL) { 724 main_importer_path = AsImportPathEntry(filename); 725 } 726 727 if (main_importer_path != NULL) { 728 /* Let RunMainFromImporter adjust sys.path[0] later */ 729 PySys_SetArgvEx(argc-_PyOS_optind, argv+_PyOS_optind, 0); 730 } else { 731 /* Use config settings to decide whether or not to update sys.path[0] */ 732 PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind); 733 } 734 735 if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) && 736 isatty(fileno(stdin)) && 737 !Py_IsolatedFlag) { 738 PyObject *v; 739 v = PyImport_ImportModule("readline"); 740 if (v == NULL) 741 PyErr_Clear(); 742 else 743 Py_DECREF(v); 744 } 745 746 if (command) { 747 sts = run_command(command, &cf); 748 PyMem_RawFree(command); 749 } else if (module) { 750 sts = (RunModule(module, 1) != 0); 751 } 752 else { 753 754 if (filename == NULL && stdin_is_interactive) { 755 Py_InspectFlag = 0; /* do exit on SystemExit */ 756 RunStartupFile(&cf); 757 RunInteractiveHook(); 758 } 759 /* XXX */ 760 761 sts = -1; /* keep track of whether we've already run __main__ */ 762 763 if (main_importer_path != NULL) { 764 sts = RunMainFromImporter(main_importer_path); 765 } 766 767 if (sts==-1 && filename != NULL) { 768 fp = _Py_wfopen(filename, L"r"); 769 if (fp == NULL) { 770 char *cfilename_buffer; 771 const char *cfilename; 772 int err = errno; 773 cfilename_buffer = Py_EncodeLocale(filename, NULL); 774 if (cfilename_buffer != NULL) 775 cfilename = cfilename_buffer; 776 else 777 cfilename = "<unprintable file name>"; 778 fprintf(stderr, "%ls: can't open file '%s': [Errno %d] %s\n", 779 argv[0], cfilename, err, strerror(err)); 780 if (cfilename_buffer) 781 PyMem_Free(cfilename_buffer); 782 return 2; 783 } 784 else if (skipfirstline) { 785 int ch; 786 /* Push back first newline so line numbers 787 remain the same */ 788 while ((ch = getc(fp)) != EOF) { 789 if (ch == '\n') { 790 (void)ungetc(ch, fp); 791 break; 792 } 793 } 794 } 795 { 796 struct _Py_stat_struct sb; 797 if (_Py_fstat_noraise(fileno(fp), &sb) == 0 && 798 S_ISDIR(sb.st_mode)) { 799 fprintf(stderr, 800 "%ls: '%ls' is a directory, cannot continue\n", 801 argv[0], filename); 802 fclose(fp); 803 return 1; 804 } 805 } 806 } 807 808 if (sts == -1) 809 sts = run_file(fp, filename, &cf); 810 } 811 812 /* Check this environment variable at the end, to give programs the 813 * opportunity to set it from Python. 814 */ 815 if (!Py_InspectFlag && 816 (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') 817 { 818 Py_InspectFlag = 1; 819 } 820 821 if (Py_InspectFlag && stdin_is_interactive && 822 (filename != NULL || command != NULL || module != NULL)) { 823 Py_InspectFlag = 0; 824 RunInteractiveHook(); 825 /* XXX */ 826 sts = PyRun_AnyFileFlags(stdin, "<stdin>", &cf) != 0; 827 } 828 829 if (Py_FinalizeEx() < 0) { 830 /* Value unlikely to be confused with a non-error exit status or 831 other special meaning */ 832 sts = 120; 833 } 834 835 #ifdef __INSURE__ 836 /* Insure++ is a memory analysis tool that aids in discovering 837 * memory leaks and other memory problems. On Python exit, the 838 * interned string dictionaries are flagged as being in use at exit 839 * (which it is). Under normal circumstances, this is fine because 840 * the memory will be automatically reclaimed by the system. Under 841 * memory debugging, it's a huge source of useless noise, so we 842 * trade off slower shutdown for less distraction in the memory 843 * reports. -baw 844 */ 845 _Py_ReleaseInternedUnicodeStrings(); 846 #endif /* __INSURE__ */ 847 848 return sts; 849 } 850 851 /* this is gonna seem *real weird*, but if you put some other code between 852 Py_Main() and Py_GetArgcArgv() you will need to adjust the test in the 853 while statement in Misc/gdbinit:ppystack */ 854 855 /* Make the *original* argc/argv available to other modules. 856 This is rare, but it is needed by the secureware extension. */ 857 858 void 859 Py_GetArgcArgv(int *argc, wchar_t ***argv) 860 { 861 *argc = orig_argc; 862 *argv = orig_argv; 863 } 864 865 #ifdef __cplusplus 866 } 867 #endif 868
