#include "Python.h"

#include "osdefs.h"

#include "internal/pygetopt.h"

#include "internal/pystate.h"

#include <locale.h>

#if defined(MS_WINDOWS) || defined(__CYGWIN__)

# include <windows.h>

# ifdef HAVE_IO_H

# include <io.h>

# ifdef HAVE_FCNTL_H

# include <fcntl.h>

#ifdef _MSC_VER

# include <crtdbg.h>

#ifdef __FreeBSD__

# include <fenv.h>

#if defined(MS_WINDOWS)

# define PYTHONHOMEHELP "<prefix>\\python{major}{minor}"

# define PYTHONHOMEHELP "<prefix>/lib/pythonX.X"

#define COPYRIGHT \

"Type \"help\", \"copyright\", \"credits\" or \"license\" " \

"for more information."

#ifdef __cplusplus

extern "C" {

#define DECODE_LOCALE_ERR(NAME, LEN) \

(((LEN) == -2) \

? _Py_INIT_USER_ERR("cannot decode " NAME) \

: _Py_INIT_NO_MEMORY())

#ifdef MS_WINDOWS

#define WCSTOK wcstok_s

#define WCSTOK wcstok

static wchar_t **orig_argv = NULL;

static int orig_argc = 0;

#define BASE_OPTS L"bBc:dEhiIJm:OqRsStuvVW:xX:?"

#define PROGRAM_OPTS BASE_OPTS

static const _PyOS_LongOption longoptions[] = {

{L"check-hash-based-pycs", 1, 0},

{NULL, 0, 0},

};

static const char usage_line[] =

"usage: %ls [option] ... [-c cmd | -m mod | file | -] [arg] ...\n";

static const char usage_1[] = "\

";

static const char usage_2[] = "\

";

static const char usage_3[] = "\

";

static const char usage_4[] = "\

";

static const char usage_5[] =

"PYTHONFAULTHANDLER: dump the Python traceback on fatal errors.\n";

static const char usage_6[] =

"PYTHONPYCACHEPREFIX: root directory for bytecode cache (pyc) files.\n";

static void

pymain_usage(int error, const wchar_t* program)

{

FILE *f = error ? stderr : stdout;

fprintf(f, usage_line, program);

if (error)

fprintf(f, "Try `python -h' for more information.\n");

else {

fputs(usage_1, f);

fputs(usage_2, f);

fputs(usage_3, f);

fprintf(f, usage_4, (wint_t)DELIM);

fprintf(f, usage_5, (wint_t)DELIM, PYTHONHOMEHELP);

fputs(usage_6, f);

}

}

static void

pymain_run_interactive_hook(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();

return;

}

result = _PyObject_CallNoArg(hook);

Py_DECREF(hook);

if (result == NULL) {

goto error;

}

Py_DECREF(result);

return;

error:

PySys_WriteStderr("Failed calling sys.__interactivehook__\n");

PyErr_Print();

}

static int

pymain_run_module(const wchar_t *modname, int set_argv0)

{

PyObject *module, *runpy, *runmodule, *runargs, *result;

runpy = PyImport_ImportModule("runpy");

if (runpy == NULL) {

fprintf(stderr, "Could not import runpy module\n");

PyErr_Print();

return -1;

}

runmodule = PyObject_GetAttrString(runpy, "_run_module_as_main");

if (runmodule == NULL) {

fprintf(stderr, "Could not access runpy._run_module_as_main\n");

PyErr_Print();

Py_DECREF(runpy);

return -1;

}

module = PyUnicode_FromWideChar(modname, wcslen(modname));

if (module == NULL) {

fprintf(stderr, "Could not convert module name to unicode\n");

PyErr_Print();

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");

PyErr_Print();

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;

}

static PyObject *

pymain_get_importer(const wchar_t *filename)

{

PyObject *sys_path0 = NULL, *importer;

sys_path0 = PyUnicode_FromWideChar(filename, wcslen(filename));

if (sys_path0 == NULL) {

goto error;

}

importer = PyImport_GetImporter(sys_path0);

if (importer == NULL) {

goto error;

}

if (importer == Py_None) {

Py_DECREF(sys_path0);

Py_DECREF(importer);

return NULL;

}

Py_DECREF(importer);

return sys_path0;

error:

Py_XDECREF(sys_path0);

PySys_WriteStderr("Failed checking if argv[0] is an import path entry\n");

PyErr_Print();

return NULL;

}

static int

pymain_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:

PySys_WriteStderr("Unable to decode the command from the command line:\n");

PyErr_Print();

return 1;

}

typedef struct {

wchar_t **argv;

int nwarnoption; /* Number of -W command line options */

wchar_t **warnoptions; /* Command line -W options */

int nenv_warnoption; /* Number of PYTHONWARNINGS environment variables */

wchar_t **env_warnoptions; /* PYTHONWARNINGS environment variables */

int print_help; /* -h, -? options */

int print_version; /* -V option */

} _PyCmdline;

typedef struct {

/* Input arguments */

int argc;

int use_bytes_argv;

char **bytes_argv;

wchar_t **wchar_argv;

/* Exit status or "exit code": result of pymain_main() */

int status;

/* Error message if a function failed */

_PyInitError err;

/* non-zero is stdin is a TTY or if -i option is used */

int stdin_is_interactive;

int skip_first_line; /* -x option */

wchar_t *filename; /* Trailing arg without -c or -m */

wchar_t *command; /* -c argument */

wchar_t *module; /* -m argument */

} _PyMain;

#define _PyMain_INIT {.err = _Py_INIT_OK()}

#define RUN_CODE(pymain) \

(pymain->command != NULL || pymain->filename != NULL \

|| pymain->module != NULL)

static wchar_t*

pymain_wstrdup(_PyMain *pymain, const wchar_t *str)

{

wchar_t *str2 = _PyMem_RawWcsdup(str);

if (str2 == NULL) {

pymain->err = _Py_INIT_NO_MEMORY();

return NULL;

}

return str2;

}

static int

pymain_init_cmdline_argv(_PyMain *pymain, _PyCoreConfig *config,

_PyCmdline *cmdline)

{

assert(cmdline->argv == NULL);

if (pymain->use_bytes_argv) {

/* +1 for a the NULL terminator */

size_t size = sizeof(wchar_t*) * (pymain->argc + 1);

wchar_t** argv = (wchar_t **)PyMem_RawMalloc(size);

if (argv == NULL) {

pymain->err = _Py_INIT_NO_MEMORY();

return -1;

}

for (int i = 0; i < pymain->argc; i++) {

size_t len;

wchar_t *arg = Py_DecodeLocale(pymain->bytes_argv[i], &len);

if (arg == NULL) {

_Py_wstrlist_clear(i, argv);

pymain->err = DECODE_LOCALE_ERR("command line arguments",

(Py_ssize_t)len);

return -1;

}

argv[i] = arg;

}

argv[pymain->argc] = NULL;

cmdline->argv = argv;

}

else {

cmdline->argv = pymain->wchar_argv;

}

wchar_t *program;

if (pymain->argc >= 1 && cmdline->argv != NULL) {

program = cmdline->argv[0];

}

else {

program = L"";

}

config->program = pymain_wstrdup(pymain, program);

if (config->program == NULL) {

return -1;

}

return 0;

}

static void

pymain_clear_cmdline(_PyMain *pymain, _PyCmdline *cmdline)

{

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

_Py_wstrlist_clear(cmdline->nwarnoption, cmdline->warnoptions);

cmdline->nwarnoption = 0;

cmdline->warnoptions = NULL;

_Py_wstrlist_clear(cmdline->nenv_warnoption, cmdline->env_warnoptions);

cmdline->nenv_warnoption = 0;

cmdline->env_warnoptions = NULL;

if (pymain->use_bytes_argv && cmdline->argv != NULL) {

_Py_wstrlist_clear(pymain->argc, cmdline->argv);

}

cmdline->argv = NULL;

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

static void

pymain_clear_pymain(_PyMain *pymain)

{

#define CLEAR(ATTR) \

do { \

PyMem_RawFree(ATTR); \

ATTR = NULL; \

} while (0)

CLEAR(pymain->filename);

CLEAR(pymain->command);

CLEAR(pymain->module);

#undef CLEAR

}

static void

pymain_clear_config(_PyCoreConfig *config)

{

/* Clear core config with the memory allocator

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

_PyCoreConfig_Clear(config);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

static void

pymain_free(_PyMain *pymain)

{

_PyImport_Fini2();

/* Free global variables which cannot be freed in Py_Finalize():

_PyPathConfig_ClearGlobal();

_Py_ClearStandardStreamEncoding();

/* Force the allocator used by pymain_read_conf() */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

pymain_clear_pymain(pymain);

_Py_wstrlist_clear(orig_argc, orig_argv);

orig_argc = 0;

orig_argv = NULL;

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

#ifdef __INSURE__

/* Insure++ is a memory analysis tool that aids in discovering

_Py_ReleaseInternedUnicodeStrings();

#endif /* __INSURE__ */

}

static int

pymain_sys_path_add_path0(PyInterpreterState *interp, PyObject *path0)

{

PyObject *sys_path;

PyObject *sysdict = interp->sysdict;

if (sysdict != NULL) {

sys_path = PyDict_GetItemRefString(sysdict, "path");

}

else {

sys_path = NULL;

}

if (sys_path == NULL) {

PyErr_SetString(PyExc_RuntimeError, "unable to get sys.path");

goto error;

}

if (PyList_Insert(sys_path, 0, path0)) {

Py_DECREF(sys_path);

goto error;

}

Py_DECREF(sys_path);

return 0;

error:

PyErr_Print();

return -1;

}

_Py_wstrlist_append(int *len, wchar_t ***list, const wchar_t *str)

{

if (*len == INT_MAX) {

/* len+1 would overflow */

return _Py_INIT_NO_MEMORY();

}

wchar_t *str2 = _PyMem_RawWcsdup(str);

if (str2 == NULL) {

return _Py_INIT_NO_MEMORY();

}

size_t size = (*len + 1) * sizeof(list[0]);

wchar_t **list2 = (wchar_t **)PyMem_RawRealloc(*list, size);

if (list2 == NULL) {

PyMem_RawFree(str2);

return _Py_INIT_NO_MEMORY();

}

list2[*len] = str2;

*list = list2;

(*len)++;

return _Py_INIT_OK();

}

static int

pymain_wstrlist_append(_PyMain *pymain, int *len, wchar_t ***list, const wchar_t *str)

{

_PyInitError err = _Py_wstrlist_append(len, list, str);

if (_Py_INIT_FAILED(err)) {

pymain->err = err;

return -1;

}

return 0;

}

static int

pymain_parse_cmdline_impl(_PyMain *pymain, _PyCoreConfig *config,

_PyCmdline *cmdline)

{

_PyOS_ResetGetOpt();

do {

int longindex = -1;

int c = _PyOS_GetOpt(pymain->argc, cmdline->argv, PROGRAM_OPTS,

longoptions, &longindex);

if (c == EOF) {

break;

}

if (c == 'c') {

/* -c is the last option; following arguments

size_t len = wcslen(_PyOS_optarg) + 1 + 1;

wchar_t *command = PyMem_RawMalloc(sizeof(wchar_t) * len);

if (command == NULL) {

pymain->err = _Py_INIT_NO_MEMORY();

return -1;

}

memcpy(command, _PyOS_optarg, (len - 2) * sizeof(wchar_t));

command[len - 2] = '\n';

command[len - 1] = 0;

pymain->command = command;

break;

}

if (c == 'm') {

/* -m is the last option; following arguments

pymain->module = pymain_wstrdup(pymain, _PyOS_optarg);

if (pymain->module == NULL) {

return -1;

}

break;

}

switch (c) {

case 0:

// Handle long option.

assert(longindex == 0); // Only one long option now.

if (!wcscmp(_PyOS_optarg, L"always")) {

config->_check_hash_pycs_mode = "always";

} else if (!wcscmp(_PyOS_optarg, L"never")) {

config->_check_hash_pycs_mode = "never";

} else if (!wcscmp(_PyOS_optarg, L"default")) {

config->_check_hash_pycs_mode = "default";

} else {

fprintf(stderr, "--check-hash-based-pycs must be one of "

"'default', 'always', or 'never'\n");

return 1;

}

break;

case 'b':

config->bytes_warning++;

break;

case 'd':

config->parser_debug++;

break;

case 'i':

config->inspect++;

config->interactive++;

break;

case 'I':

config->isolated++;

break;

/* case 'J': reserved for Jython */

case 'O':

config->optimization_level++;

break;

case 'B':

config->write_bytecode = 0;

break;

case 's':

config->user_site_directory = 0;

break;

case 'S':

config->site_import = 0;

break;

case 'E':

config->use_environment = 0;

break;

case 't':

/* ignored for backwards compatibility */

break;

case 'u':

config->buffered_stdio = 0;

break;

case 'v':

config->verbose++;

break;

case 'x':

pymain->skip_first_line = 1;

break;

case 'h':

case '?':

cmdline->print_help++;

break;

case 'V':

cmdline->print_version++;

break;

case 'W':

if (pymain_wstrlist_append(pymain,

&cmdline->nwarnoption,

&cmdline->warnoptions,

_PyOS_optarg) < 0) {

return -1;

}

break;

case 'X':

if (pymain_wstrlist_append(pymain,

&config->nxoption,

&config->xoptions,

_PyOS_optarg) < 0) {

return -1;

}

break;

case 'q':

config->quiet++;

break;

case 'R':

config->use_hash_seed = 0;

break;

/* This space reserved for other options */

default:

/* unknown argument: parsing failed */

return 1;

}

} while (1);

if (pymain->command == NULL && pymain->module == NULL

&& _PyOS_optind < pymain->argc

&& wcscmp(cmdline->argv[_PyOS_optind], L"-") != 0)

{

pymain->filename = pymain_wstrdup(pymain, cmdline->argv[_PyOS_optind]);

if (pymain->filename == NULL) {

return -1;

}

}

/* -c and -m options are exclusive */

assert(!(pymain->command != NULL && pymain->module != NULL));

return 0;

}

static int

add_xoption(PyObject *opts, const wchar_t *s)

{

PyObject *name, *value;

const wchar_t *name_end = wcschr(s, L'=');

if (!name_end) {

name = PyUnicode_FromWideChar(s, -1);

value = Py_True;

Py_INCREF(value);

}

else {

name = PyUnicode_FromWideChar(s, name_end - s);

value = PyUnicode_FromWideChar(name_end + 1, -1);

}

if (name == NULL || value == NULL) {

goto error;

}

if (PyDict_SetItem(opts, name, value) < 0) {

goto error;

}

Py_DECREF(name);

Py_DECREF(value);

return 0;

error:

Py_XDECREF(name);

Py_XDECREF(value);

return -1;

}

static PyObject*

config_create_xoptions_dict(const _PyCoreConfig *config)

{

int nxoption = config->nxoption;

wchar_t **xoptions = config->xoptions;

PyObject *dict = PyDict_New();

if (dict == NULL) {

return NULL;

}

for (int i=0; i < nxoption; i++) {

wchar_t *option = xoptions[i];

if (add_xoption(dict, option) < 0) {

Py_DECREF(dict);

return NULL;

}

}

return dict;

}

static _PyInitError

config_add_warnings_optlist(_PyCoreConfig *config, int len, wchar_t **options)

{

for (int i = 0; i < len; i++) {

_PyInitError err = _Py_wstrlist_append(&config->nwarnoption,

&config->warnoptions,

options[i]);

if (_Py_INIT_FAILED(err)) {

return err;

}

}

return _Py_INIT_OK();

}

static _PyInitError

config_init_warnoptions(_PyCoreConfig *config, _PyCmdline *cmdline)

{

_PyInitError err;

assert(config->nwarnoption == 0);

/* The priority order for warnings configuration is (highest precedence

if (config->dev_mode) {

err = _Py_wstrlist_append(&config->nwarnoption,

&config->warnoptions,

L"default");

if (_Py_INIT_FAILED(err)) {

return err;

}

}

err = config_add_warnings_optlist(config,

cmdline->nenv_warnoption,

cmdline->env_warnoptions);

if (_Py_INIT_FAILED(err)) {

return err;

}

err = config_add_warnings_optlist(config,

cmdline->nwarnoption,

cmdline->warnoptions);

if (_Py_INIT_FAILED(err)) {

return err;

}

/* If the bytes_warning_flag isn't set, bytesobject.c and bytearrayobject.c

if (config->bytes_warning) {

wchar_t *filter;

if (config->bytes_warning> 1) {

filter = L"error::BytesWarning";

}

else {

filter = L"default::BytesWarning";

}

err = _Py_wstrlist_append(&config->nwarnoption,

&config->warnoptions,

filter);

if (_Py_INIT_FAILED(err)) {

return err;

}

}

return _Py_INIT_OK();

}

static _PyInitError

cmdline_init_env_warnoptions(_PyMain *pymain, const _PyCoreConfig *config,

_PyCmdline *cmdline)

{

wchar_t *env;

int res = _PyCoreConfig_GetEnvDup(config, &env,

L"PYTHONWARNINGS", "PYTHONWARNINGS");

if (res < 0) {

return DECODE_LOCALE_ERR("PYTHONWARNINGS", res);

}

if (env == NULL) {

return _Py_INIT_OK();

}

wchar_t *warning, *context = NULL;

for (warning = WCSTOK(env, L",", &context);

warning != NULL;

warning = WCSTOK(NULL, L",", &context))

{

_PyInitError err = _Py_wstrlist_append(&cmdline->nenv_warnoption,

&cmdline->env_warnoptions,

warning);

if (_Py_INIT_FAILED(err)) {

PyMem_RawFree(env);

return err;

}

}

PyMem_RawFree(env);

return _Py_INIT_OK();

}

static void

pymain_init_stdio(_PyMain *pymain, _PyCoreConfig *config)

{

pymain->stdin_is_interactive = (isatty(fileno(stdin))

|| config->interactive);

#if defined(MS_WINDOWS) || defined(__CYGWIN__)

/* don't translate newlines (\r\n <=> \n) */

_setmode(fileno(stdin), O_BINARY);

_setmode(fileno(stdout), O_BINARY);

_setmode(fileno(stderr), O_BINARY);

if (!config->buffered_stdio) {

#ifdef HAVE_SETVBUF

setvbuf(stdin, (char *)NULL, _IONBF, BUFSIZ);

setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);

setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);

#else /* !HAVE_SETVBUF */

setbuf(stdin, (char *)NULL);

setbuf(stdout, (char *)NULL);

setbuf(stderr, (char *)NULL);

#endif /* !HAVE_SETVBUF */

}

else if (config->interactive) {

#ifdef MS_WINDOWS

/* Doesn't have to have line-buffered -- use unbuffered */

/* Any set[v]buf(stdin, ...) screws up Tkinter :-( */

setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);

#else /* !MS_WINDOWS */

#ifdef HAVE_SETVBUF

setvbuf(stdin, (char *)NULL, _IOLBF, BUFSIZ);

setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);

#endif /* HAVE_SETVBUF */

#endif /* !MS_WINDOWS */

/* Leave stderr alone - it should be unbuffered anyway. */

}

}

static void

pymain_header(_PyMain *pymain, const _PyCoreConfig *config)

{

if (config->quiet) {

return;

}

if (!config->verbose && (RUN_CODE(pymain) || !pymain->stdin_is_interactive)) {

return;

}

fprintf(stderr, "Python %s on %s\n", Py_GetVersion(), Py_GetPlatform());

if (config->site_import) {

fprintf(stderr, "%s\n", COPYRIGHT);

}

}

static int

pymain_init_core_argv(_PyMain *pymain, _PyCoreConfig *config, _PyCmdline *cmdline)

{

/* Copy argv to be able to modify it (to force -c/-m) */

int argc = pymain->argc - _PyOS_optind;

wchar_t **argv;

if (argc <= 0 || cmdline->argv == NULL) {

/* Ensure at least one (empty) argument is seen */

static wchar_t *empty_argv[1] = {L""};

argc = 1;

argv = _Py_wstrlist_copy(1, empty_argv);

}

else {

argv = _Py_wstrlist_copy(argc, &cmdline->argv[_PyOS_optind]);

}

if (argv == NULL) {

pymain->err = _Py_INIT_NO_MEMORY();

return -1;

}

wchar_t *arg0 = NULL;

if (pymain->command != NULL) {

/* Force sys.argv[0] = '-c' */

arg0 = L"-c";

}

else if (pymain->module != NULL) {