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
usage(int exitcode,const wchar_t * program)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
RunStartupFile(PyCompilerFlags * cf)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
RunInteractiveHook(void)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
RunModule(wchar_t * modname,int set_argv0)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 *
AsImportPathEntry(wchar_t * filename)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
RunMainFromImporter(PyObject * sys_path0)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
run_command(wchar_t * command,PyCompilerFlags * cf)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
run_file(FILE * fp,const wchar_t * filename,PyCompilerFlags * p_cf)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
Py_Main(int argc,wchar_t ** argv)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
Py_GetArgcArgv(int * argc,wchar_t *** argv)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