main.c 24.4 KB
Newer Older
Guido van Rossum's avatar
Guido van Rossum committed
1 2 3
/* Python interpreter main program */

#include "Python.h"
4
#include "osdefs.h"
Guido van Rossum's avatar
Guido van Rossum committed
5

6 7
#include <locale.h>

8
#if defined(MS_WINDOWS) || defined(__CYGWIN__)
9
#include <windows.h>
10
#ifdef HAVE_FCNTL_H
11 12
#include <fcntl.h>
#endif
13
#endif
14

15 16 17 18
#ifdef _MSC_VER
#include <crtdbg.h>
#endif

19
#if defined(MS_WINDOWS)
20 21
#define PYTHONHOMEHELP "<prefix>\\lib"
#else
22
#define PYTHONHOMEHELP "<prefix>/pythonX.X"
23 24
#endif

25 26
#include "pygetopt.h"

27
#define COPYRIGHT \
28 29
    "Type \"help\", \"copyright\", \"credits\" or \"license\" " \
    "for more information."
30

31 32 33 34
#ifdef __cplusplus
extern "C" {
#endif

35
/* For Py_GetArgcArgv(); set by main() */
36
static wchar_t **orig_argv;
Guido van Rossum's avatar
Guido van Rossum committed
37 38
static int  orig_argc;

39
/* command line options */
40
#define BASE_OPTS L"bBc:dEhiIJm:OqRsStuvVW:xX:?"
41 42

#define PROGRAM_OPTS BASE_OPTS
43

Guido van Rossum's avatar
Guido van Rossum committed
44
/* Short usage message (with %s for argv0) */
45
static const char usage_line[] =
46
"usage: %ls [option] ... [-c cmd | -m mod | file | -] [arg] ...\n";
Guido van Rossum's avatar
Guido van Rossum committed
47 48

/* Long usage message, split into parts < 512 bytes */
49
static const char usage_1[] = "\
Guido van Rossum's avatar
Guido van Rossum committed
50
Options and arguments (and corresponding environment variables):\n\
51 52
-b     : issue warnings about str(bytes_instance), str(bytearray_instance)\n\
         and comparing bytes/bytearray with str. (-bb: issue errors)\n\
53
-B     : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x\n\
54
-c cmd : program passed in as string (terminates option list)\n\
55
-d     : debug output from parser; also PYTHONDEBUG=x\n\
56
-E     : ignore PYTHON* environment variables (such as PYTHONPATH)\n\
57
-h     : print this help message and exit (also --help)\n\
58
";
59
static const char usage_2[] = "\
60 61
-i     : inspect interactively after running script; forces a prompt even\n\
         if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\
62
-I     : isolate Python from the user's environment (implies -E and -s)\n\
63
-m mod : run library module as a script (terminates option list)\n\
64
-O     : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x\n\
65
-OO    : remove doc-strings in addition to the -O optimizations\n\
66
-q     : don't print version and copyright messages on interactive startup\n\
67
-s     : don't add user site directory to sys.path; also PYTHONNOUSERSITE\n\
68
-S     : don't imply 'import site' on initialization\n\
69
";
70
static const char usage_3[] = "\
71 72
-u     : unbuffered binary stdout and stderr, stdin always buffered;\n\
         also PYTHONUNBUFFERED=x\n\
73
         see man page for details on internal buffering relating to '-u'\n\
74 75
-v     : verbose (trace import statements); also PYTHONVERBOSE=x\n\
         can be supplied multiple times to increase verbosity\n\
76
-V     : print the Python version number and exit (also --version)\n\
77
-W arg : warning control; arg is action:message:category:module:lineno\n\
78
         also PYTHONWARNINGS=arg\n\
79
-x     : skip first line of source, allowing use of non-Unix forms of #!cmd\n\
80
-X opt : set implementation-specific option\n\
81
";
82
static const char usage_4[] = "\
83 84
file   : program read from script file\n\
-      : program read from stdin (default; interactive mode if a tty)\n\
85
arg ...: arguments passed to program in sys.argv[1:]\n\n\
Guido van Rossum's avatar
Guido van Rossum committed
86 87
Other environment variables:\n\
PYTHONSTARTUP: file executed on interactive startup (no default)\n\
88
PYTHONPATH   : '%lc'-separated list of directories prefixed to the\n\
Guido van Rossum's avatar
Guido van Rossum committed
89
               default module search path.  The result is sys.path.\n\
90
";
91
static const char usage_5[] =
92
"PYTHONHOME   : alternate <prefix> directory (or <prefix>%lc<exec_prefix>).\n"
93 94 95
"               The default module search path uses %s.\n"
"PYTHONCASEOK : ignore case in 'import' statements (Windows).\n"
"PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.\n"
96 97 98 99 100 101 102 103 104
"PYTHONFAULTHANDLER: dump the Python traceback on fatal errors.\n";
static const char usage_6[] =
"PYTHONHASHSEED: if this variable is set to 'random', a random value is used\n"
"   to seed the hashes of str, bytes and datetime objects.  It can also be\n"
"   set to an integer in the range [0,4294967295] to get hash values with a\n"
"   predictable seed.\n"
"PYTHONMALLOC: set the Python memory allocators and/or install debug hooks\n"
"   on Python memory allocators. Use PYTHONMALLOC=debug to install debug\n"
"   hooks.\n";
Guido van Rossum's avatar
Guido van Rossum committed
105

106
static int
107
usage(int exitcode, const wchar_t* program)
108
{
109 110 111 112 113 114 115 116 117
    FILE *f = exitcode ? stderr : stdout;

    fprintf(f, usage_line, program);
    if (exitcode)
        fprintf(f, "Try `python -h' for more information.\n");
    else {
        fputs(usage_1, f);
        fputs(usage_2, f);
        fputs(usage_3, f);
118 119
        fprintf(f, usage_4, (wint_t)DELIM);
        fprintf(f, usage_5, (wint_t)DELIM, PYTHONHOMEHELP);
120
        fputs(usage_6, f);
121 122
    }
    return exitcode;
123 124
}

125 126
static void RunStartupFile(PyCompilerFlags *cf)
{
127 128
    char *startup = Py_GETENV("PYTHONSTARTUP");
    if (startup != NULL && startup[0] != '\0') {
129
        FILE *fp = _Py_fopen(startup, "r");
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
        if (fp != NULL) {
            (void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);
            PyErr_Clear();
            fclose(fp);
        } else {
            int save_errno;

            save_errno = errno;
            PySys_WriteStderr("Could not open PYTHONSTARTUP\n");
            errno = save_errno;
            PyErr_SetFromErrnoWithFilename(PyExc_IOError,
                            startup);
            PyErr_Print();
            PyErr_Clear();
        }
    }
146 147
}

148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
static void RunInteractiveHook(void)
{
    PyObject *sys, *hook, *result;
    sys = PyImport_ImportModule("sys");
    if (sys == NULL)
        goto error;
    hook = PyObject_GetAttrString(sys, "__interactivehook__");
    Py_DECREF(sys);
    if (hook == NULL)
        PyErr_Clear();
    else {
        result = PyObject_CallObject(hook, NULL);
        Py_DECREF(hook);
        if (result == NULL)
            goto error;
        else
            Py_DECREF(result);
    }
    return;

error:
    PySys_WriteStderr("Failed calling sys.__interactivehook__\n");
    PyErr_Print();
    PyErr_Clear();
}

174

175
static int RunModule(wchar_t *modname, int set_argv0)
176
{
177 178 179 180
    PyObject *module, *runpy, *runmodule, *runargs, *result;
    runpy = PyImport_ImportModule("runpy");
    if (runpy == NULL) {
        fprintf(stderr, "Could not import runpy module\n");
181
        PyErr_Print();
182 183 184 185 186
        return -1;
    }
    runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main");
    if (runmodule == NULL) {
        fprintf(stderr, "Could not access runpy._run_module_as_main\n");
187
        PyErr_Print();
188 189 190 191 192 193
        Py_DECREF(runpy);
        return -1;
    }
    module = PyUnicode_FromWideChar(modname, wcslen(modname));
    if (module == NULL) {
        fprintf(stderr, "Could not convert module name to unicode\n");
194
        PyErr_Print();
195 196 197 198 199 200 201 202
        Py_DECREF(runpy);
        Py_DECREF(runmodule);
        return -1;
    }
    runargs = Py_BuildValue("(Oi)", module, set_argv0);
    if (runargs == NULL) {
        fprintf(stderr,
            "Could not create arguments for runpy._run_module_as_main\n");
203
        PyErr_Print();
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
        Py_DECREF(runpy);
        Py_DECREF(runmodule);
        Py_DECREF(module);
        return -1;
    }
    result = PyObject_Call(runmodule, runargs, NULL);
    if (result == NULL) {
        PyErr_Print();
    }
    Py_DECREF(runpy);
    Py_DECREF(runmodule);
    Py_DECREF(module);
    Py_DECREF(runargs);
    if (result == NULL) {
        return -1;
    }
    Py_DECREF(result);
    return 0;
222
}
223

224 225
static int
RunMainFromImporter(wchar_t *filename)
226
{
227 228
    PyObject *argv0 = NULL, *importer, *sys_path;
    int sts;
229

230 231 232 233 234 235 236 237
    argv0 = PyUnicode_FromWideChar(filename, wcslen(filename));
    if (argv0 == NULL)
        goto error;

    importer = PyImport_GetImporter(argv0);
    if (importer == NULL)
        goto error;

238
    if (importer == Py_None) {
239 240
        Py_DECREF(argv0);
        Py_DECREF(importer);
241 242
        return -1;
    }
243 244 245 246
    Py_DECREF(importer);

    /* argv0 is usable as an import source, so put it in sys.path[0]
       and import __main__ */
247
    sys_path = PySys_GetObject("path");
248 249
    if (sys_path == NULL) {
        PyErr_SetString(PyExc_RuntimeError, "unable to get sys.path");
250
        goto error;
251
    }
252 253 254 255 256 257 258 259 260 261 262 263 264
    if (PyList_SetItem(sys_path, 0, argv0)) {
        argv0 = NULL;
        goto error;
    }
    Py_INCREF(argv0);

    sts = RunModule(L"__main__", 0);
    return sts != 0;

error:
    Py_XDECREF(argv0);
    PyErr_Print();
    return 1;
265 266
}

267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
static int
run_command(wchar_t *command, PyCompilerFlags *cf)
{
    PyObject *unicode, *bytes;
    int ret;

    unicode = PyUnicode_FromWideChar(command, -1);
    if (unicode == NULL)
        goto error;
    bytes = PyUnicode_AsUTF8String(unicode);
    Py_DECREF(unicode);
    if (bytes == NULL)
        goto error;
    ret = PyRun_SimpleStringFlags(PyBytes_AsString(bytes), cf);
    Py_DECREF(bytes);
    return ret != 0;

error:
285
    PySys_WriteStderr("Unable to decode the command from the command line:\n");
286 287 288 289
    PyErr_Print();
    return 1;
}

290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
static int
run_file(FILE *fp, const wchar_t *filename, PyCompilerFlags *p_cf)
{
    PyObject *unicode, *bytes = NULL;
    char *filename_str;
    int run;

    /* call pending calls like signal handlers (SIGINT) */
    if (Py_MakePendingCalls() == -1) {
        PyErr_Print();
        return 1;
    }

    if (filename) {
        unicode = PyUnicode_FromWideChar(filename, wcslen(filename));
        if (unicode != NULL) {
306
            bytes = PyUnicode_EncodeFSDefault(unicode);
307 308 309 310 311 312
            Py_DECREF(unicode);
        }
        if (bytes != NULL)
            filename_str = PyBytes_AsString(bytes);
        else {
            PyErr_Clear();
313
            filename_str = "<encoding error>";
314 315 316 317 318 319 320 321 322 323
        }
    }
    else
        filename_str = "<stdin>";

    run = PyRun_AnyFileExFlags(fp, filename_str, filename != NULL, p_cf);
    Py_XDECREF(bytes);
    return run != 0;
}

324

Guido van Rossum's avatar
Guido van Rossum committed
325 326
/* Main program */

327
int
328
Py_Main(int argc, wchar_t **argv)
Guido van Rossum's avatar
Guido van Rossum committed
329
{
330 331 332 333 334 335 336
    int c;
    int sts;
    wchar_t *command = NULL;
    wchar_t *filename = NULL;
    wchar_t *module = NULL;
    FILE *fp = stdin;
    char *p;
337
#ifdef MS_WINDOWS
338
    wchar_t *wp;
339
#endif
340 341 342 343 344
    int skipfirstline = 0;
    int stdin_is_interactive = 0;
    int help = 0;
    int version = 0;
    int saw_unbuffered_flag = 0;
345
    char *opt;
346
    PyCompilerFlags cf;
347 348
    PyObject *warning_option = NULL;
    PyObject *warning_options = NULL;
349 350 351 352 353 354

    cf.cf_flags = 0;

    orig_argc = argc;           /* For Py_GetArgcArgv() */
    orig_argv = argv;

355 356
    /* Hash randomization needed early for all string operations
       (including -W and -X options). */
357
    _PyOS_opterr = 0;  /* prevent printing the error in 1st pass */
358 359 360 361 362 363
    while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
        if (c == 'm' || c == 'c') {
            /* -c / -m is the last option: following arguments are
               not interpreter options. */
            break;
        }
364
        if (c == 'E') {
365 366 367 368 369
            Py_IgnoreEnvironmentFlag++;
            break;
        }
    }

370 371 372 373 374 375 376
    opt = Py_GETENV("PYTHONMALLOC");
    if (_PyMem_SetupAllocators(opt) < 0) {
        fprintf(stderr,
                "Error in PYTHONMALLOC: unknown allocator \"%s\"!\n", opt);
        exit(1);
    }

377
    Py_HashRandomizationFlag = 1;
378 379
    _PyRandom_Init();

380
    PySys_ResetWarnOptions();
381
    _PyOS_ResetGetOpt();
382 383 384 385 386 387 388 389 390

    while ((c = _PyOS_GetOpt(argc, argv, PROGRAM_OPTS)) != EOF) {
        if (c == 'c') {
            size_t len;
            /* -c is the last option; following arguments
               that look like options are left for the
               command to interpret. */

            len = wcslen(_PyOS_optarg) + 1 + 1;
391
            command = (wchar_t *)PyMem_RawMalloc(sizeof(wchar_t) * len);
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
            if (command == NULL)
                Py_FatalError(
                   "not enough memory to copy -c argument");
            wcscpy(command, _PyOS_optarg);
            command[len - 2] = '\n';
            command[len - 1] = 0;
            break;
        }

        if (c == 'm') {
            /* -m is the last option; following arguments
               that look like options are left for the
               module to interpret. */
            module = _PyOS_optarg;
            break;
        }

        switch (c) {
        case 'b':
            Py_BytesWarningFlag++;
            break;

        case 'd':
            Py_DebugFlag++;
            break;

        case 'i':
            Py_InspectFlag++;
            Py_InteractiveFlag++;
            break;

423 424 425 426 427 428
        case 'I':
            Py_IsolatedFlag++;
            Py_NoUserSiteDirectory++;
            Py_IgnoreEnvironmentFlag++;
            break;

429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
        /* case 'J': reserved for Jython */

        case 'O':
            Py_OptimizeFlag++;
            break;

        case 'B':
            Py_DontWriteBytecodeFlag++;
            break;

        case 's':
            Py_NoUserSiteDirectory++;
            break;

        case 'S':
            Py_NoSiteFlag++;
            break;

        case 'E':
448
            /* Already handled above */
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
            break;

        case 't':
            /* ignored for backwards compatibility */
            break;

        case 'u':
            Py_UnbufferedStdioFlag = 1;
            saw_unbuffered_flag = 1;
            break;

        case 'v':
            Py_VerboseFlag++;
            break;

        case 'x':
            skipfirstline = 1;
            break;

        case 'h':
        case '?':
            help++;
            break;

        case 'V':
            version++;
            break;

        case 'W':
478 479 480 481 482 483 484
            if (warning_options == NULL)
                warning_options = PyList_New(0);
            if (warning_options == NULL)
                Py_FatalError("failure in handling of -W argument");
            warning_option = PyUnicode_FromWideChar(_PyOS_optarg, -1);
            if (warning_option == NULL)
                Py_FatalError("failure in handling of -W argument");
485 486
            if (PyList_Append(warning_options, warning_option) == -1)
                Py_FatalError("failure in handling of -W argument");
487
            Py_DECREF(warning_option);
488 489
            break;

490 491 492 493
        case 'X':
            PySys_AddXOption(_PyOS_optarg);
            break;

494
        case 'q':
495
            Py_QuietFlag++;
496 497
            break;

498
        case 'R':
499
            /* Ignored */
500 501
            break;

502 503 504 505 506 507 508 509
        /* This space reserved for other options */

        default:
            return usage(2, argv[0]);
            /*NOTREACHED*/

        }
    }
510

511 512 513 514
    if (help)
        return usage(0, argv[0]);

    if (version) {
515
        printf("Python %s\n", PY_VERSION);
516 517 518 519 520 521 522 523 524 525 526 527 528
        return 0;
    }

    if (!Py_InspectFlag &&
        (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
        Py_InspectFlag = 1;
    if (!saw_unbuffered_flag &&
        (p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0')
        Py_UnbufferedStdioFlag = 1;

    if (!Py_NoUserSiteDirectory &&
        (p = Py_GETENV("PYTHONNOUSERSITE")) && *p != '\0')
        Py_NoUserSiteDirectory = 1;
529

530
#ifdef MS_WINDOWS
531 532
    if (!Py_IgnoreEnvironmentFlag && (wp = _wgetenv(L"PYTHONWARNINGS")) &&
        *wp != L'\0') {
533
        wchar_t *buf, *warning, *context = NULL;
534

535
        buf = (wchar_t *)PyMem_RawMalloc((wcslen(wp) + 1) * sizeof(wchar_t));
536 537 538 539
        if (buf == NULL)
            Py_FatalError(
               "not enough memory to copy PYTHONWARNINGS");
        wcscpy(buf, wp);
540
        for (warning = wcstok_s(buf, L",", &context);
541
             warning != NULL;
542
             warning = wcstok_s(NULL, L",", &context)) {
543 544
            PySys_AddWarnOption(warning);
        }
545
        PyMem_RawFree(buf);
546
    }
547
#else
548 549
    if ((p = Py_GETENV("PYTHONWARNINGS")) && *p != '\0') {
        char *buf, *oldloc;
550
        PyObject *unicode;
551 552 553

        /* settle for strtok here as there's no one standard
           C89 wcstok */
554
        buf = (char *)PyMem_RawMalloc(strlen(p) + 1);
555 556 557 558
        if (buf == NULL)
            Py_FatalError(
               "not enough memory to copy PYTHONWARNINGS");
        strcpy(buf, p);
559
        oldloc = _PyMem_RawStrdup(setlocale(LC_ALL, NULL));
560 561
        setlocale(LC_ALL, "");
        for (p = strtok(buf, ","); p != NULL; p = strtok(NULL, ",")) {
562 563 564 565
#ifdef __APPLE__
            /* Use utf-8 on Mac OS X */
            unicode = PyUnicode_FromString(p);
#else
566
            unicode = PyUnicode_DecodeLocale(p, "surrogateescape");
567
#endif
568 569 570
            if (unicode == NULL) {
                /* ignore errors */
                PyErr_Clear();
571
                continue;
572
            }
573 574
            PySys_AddWarnOptionUnicode(unicode);
            Py_DECREF(unicode);
575 576
        }
        setlocale(LC_ALL, oldloc);
577
        PyMem_RawFree(oldloc);
578
        PyMem_RawFree(buf);
579
    }
580
#endif
581 582 583 584 585 586
    if (warning_options != NULL) {
        Py_ssize_t i;
        for (i = 0; i < PyList_GET_SIZE(warning_options); i++) {
            PySys_AddWarnOptionUnicode(PyList_GET_ITEM(warning_options, i));
        }
    }
587

588 589 590 591 592
    if (command == NULL && module == NULL && _PyOS_optind < argc &&
        wcscmp(argv[_PyOS_optind], L"-") != 0)
    {
        filename = argv[_PyOS_optind];
    }
593

594
    stdin_is_interactive = Py_FdIsInteractive(stdin, (char *)0);
595

596
#if defined(MS_WINDOWS) || defined(__CYGWIN__)
597 598 599 600
    /* don't translate newlines (\r\n <=> \n) */
    _setmode(fileno(stdin), O_BINARY);
    _setmode(fileno(stdout), O_BINARY);
    _setmode(fileno(stderr), O_BINARY);
601
#endif
602 603

    if (Py_UnbufferedStdioFlag) {
604
#ifdef HAVE_SETVBUF
605 606 607
        setvbuf(stdin,  (char *)NULL, _IONBF, BUFSIZ);
        setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
        setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);
608
#else /* !HAVE_SETVBUF */
609 610 611
        setbuf(stdin,  (char *)NULL);
        setbuf(stdout, (char *)NULL);
        setbuf(stderr, (char *)NULL);
612
#endif /* !HAVE_SETVBUF */
613 614
    }
    else if (Py_InteractiveFlag) {
615
#ifdef MS_WINDOWS
616 617 618
        /* Doesn't have to have line-buffered -- use unbuffered */
        /* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
        setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
619 620
#else /* !MS_WINDOWS */
#ifdef HAVE_SETVBUF
621 622
        setvbuf(stdin,  (char *)NULL, _IOLBF, BUFSIZ);
        setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
623 624
#endif /* HAVE_SETVBUF */
#endif /* !MS_WINDOWS */
625 626
        /* Leave stderr alone - it should be unbuffered anyway. */
    }
Guido van Rossum's avatar
Guido van Rossum committed
627

628
#ifdef __APPLE__
629 630 631 632 633 634 635 636 637 638 639
    /* On MacOS X, when the Python interpreter is embedded in an
       application bundle, it gets executed by a bootstrapping script
       that does os.execve() with an argv[0] that's different from the
       actual Python executable. This is needed to keep the Finder happy,
       or rather, to work around Apple's overly strict requirements of
       the process name. However, we still need a usable sys.executable,
       so the actual executable path is passed in an environment variable.
       See Lib/plat-mac/bundlebuiler.py for details about the bootstrap
       script. */
    if ((p = Py_GETENV("PYTHONEXECUTABLE")) && *p != '\0') {
        wchar_t* buffer;
640
        size_t len = strlen(p) + 1;
641

642
        buffer = PyMem_RawMalloc(len * sizeof(wchar_t));
643 644 645 646 647
        if (buffer == NULL) {
            Py_FatalError(
               "not enough memory to copy PYTHONEXECUTABLE");
        }

648
        mbstowcs(buffer, p, len);
649 650 651
        Py_SetProgramName(buffer);
        /* buffer is now handed off - do not free */
    } else {
652 653 654 655 656 657 658
#ifdef WITH_NEXT_FRAMEWORK
        char* pyvenv_launcher = getenv("__PYVENV_LAUNCHER__");

        if (pyvenv_launcher && *pyvenv_launcher) {
            /* Used by Mac/Tools/pythonw.c to forward
             * the argv0 of the stub executable
             */
659
            wchar_t* wbuf = Py_DecodeLocale(pyvenv_launcher, NULL);
660 661 662 663 664 665 666

            if (wbuf == NULL) {
                Py_FatalError("Cannot decode __PYVENV_LAUNCHER__");
            }
            Py_SetProgramName(wbuf);

            /* Don't free wbuf, the argument to Py_SetProgramName
667
             * must remain valid until Py_FinalizeEx is called.
668 669 670 671 672
             */
        } else {
            Py_SetProgramName(argv[0]);
        }
#else
673
        Py_SetProgramName(argv[0]);
674
#endif
675
    }
676
#else
677
    Py_SetProgramName(argv[0]);
678
#endif
679
    Py_Initialize();
680
    Py_XDECREF(warning_options);
681

682
    if (!Py_QuietFlag && (Py_VerboseFlag ||
683 684
                        (command == NULL && filename == NULL &&
                         module == NULL && stdin_is_interactive))) {
685 686 687 688 689 690 691 692 693 694 695 696 697
        fprintf(stderr, "Python %s on %s\n",
            Py_GetVersion(), Py_GetPlatform());
        if (!Py_NoSiteFlag)
            fprintf(stderr, "%s\n", COPYRIGHT);
    }

    if (command != NULL) {
        /* Backup _PyOS_optind and force sys.argv[0] = '-c' */
        _PyOS_optind--;
        argv[_PyOS_optind] = L"-c";
    }

    if (module != NULL) {
698
        /* Backup _PyOS_optind and force sys.argv[0] = '-m'*/
699
        _PyOS_optind--;
700
        argv[_PyOS_optind] = L"-m";
701 702 703 704 705
    }

    PySys_SetArgv(argc-_PyOS_optind, argv+_PyOS_optind);

    if ((Py_InspectFlag || (command == NULL && filename == NULL && module == NULL)) &&
706 707
        isatty(fileno(stdin)) &&
        !Py_IsolatedFlag) {
708 709 710 711 712 713 714 715 716
        PyObject *v;
        v = PyImport_ImportModule("readline");
        if (v == NULL)
            PyErr_Clear();
        else
            Py_DECREF(v);
    }

    if (command) {
717
        sts = run_command(command, &cf);
718
        PyMem_RawFree(command);
719
    } else if (module) {
720
        sts = (RunModule(module, 1) != 0);
721 722 723 724 725 726
    }
    else {

        if (filename == NULL && stdin_is_interactive) {
            Py_InspectFlag = 0; /* do exit on SystemExit */
            RunStartupFile(&cf);
727
            RunInteractiveHook();
728 729 730 731 732 733 734 735 736 737
        }
        /* XXX */

        sts = -1;               /* keep track of whether we've already run __main__ */

        if (filename != NULL) {
            sts = RunMainFromImporter(filename);
        }

        if (sts==-1 && filename!=NULL) {
738 739 740 741
            fp = _Py_wfopen(filename, L"r");
            if (fp == NULL) {
                char *cfilename_buffer;
                const char *cfilename;
742
                int err = errno;
743
                cfilename_buffer = Py_EncodeLocale(filename, NULL);
744 745 746 747
                if (cfilename_buffer != NULL)
                    cfilename = cfilename_buffer;
                else
                    cfilename = "<unprintable file name>";
748
                fprintf(stderr, "%ls: can't open file '%s': [Errno %d] %s\n",
749
                    argv[0], cfilename, err, strerror(err));
750 751
                if (cfilename_buffer)
                    PyMem_Free(cfilename_buffer);
752 753 754 755 756 757 758 759 760 761 762 763 764 765
                return 2;
            }
            else if (skipfirstline) {
                int ch;
                /* Push back first newline so line numbers
                   remain the same */
                while ((ch = getc(fp)) != EOF) {
                    if (ch == '\n') {
                        (void)ungetc(ch, fp);
                        break;
                    }
                }
            }
            {
766
                struct _Py_stat_struct sb;
767
                if (_Py_fstat_noraise(fileno(fp), &sb) == 0 &&
768
                    S_ISDIR(sb.st_mode)) {
769 770 771
                    fprintf(stderr,
                            "%ls: '%ls' is a directory, cannot continue\n",
                            argv[0], filename);
772 773 774 775 776 777
                    fclose(fp);
                    return 1;
                }
            }
        }

778 779
        if (sts == -1)
            sts = run_file(fp, filename, &cf);
780 781 782 783 784 785 786 787 788 789 790 791 792 793
    }

    /* Check this environment variable at the end, to give programs the
     * opportunity to set it from Python.
     */
    if (!Py_InspectFlag &&
        (p = Py_GETENV("PYTHONINSPECT")) && *p != '\0')
    {
        Py_InspectFlag = 1;
    }

    if (Py_InspectFlag && stdin_is_interactive &&
        (filename != NULL || command != NULL || module != NULL)) {
        Py_InspectFlag = 0;
794
        RunInteractiveHook();
795 796 797 798
        /* XXX */
        sts = PyRun_AnyFileFlags(stdin, "<stdin>", &cf) != 0;
    }

799 800 801 802 803
    if (Py_FinalizeEx() < 0) {
        /* Value unlikely to be confused with a non-error exit status or
        other special meaning */
        sts = 120;
    }
804 805

#ifdef __INSURE__
806 807 808 809 810 811 812 813 814 815
    /* Insure++ is a memory analysis tool that aids in discovering
     * memory leaks and other memory problems.  On Python exit, the
     * interned string dictionaries are flagged as being in use at exit
     * (which it is).  Under normal circumstances, this is fine because
     * the memory will be automatically reclaimed by the system.  Under
     * memory debugging, it's a huge source of useless noise, so we
     * trade off slower shutdown for less distraction in the memory
     * reports.  -baw
     */
    _Py_ReleaseInternedUnicodeStrings();
816 817
#endif /* __INSURE__ */

818
    return sts;
Guido van Rossum's avatar
Guido van Rossum committed
819 820
}

821 822 823
/* this is gonna seem *real weird*, but if you put some other code between
   Py_Main() and Py_GetArgcArgv() you will need to adjust the test in the
   while statement in Misc/gdbinit:ppystack */
Guido van Rossum's avatar
Guido van Rossum committed
824 825 826 827 828

/* Make the *original* argc/argv available to other modules.
   This is rare, but it is needed by the secureware extension. */

void
829
Py_GetArgcArgv(int *argc, wchar_t ***argv)
Guido van Rossum's avatar
Guido van Rossum committed
830
{
831 832
    *argc = orig_argc;
    *argv = orig_argv;
Guido van Rossum's avatar
Guido van Rossum committed
833
}
834 835 836 837

#ifdef __cplusplus
}
#endif