#include "Python.h"

#include "osdefs.h"

#include "internal/import.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())

#define SET_DECODE_ERROR(NAME, LEN) \

do { \

if ((LEN) == (size_t)-2) { \

pymain->err = _Py_INIT_USER_ERR("cannot decode " NAME); \

} \

else { \

pymain->err = _Py_INIT_NO_MEMORY(); \

} \

} while (0)

#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[] =

"PYTHONDEVMODE: enable the development mode.\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 const char*

config_get_env_var(const char *name)

{

const char *var = Py_GETENV(name);

if (var && var[0] != '\0') {

return var;

}

else {

return NULL;

}

}

static int

config_get_env_var_dup(wchar_t **dest, wchar_t *wname, char *name)

{

if (Py_IgnoreEnvironmentFlag) {

*dest = NULL;

return 0;

}

#ifdef MS_WINDOWS

const wchar_t *var = _wgetenv(wname);

if (!var || var[0] == '\0') {

*dest = NULL;

return 0;

}

wchar_t *copy = _PyMem_RawWcsdup(var);

if (copy == NULL) {

return -1;

}

*dest = copy;

const char *var = getenv(name);

if (!var || var[0] == '\0') {

*dest = NULL;

return 0;

}

size_t len;

wchar_t *wvar = Py_DecodeLocale(var, &len);

if (!wvar) {

if (len == (size_t)-2) {

return -2;

}

else {

return -1;

}

}

*dest = wvar;

return 0;

}

static void

pymain_run_startup(PyCompilerFlags *cf)

{

const char *startup = config_get_env_var("PYTHONSTARTUP");

if (startup == NULL) {

return;

}

FILE *fp = _Py_fopen(startup, "r");

if (fp == NULL) {

int save_errno = errno;

PySys_WriteStderr("Could not open PYTHONSTARTUP\n");

errno = save_errno;

PyErr_SetFromErrnoWithFilename(PyExc_OSError,

startup);

PyErr_Print();

PyErr_Clear();

return;

}

(void) PyRun_SimpleFileExFlags(fp, startup, 0, cf);

PyErr_Clear();

fclose(fp);

}

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

PyErr_Clear();

}

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

PyErr_Clear();

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;

}

static int

pymain_run_file(FILE *fp, const wchar_t *filename, PyCompilerFlags *p_cf)

{

PyObject *unicode, *bytes = NULL;

const 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) {

bytes = PyUnicode_EncodeFSDefault(unicode);

Py_DECREF(unicode);

}

if (bytes != NULL) {

filename_str = PyBytes_AsString(bytes);

}

else {

PyErr_Clear();

filename_str = "<encoding error>";

}

}

else {

filename_str = "<stdin>";

}

run = PyRun_AnyFileExFlags(fp, filename_str, filename != NULL, p_cf);

Py_XDECREF(bytes);

return run != 0;

}

typedef struct {

wchar_t **argv;

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

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

int nenv_warnoption; /* Number of PYTHONWARNINGS options */

wchar_t **env_warnoptions; /* PYTHONWARNINGS options */

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

int print_version; /* -V option */

int bytes_warning; /* Py_BytesWarningFlag, -b */

int debug; /* Py_DebugFlag, -b, PYTHONDEBUG */

int inspect; /* Py_InspectFlag, -i, PYTHONINSPECT */

int interactive; /* Py_InteractiveFlag, -i */

int isolated; /* Py_IsolatedFlag, -I */

int optimization_level; /* Py_OptimizeFlag, -O, PYTHONOPTIMIZE */

int dont_write_bytecode; /* Py_DontWriteBytecodeFlag, -B, PYTHONDONTWRITEBYTECODE */

int no_user_site_directory; /* Py_NoUserSiteDirectory, -I, -s, PYTHONNOUSERSITE */

int no_site_import; /* Py_NoSiteFlag, -S */

int use_unbuffered_io; /* Py_UnbufferedStdioFlag, -u, PYTHONUNBUFFERED */

int verbosity; /* Py_VerboseFlag, -v, PYTHONVERBOSE */

int quiet_flag; /* Py_QuietFlag, -q */

const char *check_hash_pycs_mode; /* --check-hash-based-pycs */

#ifdef MS_WINDOWS

int legacy_windows_fs_encoding; /* Py_LegacyWindowsFSEncodingFlag,

int legacy_windows_stdio; /* Py_LegacyWindowsStdioFlag,

} _Py_CommandLineDetails;

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 */

_PyCoreConfig config;

PyObject *main_importer_path;

} _PyMain;

#define _PyMain_INIT \

{.config = _PyCoreConfig_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 void

clear_wstrlist(int len, wchar_t **list)

{

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

PyMem_RawFree(list[i]);

}

PyMem_RawFree(list);

}

static int

pymain_init_cmdline_argv(_PyMain *pymain, _Py_CommandLineDetails *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) {

clear_wstrlist(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"";

}

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

if (pymain->config.program == NULL) {

return -1;

}

return 0;

}

static void

pymain_clear_cmdline(_PyMain *pymain, _Py_CommandLineDetails *cmdline)

{

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

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

cmdline->nwarnoption = 0;

cmdline->warnoptions = NULL;

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

cmdline->nenv_warnoption = 0;

cmdline->env_warnoptions = NULL;

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

clear_wstrlist(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(_PyMain *pymain)

{

/* Clear core config with the memory allocator

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

_PyCoreConfig_Clear(&pymain->config);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

static void

pymain_free_python(_PyMain *pymain)

{

Py_CLEAR(pymain->main_importer_path);

#ifdef __INSURE__

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

_Py_ReleaseInternedUnicodeStrings();

#endif /* __INSURE__ */

}

static void

pymain_free_raw(_PyMain *pymain)

{

_PyImport_Fini2();

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

_PyPathConfig_Clear(&_Py_path_config);

pymain_clear_config(pymain);

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

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

pymain_clear_pymain(pymain);

clear_wstrlist(orig_argc, orig_argv);

orig_argc = 0;

orig_argv = NULL;

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

static void

pymain_free(_PyMain *pymain)

{

pymain_free_python(pymain);

pymain_free_raw(pymain);

}

static int

pymain_run_main_from_importer(_PyMain *pymain)

{

/* Assume sys_path0 has already been checked by pymain_get_importer(),

PyObject *sys_path = PySys_GetObject("path");

if (sys_path == NULL) {

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

goto error;

}

if (PyList_Insert(sys_path, 0, pymain->main_importer_path)) {

goto error;

}

int sts = pymain_run_module(L"__main__", 0);

return (sts != 0);

error:

Py_CLEAR(pymain->main_importer_path);

PyErr_Print();

return 1;

}

static _PyInitError

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

{

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 = 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, _Py_CommandLineDetails *cmdline)

{

_PyCoreConfig *config = &pymain->config;

_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")) {

cmdline->check_hash_pycs_mode = "always";

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

cmdline->check_hash_pycs_mode = "never";

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

cmdline->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':

cmdline->bytes_warning++;

break;

case 'd':

cmdline->debug++;

break;

case 'i':

cmdline->inspect++;

cmdline->interactive++;

break;

case 'I':

config->ignore_environment++;

cmdline->isolated++;

cmdline->no_user_site_directory++;

break;

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

case 'O':

cmdline->optimization_level++;

break;

case 'B':

cmdline->dont_write_bytecode++;

break;

case 's':

cmdline->no_user_site_directory++;

break;

case 'S':

cmdline->no_site_import++;

break;

case 'E':

config->ignore_environment++;

break;

case 't':

/* ignored for backwards compatibility */

break;

case 'u':

cmdline->use_unbuffered_io = 1;

break;

case 'v':

cmdline->verbosity++;

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

cmdline->quiet_flag++;

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 = 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, _Py_CommandLineDetails *cmdline)

{

_PyInitError err;

assert(config->nwarnoption == 0);

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