|
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\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 fprintf(f, usage_1); |
|
116 fprintf(f, usage_2); |
|
117 fprintf(f, usage_3); |
|
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 /* Wait until threading._shutdown completes, provided |
|
226 the threading module was imported in the first place. |
|
227 The shutdown routine will wait until all non-daemon |
|
228 "threading" threads have completed. */ |
|
229 #include "abstract.h" |
|
230 static void |
|
231 WaitForThreadShutdown(void) |
|
232 { |
|
233 #ifdef WITH_THREAD |
|
234 PyObject *result; |
|
235 PyThreadState *tstate = PyThreadState_GET(); |
|
236 PyObject *threading = PyMapping_GetItemString(tstate->interp->modules, |
|
237 "threading"); |
|
238 if (threading == NULL) { |
|
239 /* threading not imported */ |
|
240 PyErr_Clear(); |
|
241 return; |
|
242 } |
|
243 result = PyObject_CallMethod(threading, "_shutdown", ""); |
|
244 if (result == NULL) |
|
245 PyErr_WriteUnraisable(threading); |
|
246 else |
|
247 Py_DECREF(result); |
|
248 Py_DECREF(threading); |
|
249 #endif |
|
250 } |
|
251 |
|
252 /* Main program */ |
|
253 |
|
254 int |
|
255 Py_Main(int argc, char **argv) |
|
256 { |
|
257 int c; |
|
258 int sts; |
|
259 char *command = NULL; |
|
260 char *filename = NULL; |
|
261 char *module = NULL; |
|
262 FILE *fp = stdin; |
|
263 char *p; |
|
264 int unbuffered = 0; |
|
265 int skipfirstline = 0; |
|
266 int stdin_is_interactive = 0; |
|
267 int help = 0; |
|
268 int version = 0; |
|
269 int saw_unbuffered_flag = 0; |
|
270 PyCompilerFlags cf; |
|
271 |
|
272 cf.cf_flags = 0; |
|
273 |
|
274 orig_argc = argc; /* For Py_GetArgcArgv() */ |
|
275 orig_argv = argv; |
|
276 |
|
277 #ifdef RISCOS |
|
278 Py_RISCOSWimpFlag = 0; |
|
279 #endif |
|
280 |
|
281 PySys_ResetWarnOptions(); |
|
282 |
|
283 while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) { |
|
284 if (c == 'c') { |
|
285 /* -c is the last option; following arguments |
|
286 that look like options are left for the |
|
287 command to interpret. */ |
|
288 command = (char *)malloc(strlen(_PyOS_optarg) + 2); |
|
289 if (command == NULL) |
|
290 Py_FatalError( |
|
291 "not enough memory to copy -c argument"); |
|
292 strcpy(command, _PyOS_optarg); |
|
293 strcat(command, "\n"); |
|
294 break; |
|
295 } |
|
296 |
|
297 if (c == 'm') { |
|
298 /* -m is the last option; following arguments |
|
299 that look like options are left for the |
|
300 module to interpret. */ |
|
301 module = (char *)malloc(strlen(_PyOS_optarg) + 2); |
|
302 if (module == NULL) |
|
303 Py_FatalError( |
|
304 "not enough memory to copy -m argument"); |
|
305 strcpy(module, _PyOS_optarg); |
|
306 break; |
|
307 } |
|
308 |
|
309 switch (c) { |
|
310 case 'b': |
|
311 Py_BytesWarningFlag++; |
|
312 break; |
|
313 |
|
314 case 'd': |
|
315 Py_DebugFlag++; |
|
316 break; |
|
317 |
|
318 case '3': |
|
319 Py_Py3kWarningFlag++; |
|
320 break; |
|
321 |
|
322 case 'Q': |
|
323 if (strcmp(_PyOS_optarg, "old") == 0) { |
|
324 Py_DivisionWarningFlag = 0; |
|
325 break; |
|
326 } |
|
327 if (strcmp(_PyOS_optarg, "warn") == 0) { |
|
328 Py_DivisionWarningFlag = 1; |
|
329 break; |
|
330 } |
|
331 if (strcmp(_PyOS_optarg, "warnall") == 0) { |
|
332 Py_DivisionWarningFlag = 2; |
|
333 break; |
|
334 } |
|
335 if (strcmp(_PyOS_optarg, "new") == 0) { |
|
336 /* This only affects __main__ */ |
|
337 cf.cf_flags |= CO_FUTURE_DIVISION; |
|
338 /* And this tells the eval loop to treat |
|
339 BINARY_DIVIDE as BINARY_TRUE_DIVIDE */ |
|
340 _Py_QnewFlag = 1; |
|
341 break; |
|
342 } |
|
343 fprintf(stderr, |
|
344 "-Q option should be `-Qold', " |
|
345 "`-Qwarn', `-Qwarnall', or `-Qnew' only\n"); |
|
346 return usage(2, argv[0]); |
|
347 /* NOTREACHED */ |
|
348 |
|
349 case 'i': |
|
350 Py_InspectFlag++; |
|
351 Py_InteractiveFlag++; |
|
352 break; |
|
353 |
|
354 /* case 'J': reserved for Jython */ |
|
355 |
|
356 case 'O': |
|
357 Py_OptimizeFlag++; |
|
358 break; |
|
359 |
|
360 case 'B': |
|
361 Py_DontWriteBytecodeFlag++; |
|
362 break; |
|
363 |
|
364 case 's': |
|
365 Py_NoUserSiteDirectory++; |
|
366 break; |
|
367 |
|
368 case 'S': |
|
369 Py_NoSiteFlag++; |
|
370 break; |
|
371 |
|
372 case 'E': |
|
373 Py_IgnoreEnvironmentFlag++; |
|
374 break; |
|
375 |
|
376 case 't': |
|
377 Py_TabcheckFlag++; |
|
378 break; |
|
379 |
|
380 case 'u': |
|
381 unbuffered++; |
|
382 saw_unbuffered_flag = 1; |
|
383 break; |
|
384 |
|
385 case 'v': |
|
386 Py_VerboseFlag++; |
|
387 break; |
|
388 |
|
389 #ifdef RISCOS |
|
390 case 'w': |
|
391 Py_RISCOSWimpFlag = 1; |
|
392 break; |
|
393 #endif |
|
394 |
|
395 case 'x': |
|
396 skipfirstline = 1; |
|
397 break; |
|
398 |
|
399 /* case 'X': reserved for implementation-specific arguments */ |
|
400 |
|
401 case 'U': |
|
402 Py_UnicodeFlag++; |
|
403 break; |
|
404 case 'h': |
|
405 case '?': |
|
406 help++; |
|
407 break; |
|
408 case 'V': |
|
409 version++; |
|
410 break; |
|
411 |
|
412 case 'W': |
|
413 PySys_AddWarnOption(_PyOS_optarg); |
|
414 break; |
|
415 |
|
416 /* This space reserved for other options */ |
|
417 |
|
418 default: |
|
419 return usage(2, argv[0]); |
|
420 /*NOTREACHED*/ |
|
421 |
|
422 } |
|
423 } |
|
424 |
|
425 if (help) |
|
426 return usage(0, argv[0]); |
|
427 |
|
428 if (version) { |
|
429 fprintf(stderr, "Python %s\n", PY_VERSION); |
|
430 return 0; |
|
431 } |
|
432 |
|
433 if (!Py_InspectFlag && |
|
434 (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') |
|
435 Py_InspectFlag = 1; |
|
436 if (!saw_unbuffered_flag && |
|
437 (p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0') |
|
438 unbuffered = 1; |
|
439 |
|
440 if (!Py_NoUserSiteDirectory && |
|
441 (p = Py_GETENV("PYTHONNOUSERSITE")) && *p != '\0') |
|
442 Py_NoUserSiteDirectory = 1; |
|
443 |
|
444 if (command == NULL && module == NULL && _PyOS_optind < argc && |
|
445 strcmp(argv[_PyOS_optind], "-") != 0) |
|
446 { |
|
447 #ifdef __VMS |
|
448 filename = decc$translate_vms(argv[_PyOS_optind]); |
|
449 if (filename == (char *)0 || filename == (char *)-1) |
|
450 filename = argv[_PyOS_optind]; |
|
451 |
|
452 #else |
|
453 filename = argv[_PyOS_optind]; |
|
454 #endif |
|
455 } |
|
456 |
|
457 stdin_is_interactive = Py_FdIsInteractive(stdin, (char *)0); |
|
458 |
|
459 if (unbuffered) { |
|
460 #if defined(MS_WINDOWS) || defined(__CYGWIN__) |
|
461 _setmode(fileno(stdin), O_BINARY); |
|
462 _setmode(fileno(stdout), O_BINARY); |
|
463 #endif |
|
464 #ifdef HAVE_SETVBUF |
|
465 setvbuf(stdin, (char *)NULL, _IONBF, BUFSIZ); |
|
466 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ); |
|
467 setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ); |
|
468 #else /* !HAVE_SETVBUF */ |
|
469 setbuf(stdin, (char *)NULL); |
|
470 setbuf(stdout, (char *)NULL); |
|
471 setbuf(stderr, (char *)NULL); |
|
472 #endif /* !HAVE_SETVBUF */ |
|
473 } |
|
474 else if (Py_InteractiveFlag) { |
|
475 #ifdef MS_WINDOWS |
|
476 /* Doesn't have to have line-buffered -- use unbuffered */ |
|
477 /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */ |
|
478 setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ); |
|
479 #else /* !MS_WINDOWS */ |
|
480 #ifdef HAVE_SETVBUF |
|
481 setvbuf(stdin, (char *)NULL, _IOLBF, BUFSIZ); |
|
482 setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ); |
|
483 #endif /* HAVE_SETVBUF */ |
|
484 #endif /* !MS_WINDOWS */ |
|
485 /* Leave stderr alone - it should be unbuffered anyway. */ |
|
486 } |
|
487 #ifdef __VMS |
|
488 else { |
|
489 setvbuf (stdout, (char *)NULL, _IOLBF, BUFSIZ); |
|
490 } |
|
491 #endif /* __VMS */ |
|
492 |
|
493 #ifdef __APPLE__ |
|
494 /* On MacOS X, when the Python interpreter is embedded in an |
|
495 application bundle, it gets executed by a bootstrapping script |
|
496 that does os.execve() with an argv[0] that's different from the |
|
497 actual Python executable. This is needed to keep the Finder happy, |
|
498 or rather, to work around Apple's overly strict requirements of |
|
499 the process name. However, we still need a usable sys.executable, |
|
500 so the actual executable path is passed in an environment variable. |
|
501 See Lib/plat-mac/bundlebuiler.py for details about the bootstrap |
|
502 script. */ |
|
503 if ((p = Py_GETENV("PYTHONEXECUTABLE")) && *p != '\0') |
|
504 Py_SetProgramName(p); |
|
505 else |
|
506 Py_SetProgramName(argv[0]); |
|
507 #else |
|
508 Py_SetProgramName(argv[0]); |
|
509 #endif |
|
510 Py_Initialize(); |
|
511 |
|
512 if (Py_VerboseFlag || |
|
513 (command == NULL && filename == NULL && module == NULL && stdin_is_interactive)) { |
|
514 fprintf(stderr, "Python %s on %s\n", |
|
515 Py_GetVersion(), Py_GetPlatform()); |
|
516 if (!Py_NoSiteFlag) |
|
517 fprintf(stderr, "%s\n", COPYRIGHT); |
|
518 } |
|
519 |
|
520 if (command != NULL) { |
|
521 /* Backup _PyOS_optind and force sys.argv[0] = '-c' */ |
|
522 _PyOS_optind--; |
|
523 argv[_PyOS_optind] = "-c"; |
|
524 } |
|
525 |
|
526 if (module != NULL) { |
|
527 /* Backup _PyOS_optind and force sys.argv[0] = '-c' |
|
528 so that PySys_SetArgv correctly sets sys.path[0] to ''*/ |
|
529 _PyOS_optind--; |
|
530 argv[_PyOS_optind] = "-c"; |
|
531 } |
|
532 |
|
533 PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind); |
|
534 |
|
535 if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) && |
|
536 isatty(fileno(stdin))) { |
|
537 PyObject *v; |
|
538 v = PyImport_ImportModule("readline"); |
|
539 if (v == NULL) |
|
540 PyErr_Clear(); |
|
541 else |
|
542 Py_DECREF(v); |
|
543 } |
|
544 |
|
545 if (command) { |
|
546 sts = PyRun_SimpleStringFlags(command, &cf) != 0; |
|
547 free(command); |
|
548 } else if (module) { |
|
549 sts = RunModule(module, 1); |
|
550 free(module); |
|
551 } |
|
552 else { |
|
553 |
|
554 if (filename == NULL && stdin_is_interactive) { |
|
555 Py_InspectFlag = 0; /* do exit on SystemExit */ |
|
556 RunStartupFile(&cf); |
|
557 } |
|
558 /* XXX */ |
|
559 |
|
560 sts = -1; /* keep track of whether we've already run __main__ */ |
|
561 |
|
562 if (filename != NULL) { |
|
563 sts = RunMainFromImporter(filename); |
|
564 } |
|
565 |
|
566 if (sts==-1 && filename!=NULL) { |
|
567 if ((fp = fopen(filename, "r")) == NULL) { |
|
568 fprintf(stderr, "%s: can't open file '%s': [Errno %d] %s\n", |
|
569 argv[0], filename, errno, strerror(errno)); |
|
570 |
|
571 return 2; |
|
572 } |
|
573 else if (skipfirstline) { |
|
574 int ch; |
|
575 /* Push back first newline so line numbers |
|
576 remain the same */ |
|
577 while ((ch = getc(fp)) != EOF) { |
|
578 if (ch == '\n') { |
|
579 (void)ungetc(ch, fp); |
|
580 break; |
|
581 } |
|
582 } |
|
583 } |
|
584 { |
|
585 /* XXX: does this work on Win/Win64? (see posix_fstat) */ |
|
586 struct stat sb; |
|
587 if (fstat(fileno(fp), &sb) == 0 && |
|
588 S_ISDIR(sb.st_mode)) { |
|
589 fprintf(stderr, "%s: '%s' is a directory, cannot continue\n", argv[0], filename); |
|
590 fclose(fp); |
|
591 return 1; |
|
592 } |
|
593 } |
|
594 } |
|
595 |
|
596 if (sts==-1) { |
|
597 sts = PyRun_AnyFileExFlags( |
|
598 fp, |
|
599 filename == NULL ? "<stdin>" : filename, |
|
600 filename != NULL, &cf) != 0; |
|
601 } |
|
602 |
|
603 } |
|
604 |
|
605 /* Check this environment variable at the end, to give programs the |
|
606 * opportunity to set it from Python. |
|
607 */ |
|
608 if (!Py_InspectFlag && |
|
609 (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') |
|
610 { |
|
611 Py_InspectFlag = 1; |
|
612 } |
|
613 |
|
614 if (Py_InspectFlag && stdin_is_interactive && |
|
615 (filename != NULL || command != NULL || module != NULL)) { |
|
616 Py_InspectFlag = 0; |
|
617 /* XXX */ |
|
618 sts = PyRun_AnyFileFlags(stdin, "<stdin>", &cf) != 0; |
|
619 } |
|
620 |
|
621 WaitForThreadShutdown(); |
|
622 |
|
623 Py_Finalize(); |
|
624 #ifdef RISCOS |
|
625 if (Py_RISCOSWimpFlag) |
|
626 fprintf(stderr, "\x0cq\x0c"); /* make frontend quit */ |
|
627 #endif |
|
628 |
|
629 #ifdef __INSURE__ |
|
630 /* Insure++ is a memory analysis tool that aids in discovering |
|
631 * memory leaks and other memory problems. On Python exit, the |
|
632 * interned string dictionary is flagged as being in use at exit |
|
633 * (which it is). Under normal circumstances, this is fine because |
|
634 * the memory will be automatically reclaimed by the system. Under |
|
635 * memory debugging, it's a huge source of useless noise, so we |
|
636 * trade off slower shutdown for less distraction in the memory |
|
637 * reports. -baw |
|
638 */ |
|
639 _Py_ReleaseInternedStrings(); |
|
640 #endif /* __INSURE__ */ |
|
641 |
|
642 return sts; |
|
643 } |
|
644 |
|
645 /* this is gonna seem *real weird*, but if you put some other code between |
|
646 Py_Main() and Py_GetArgcArgv() you will need to adjust the test in the |
|
647 while statement in Misc/gdbinit:ppystack */ |
|
648 |
|
649 /* Make the *original* argc/argv available to other modules. |
|
650 This is rare, but it is needed by the secureware extension. */ |
|
651 |
|
652 void |
|
653 Py_GetArgcArgv(int *argc, char ***argv) |
|
654 { |
|
655 *argc = orig_argc; |
|
656 *argv = orig_argv; |
|
657 } |
|
658 |
|
659 #ifdef __cplusplus |
|
660 } |
|
661 #endif |
|
662 |