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