#include "Python.h"

#include "pycore_fileutils.h" // _Py_HasFileSystemDefaultEncodeErrors

#include "pycore_getopt.h" // _PyOS_GetOpt()

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_interp.h" // _PyInterpreterState.runtime

#include "pycore_pathconfig.h" // _Py_path_config

#include "pycore_pyerrors.h" // _PyErr_Fetch()

#include "pycore_pylifecycle.h" // _Py_PreInitializeFromConfig()

#include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "osdefs.h" // DELIM

#include <locale.h> // setlocale()

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

# ifdef HAVE_IO_H

# include <io.h>

# endif

# ifdef HAVE_FCNTL_H

# include <fcntl.h> // O_BINARY

# endif

#endif

#ifndef PLATLIBDIR

# error "PLATLIBDIR macro must be defined"

#endif

/* --- Command line options --------------------------------------- */

/* Short usage message (with %s for argv0) */

static const char usage_line[] =

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

/* Long usage message, split into parts < 512 bytes */

static const char usage_1[] = "\

Options and arguments (and corresponding environment variables):\n\

-b : issue warnings about str(bytes_instance), str(bytearray_instance)\n\

and comparing bytes/bytearray with str. (-bb: issue errors)\n\

-B : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x\n\

-c cmd : program passed in as string (terminates option list)\n\

-d : debug output from parser; also PYTHONDEBUG=x\n\

-E : ignore PYTHON* environment variables (such as PYTHONPATH)\n\

-h : print this help message and exit (also --help)\n\

";

static const char usage_2[] = "\

-i : inspect interactively after running script; forces a prompt even\n\

if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\

-I : isolate Python from the user's environment (implies -E and -s)\n\

-m mod : run library module as a script (terminates option list)\n\

-O : remove assert and __debug__-dependent statements; add .opt-1 before\n\

.pyc extension; also PYTHONOPTIMIZE=x\n\

-OO : do -O changes and also discard docstrings; add .opt-2 before\n\

.pyc extension\n\

-q : don't print version and copyright messages on interactive startup\n\

-s : don't add user site directory to sys.path; also PYTHONNOUSERSITE\n\

-S : don't imply 'import site' on initialization\n\

";

static const char usage_3[] = "\

-u : force the stdout and stderr streams to be unbuffered;\n\

this option has no effect on stdin; also PYTHONUNBUFFERED=x\n\

-v : verbose (trace import statements); also PYTHONVERBOSE=x\n\

can be supplied multiple times to increase verbosity\n\

-V : print the Python version number and exit (also --version)\n\

when given twice, print more information about the build\n\

-W arg : warning control; arg is action:message:category:module:lineno\n\

also PYTHONWARNINGS=arg\n\

-x : skip first line of source, allowing use of non-Unix forms of #!cmd\n\

-X opt : set implementation-specific option. The following options are available:\n\

\n\

-X faulthandler: enable faulthandler\n\

-X showrefcount: output the total reference count and number of used\n\

memory blocks when the program finishes or after each statement in the\n\

interactive interpreter. This only works on debug builds\n\

-X tracemalloc: start tracing Python memory allocations using the\n\

tracemalloc module. By default, only the most recent frame is stored in a\n\

traceback of a trace. Use -X tracemalloc=NFRAME to start tracing with a\n\

traceback limit of NFRAME frames\n\

-X importtime: show how long each import takes. It shows module name,\n\

cumulative time (including nested imports) and self time (excluding\n\

nested imports). Note that its output may be broken in multi-threaded\n\

application. Typical usage is python3 -X importtime -c 'import asyncio'\n\

-X dev: enable CPython's \"development mode\", introducing additional runtime\n\

checks which are too expensive to be enabled by default. Effect of the\n\

developer mode:\n\

* Add default warning filter, as -W default\n\

* Install debug hooks on memory allocators: see the PyMem_SetupDebugHooks() C function\n\

* Enable the faulthandler module to dump the Python traceback on a crash\n\

* Enable asyncio debug mode\n\

* Set the dev_mode attribute of sys.flags to True\n\

* io.IOBase destructor logs close() exceptions\n\

-X utf8: enable UTF-8 mode for operating system interfaces, overriding the default\n\

locale-aware mode. -X utf8=0 explicitly disables UTF-8 mode (even when it would\n\

otherwise activate automatically)\n\

-X pycache_prefix=PATH: enable writing .pyc files to a parallel tree rooted at the\n\

given directory instead of to the code tree\n\

\n\

--check-hash-based-pycs always|default|never:\n\

control how Python invalidates hash-based .pyc files\n\

";

static const char usage_4[] = "\

file : program read from script file\n\

- : program read from stdin (default; interactive mode if a tty)\n\

arg ...: arguments passed to program in sys.argv[1:]\n\n\

Other environment variables:\n\

PYTHONSTARTUP: file executed on interactive startup (no default)\n\

PYTHONPATH : '%lc'-separated list of directories prefixed to the\n\

default module search path. The result is sys.path.\n\

";

static const char usage_5[] =

"PYTHONHOME : alternate <prefix> directory (or <prefix>%lc<exec_prefix>).\n"

" The default module search path uses %s.\n"

"PYTHONPLATLIBDIR : override sys.platlibdir.\n"

"PYTHONCASEOK : ignore case in 'import' statements (Windows).\n"

"PYTHONUTF8: if set to 1, enable the UTF-8 mode.\n"

"PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.\n"

"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 and bytes objects. It can also be set to an\n"

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

"PYTHONCOERCECLOCALE: if this variable is set to 0, it disables the locale\n"

" coercion behavior. Use PYTHONCOERCECLOCALE=warn to request display of\n"

" locale coercion and locale compatibility warnings on stderr.\n"

"PYTHONBREAKPOINT: if this variable is set to 0, it disables the default\n"

" debugger. It can be set to the callable of your debugger of choice.\n"

"PYTHONDEVMODE: enable the development mode.\n"

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

#if defined(MS_WINDOWS)

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

#else

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

#endif

/* --- Global configuration variables ----------------------------- */

/* UTF-8 mode (PEP 540): if equals to 1, use the UTF-8 encoding, and change

stdin and stdout error handler to "surrogateescape". */

int Py_UTF8Mode = 0;

int Py_DebugFlag = 0; /* Needed by parser.c */

int Py_VerboseFlag = 0; /* Needed by import.c */

int Py_QuietFlag = 0; /* Needed by sysmodule.c */

int Py_InteractiveFlag = 0; /* Needed by Py_FdIsInteractive() below */

int Py_InspectFlag = 0; /* Needed to determine whether to exit at SystemExit */

int Py_OptimizeFlag = 0; /* Needed by compile.c */

int Py_NoSiteFlag = 0; /* Suppress 'import site' */

int Py_BytesWarningFlag = 0; /* Warn on str(bytes) and str(buffer) */

int Py_FrozenFlag = 0; /* Needed by getpath.c */

int Py_IgnoreEnvironmentFlag = 0; /* e.g. PYTHONPATH, PYTHONHOME */

int Py_DontWriteBytecodeFlag = 0; /* Suppress writing bytecode files (*.pyc) */

int Py_NoUserSiteDirectory = 0; /* for -s and site.py */

int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */

int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */

int Py_IsolatedFlag = 0; /* for -I, isolate from user's env */

#ifdef MS_WINDOWS

int Py_LegacyWindowsFSEncodingFlag = 0; /* Uses mbcs instead of utf-8 */

int Py_LegacyWindowsStdioFlag = 0; /* Uses FileIO instead of WindowsConsoleIO */

#endif

static PyObject *

_Py_GetGlobalVariablesAsDict(void)

{

PyObject *dict, *obj;

dict = PyDict_New();

if (dict == NULL) {

return NULL;

}

#define SET_ITEM(KEY, EXPR) \

do { \

obj = (EXPR); \

if (obj == NULL) { \

return NULL; \

} \

int res = PyDict_SetItemString(dict, (KEY), obj); \

Py_DECREF(obj); \

if (res < 0) { \

goto fail; \

} \

} while (0)

#define SET_ITEM_INT(VAR) \

SET_ITEM(#VAR, PyLong_FromLong(VAR))

#define FROM_STRING(STR) \

((STR != NULL) ? \

PyUnicode_FromString(STR) \

: (Py_INCREF(Py_None), Py_None))

#define SET_ITEM_STR(VAR) \

SET_ITEM(#VAR, FROM_STRING(VAR))

SET_ITEM_STR(Py_FileSystemDefaultEncoding);

SET_ITEM_INT(Py_HasFileSystemDefaultEncoding);

SET_ITEM_STR(Py_FileSystemDefaultEncodeErrors);

SET_ITEM_INT(_Py_HasFileSystemDefaultEncodeErrors);

SET_ITEM_INT(Py_UTF8Mode);

SET_ITEM_INT(Py_DebugFlag);

SET_ITEM_INT(Py_VerboseFlag);

SET_ITEM_INT(Py_QuietFlag);

SET_ITEM_INT(Py_InteractiveFlag);

SET_ITEM_INT(Py_InspectFlag);

SET_ITEM_INT(Py_OptimizeFlag);

SET_ITEM_INT(Py_NoSiteFlag);

SET_ITEM_INT(Py_BytesWarningFlag);

SET_ITEM_INT(Py_FrozenFlag);

SET_ITEM_INT(Py_IgnoreEnvironmentFlag);

SET_ITEM_INT(Py_DontWriteBytecodeFlag);

SET_ITEM_INT(Py_NoUserSiteDirectory);

SET_ITEM_INT(Py_UnbufferedStdioFlag);

SET_ITEM_INT(Py_HashRandomizationFlag);

SET_ITEM_INT(Py_IsolatedFlag);

#ifdef MS_WINDOWS

SET_ITEM_INT(Py_LegacyWindowsFSEncodingFlag);

SET_ITEM_INT(Py_LegacyWindowsStdioFlag);

#endif

return dict;

fail:

Py_DECREF(dict);

return NULL;

#undef FROM_STRING

#undef SET_ITEM

#undef SET_ITEM_INT

#undef SET_ITEM_STR

}

/* --- PyStatus ----------------------------------------------- */

PyStatus PyStatus_Ok(void)

{ return _PyStatus_OK(); }

PyStatus PyStatus_Error(const char *err_msg)

{

assert(err_msg != NULL);

return (PyStatus){._type = _PyStatus_TYPE_ERROR,

.err_msg = err_msg};

}

PyStatus PyStatus_NoMemory(void)

{ return PyStatus_Error("memory allocation failed"); }

PyStatus PyStatus_Exit(int exitcode)

{ return _PyStatus_EXIT(exitcode); }

int PyStatus_IsError(PyStatus status)

{ return _PyStatus_IS_ERROR(status); }

int PyStatus_IsExit(PyStatus status)

{ return _PyStatus_IS_EXIT(status); }

int PyStatus_Exception(PyStatus status)

{ return _PyStatus_EXCEPTION(status); }

PyObject*

_PyErr_SetFromPyStatus(PyStatus status)

{

if (!_PyStatus_IS_ERROR(status)) {

PyErr_Format(PyExc_SystemError,

"%s() expects an error PyStatus",

_PyStatus_GET_FUNC());

}

else if (status.func) {

PyErr_Format(PyExc_ValueError, "%s: %s", status.func, status.err_msg);

}

else {

PyErr_Format(PyExc_ValueError, "%s", status.err_msg);

}

return NULL;

}

/* --- PyWideStringList ------------------------------------------------ */

#ifndef NDEBUG

int

_PyWideStringList_CheckConsistency(const PyWideStringList *list)

{

assert(list->length >= 0);

if (list->length != 0) {

assert(list->items != NULL);

}

for (Py_ssize_t i = 0; i < list->length; i++) {

assert(list->items[i] != NULL);

}

return 1;

}

#endif /* Py_DEBUG */

void

_PyWideStringList_Clear(PyWideStringList *list)

{

assert(_PyWideStringList_CheckConsistency(list));

for (Py_ssize_t i=0; i < list->length; i++) {

PyMem_RawFree(list->items[i]);

}

PyMem_RawFree(list->items);

list->length = 0;

list->items = NULL;

}

int

_PyWideStringList_Copy(PyWideStringList *list, const PyWideStringList *list2)

{

assert(_PyWideStringList_CheckConsistency(list));

assert(_PyWideStringList_CheckConsistency(list2));

if (list2->length == 0) {

_PyWideStringList_Clear(list);

return 0;

}

PyWideStringList copy = _PyWideStringList_INIT;

size_t size = list2->length * sizeof(list2->items[0]);

copy.items = PyMem_RawMalloc(size);

if (copy.items == NULL) {

return -1;

}

for (Py_ssize_t i=0; i < list2->length; i++) {

wchar_t *item = _PyMem_RawWcsdup(list2->items[i]);

if (item == NULL) {

_PyWideStringList_Clear(&copy);

return -1;

}

copy.items[i] = item;

copy.length = i + 1;

}

_PyWideStringList_Clear(list);

*list = copy;

return 0;

}

PyStatus

PyWideStringList_Insert(PyWideStringList *list,

Py_ssize_t index, const wchar_t *item)

{

Py_ssize_t len = list->length;

if (len == PY_SSIZE_T_MAX) {

/* length+1 would overflow */

return _PyStatus_NO_MEMORY();

}

if (index < 0) {

return _PyStatus_ERR("PyWideStringList_Insert index must be >= 0");

}

if (index > len) {

index = len;

}

wchar_t *item2 = _PyMem_RawWcsdup(item);

if (item2 == NULL) {

return _PyStatus_NO_MEMORY();

}

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

wchar_t **items2 = (wchar_t **)PyMem_RawRealloc(list->items, size);

if (items2 == NULL) {

PyMem_RawFree(item2);

return _PyStatus_NO_MEMORY();

}

if (index < len) {

memmove(&items2[index + 1],

&items2[index],

(len - index) * sizeof(items2[0]));

}

items2[index] = item2;

list->items = items2;

list->length++;

return _PyStatus_OK();

}

PyStatus

PyWideStringList_Append(PyWideStringList *list, const wchar_t *item)

{

return PyWideStringList_Insert(list, list->length, item);

}

PyStatus

_PyWideStringList_Extend(PyWideStringList *list, const PyWideStringList *list2)

{

for (Py_ssize_t i = 0; i < list2->length; i++) {

PyStatus status = PyWideStringList_Append(list, list2->items[i]);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

}

return _PyStatus_OK();

}

static int

_PyWideStringList_Find(PyWideStringList *list, const wchar_t *item)

{

for (Py_ssize_t i = 0; i < list->length; i++) {

if (wcscmp(list->items[i], item) == 0) {

return 1;

}

}

return 0;

}

PyObject*

_PyWideStringList_AsList(const PyWideStringList *list)

{

assert(_PyWideStringList_CheckConsistency(list));

PyObject *pylist = PyList_New(list->length);

if (pylist == NULL) {

return NULL;

}

for (Py_ssize_t i = 0; i < list->length; i++) {

PyObject *item = PyUnicode_FromWideChar(list->items[i], -1);

if (item == NULL) {

Py_DECREF(pylist);

return NULL;

}

PyList_SET_ITEM(pylist, i, item);

}

return pylist;

}

/* --- Py_SetStandardStreamEncoding() ----------------------------- */

/* Helper to allow an embedding application to override the normal

* mechanism that attempts to figure out an appropriate IO encoding

*/

static char *_Py_StandardStreamEncoding = NULL;

static char *_Py_StandardStreamErrors = NULL;

int

Py_SetStandardStreamEncoding(const char *encoding, const char *errors)

{

if (Py_IsInitialized()) {

/* This is too late to have any effect */

return -1;

}

int res = 0;

/* Py_SetStandardStreamEncoding() can be called before Py_Initialize(),

but Py_Initialize() can change the allocator. Use a known allocator

to be able to release the memory later. */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

/* Can't call PyErr_NoMemory() on errors, as Python hasn't been

* initialised yet.

*

* However, the raw memory allocators are initialised appropriately

* as C static variables, so _PyMem_RawStrdup is OK even though

* Py_Initialize hasn't been called yet.

*/

if (encoding) {

PyMem_RawFree(_Py_StandardStreamEncoding);

_Py_StandardStreamEncoding = _PyMem_RawStrdup(encoding);

if (!_Py_StandardStreamEncoding) {

res = -2;

goto done;

}

}

if (errors) {

PyMem_RawFree(_Py_StandardStreamErrors);

_Py_StandardStreamErrors = _PyMem_RawStrdup(errors);

if (!_Py_StandardStreamErrors) {

PyMem_RawFree(_Py_StandardStreamEncoding);

_Py_StandardStreamEncoding = NULL;

res = -3;

goto done;

}

}

#ifdef MS_WINDOWS

if (_Py_StandardStreamEncoding) {

/* Overriding the stream encoding implies legacy streams */

Py_LegacyWindowsStdioFlag = 1;

}

#endif

done:

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

return res;

}

void

_Py_ClearStandardStreamEncoding(void)

{

/* Use the same allocator than Py_SetStandardStreamEncoding() */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

/* We won't need them anymore. */

if (_Py_StandardStreamEncoding) {

PyMem_RawFree(_Py_StandardStreamEncoding);

_Py_StandardStreamEncoding = NULL;

}

if (_Py_StandardStreamErrors) {

PyMem_RawFree(_Py_StandardStreamErrors);

_Py_StandardStreamErrors = NULL;

}

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

/* --- Py_GetArgcArgv() ------------------------------------------- */

/* For Py_GetArgcArgv(); set by _Py_SetArgcArgv() */

static PyWideStringList orig_argv = {.length = 0, .items = NULL};

void

_Py_ClearArgcArgv(void)

{

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

_PyWideStringList_Clear(&orig_argv);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

static int

_Py_SetArgcArgv(Py_ssize_t argc, wchar_t * const *argv)

{

const PyWideStringList argv_list = {.length = argc, .items = (wchar_t **)argv};

int res;

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

res = _PyWideStringList_Copy(&orig_argv, &argv_list);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

return res;

}

// _PyConfig_Write() calls _Py_SetArgcArgv() with PyConfig.orig_argv.

void

Py_GetArgcArgv(int *argc, wchar_t ***argv)

{

*argc = (int)orig_argv.length;

*argv = orig_argv.items;

}

/* --- PyConfig ---------------------------------------------- */

#define DECODE_LOCALE_ERR(NAME, LEN) \

(((LEN) == -2) \

? _PyStatus_ERR("cannot decode " NAME) \

: _PyStatus_NO_MEMORY())

/* Free memory allocated in config, but don't clear all attributes */

void

PyConfig_Clear(PyConfig *config)

{

#define CLEAR(ATTR) \

do { \

PyMem_RawFree(ATTR); \

ATTR = NULL; \

} while (0)

CLEAR(config->pycache_prefix);

CLEAR(config->pythonpath_env);

CLEAR(config->home);

CLEAR(config->program_name);

_PyWideStringList_Clear(&config->argv);

_PyWideStringList_Clear(&config->warnoptions);

_PyWideStringList_Clear(&config->xoptions);

_PyWideStringList_Clear(&config->module_search_paths);

config->module_search_paths_set = 0;

CLEAR(config->executable);

CLEAR(config->base_executable);

CLEAR(config->prefix);

CLEAR(config->base_prefix);

CLEAR(config->exec_prefix);

CLEAR(config->base_exec_prefix);

CLEAR(config->platlibdir);

CLEAR(config->filesystem_encoding);

CLEAR(config->filesystem_errors);

CLEAR(config->stdio_encoding);

CLEAR(config->stdio_errors);

CLEAR(config->run_command);

CLEAR(config->run_module);

CLEAR(config->run_filename);

CLEAR(config->check_hash_pycs_mode);

_PyWideStringList_Clear(&config->orig_argv);

#undef CLEAR

}

void

_PyConfig_InitCompatConfig(PyConfig *config)

{

memset(config, 0, sizeof(*config));

config->_config_init = (int)_PyConfig_INIT_COMPAT;

config->isolated = -1;

config->use_environment = -1;

config->dev_mode = -1;

config->install_signal_handlers = 1;

config->use_hash_seed = -1;

config->faulthandler = -1;

config->tracemalloc = -1;

config->module_search_paths_set = 0;

config->parse_argv = 0;

config->site_import = -1;

config->bytes_warning = -1;

config->inspect = -1;

config->interactive = -1;

config->optimization_level = -1;

config->parser_debug= -1;

config->write_bytecode = -1;

config->verbose = -1;

config->quiet = -1;

config->user_site_directory = -1;

config->configure_c_stdio = 0;

config->buffered_stdio = -1;

config->_install_importlib = 1;

config->check_hash_pycs_mode = NULL;

config->pathconfig_warnings = -1;

config->_init_main = 1;

config->_isolated_interpreter = 0;

#ifdef MS_WINDOWS

config->legacy_windows_stdio = -1;

#endif

}

static void

config_init_defaults(PyConfig *config)

{

_PyConfig_InitCompatConfig(config);

config->isolated = 0;

config->use_environment = 1;

config->site_import = 1;

config->bytes_warning = 0;

config->inspect = 0;

config->interactive = 0;

config->optimization_level = 0;

config->parser_debug= 0;

config->write_bytecode = 1;

config->verbose = 0;

config->quiet = 0;

config->user_site_directory = 1;

config->buffered_stdio = 1;

config->pathconfig_warnings = 1;

#ifdef MS_WINDOWS

config->legacy_windows_stdio = 0;

#endif

}

void

PyConfig_InitPythonConfig(PyConfig *config)

{

config_init_defaults(config);

config->_config_init = (int)_PyConfig_INIT_PYTHON;

config->configure_c_stdio = 1;

config->parse_argv = 1;

}

void

PyConfig_InitIsolatedConfig(PyConfig *config)

{

config_init_defaults(config);

config->_config_init = (int)_PyConfig_INIT_ISOLATED;

config->isolated = 1;

config->use_environment = 0;

config->user_site_directory = 0;

config->dev_mode = 0;

config->install_signal_handlers = 0;

config->use_hash_seed = 0;

config->faulthandler = 0;

config->tracemalloc = 0;

config->pathconfig_warnings = 0;

#ifdef MS_WINDOWS

config->legacy_windows_stdio = 0;

#endif

}

/* Copy str into *config_str (duplicate the string) */

PyStatus

PyConfig_SetString(PyConfig *config, wchar_t **config_str, const wchar_t *str)

{

PyStatus status = _Py_PreInitializeFromConfig(config, NULL);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

wchar_t *str2;

if (str != NULL) {

str2 = _PyMem_RawWcsdup(str);

if (str2 == NULL) {

return _PyStatus_NO_MEMORY();

}

}

else {

str2 = NULL;

}

PyMem_RawFree(*config_str);

*config_str = str2;

return _PyStatus_OK();

}

static PyStatus

config_set_bytes_string(PyConfig *config, wchar_t **config_str,

const char *str, const char *decode_err_msg)

{

PyStatus status = _Py_PreInitializeFromConfig(config, NULL);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

wchar_t *str2;

if (str != NULL) {

size_t len;

str2 = Py_DecodeLocale(str, &len);

if (str2 == NULL) {

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

return _PyStatus_ERR(decode_err_msg);

}

else {

return _PyStatus_NO_MEMORY();

}

}

}

else {

str2 = NULL;

}

PyMem_RawFree(*config_str);

*config_str = str2;

return _PyStatus_OK();

}

#define CONFIG_SET_BYTES_STR(config, config_str, str, NAME) \

config_set_bytes_string(config, config_str, str, "cannot decode " NAME)

/* Decode str using Py_DecodeLocale() and set the result into *config_str.

Pre-initialize Python if needed to ensure that encodings are properly

configured. */

PyStatus

PyConfig_SetBytesString(PyConfig *config, wchar_t **config_str,

const char *str)

{

return CONFIG_SET_BYTES_STR(config, config_str, str, "string");

}

PyStatus

_PyConfig_Copy(PyConfig *config, const PyConfig *config2)

{

PyStatus status;

PyConfig_Clear(config);

#define COPY_ATTR(ATTR) config->ATTR = config2->ATTR

#define COPY_WSTR_ATTR(ATTR) \

do { \

status = PyConfig_SetString(config, &config->ATTR, config2->ATTR); \

if (_PyStatus_EXCEPTION(status)) { \

return status; \

} \

} while (0)

#define COPY_WSTRLIST(LIST) \

do { \

if (_PyWideStringList_Copy(&config->LIST, &config2->LIST) < 0) { \

return _PyStatus_NO_MEMORY(); \

} \

} while (0)

COPY_ATTR(_config_init);

COPY_ATTR(isolated);

COPY_ATTR(use_environment);

COPY_ATTR(dev_mode);

COPY_ATTR(install_signal_handlers);

COPY_ATTR(use_hash_seed);

COPY_ATTR(hash_seed);

COPY_ATTR(_install_importlib);

COPY_ATTR(faulthandler);

COPY_ATTR(tracemalloc);

COPY_ATTR(import_time);

COPY_ATTR(show_ref_count);

COPY_ATTR(dump_refs);

COPY_ATTR(malloc_stats);

COPY_WSTR_ATTR(pycache_prefix);

COPY_WSTR_ATTR(pythonpath_env);

COPY_WSTR_ATTR(home);

COPY_WSTR_ATTR(program_name);

COPY_ATTR(parse_argv);

COPY_WSTRLIST(argv);

COPY_WSTRLIST(warnoptions);

COPY_WSTRLIST(xoptions);

COPY_WSTRLIST(module_search_paths);

COPY_ATTR(module_search_paths_set);

COPY_WSTR_ATTR(executable);

COPY_WSTR_ATTR(base_executable);

COPY_WSTR_ATTR(prefix);

COPY_WSTR_ATTR(base_prefix);

COPY_WSTR_ATTR(exec_prefix);

COPY_WSTR_ATTR(base_exec_prefix);

COPY_WSTR_ATTR(platlibdir);

COPY_ATTR(site_import);

COPY_ATTR(bytes_warning);

COPY_ATTR(inspect);

COPY_ATTR(interactive);

COPY_ATTR(optimization_level);

COPY_ATTR(parser_debug);

COPY_ATTR(write_bytecode);

COPY_ATTR(verbose);

COPY_ATTR(quiet);

COPY_ATTR(user_site_directory);

COPY_ATTR(configure_c_stdio);

COPY_ATTR(buffered_stdio);

COPY_WSTR_ATTR(filesystem_encoding);

COPY_WSTR_ATTR(filesystem_errors);

COPY_WSTR_ATTR(stdio_encoding);

COPY_WSTR_ATTR(stdio_errors);

#ifdef MS_WINDOWS

COPY_ATTR(legacy_windows_stdio);

#endif

COPY_ATTR(skip_source_first_line);

COPY_WSTR_ATTR(run_command);

COPY_WSTR_ATTR(run_module);

COPY_WSTR_ATTR(run_filename);

COPY_WSTR_ATTR(check_hash_pycs_mode);

COPY_ATTR(pathconfig_warnings);

COPY_ATTR(_init_main);

COPY_ATTR(_isolated_interpreter);

COPY_WSTRLIST(orig_argv);

#undef COPY_ATTR

#undef COPY_WSTR_ATTR

#undef COPY_WSTRLIST

return _PyStatus_OK();

}

static PyObject *

config_as_dict(const PyConfig *config)

{

PyObject *dict = PyDict_New();

if (dict == NULL) {

return NULL;

}

#define SET_ITEM(KEY, EXPR) \

do { \

PyObject *obj = (EXPR); \

if (obj == NULL) { \

goto fail; \

} \

int res = PyDict_SetItemString(dict, (KEY), obj); \

Py_DECREF(obj); \

if (res < 0) { \

goto fail; \

} \

} while (0)

#define SET_ITEM_INT(ATTR) \

SET_ITEM(#ATTR, PyLong_FromLong(config->ATTR))

#define SET_ITEM_UINT(ATTR) \

SET_ITEM(#ATTR, PyLong_FromUnsignedLong(config->ATTR))

#define FROM_WSTRING(STR) \

((STR != NULL) ? \

PyUnicode_FromWideChar(STR, -1) \

: (Py_INCREF(Py_None), Py_None))

#define SET_ITEM_WSTR(ATTR) \

SET_ITEM(#ATTR, FROM_WSTRING(config->ATTR))

#define SET_ITEM_WSTRLIST(LIST) \

SET_ITEM(#LIST, _PyWideStringList_AsList(&config->LIST))

SET_ITEM_INT(_config_init);

SET_ITEM_INT(isolated);

SET_ITEM_INT(use_environment);

SET_ITEM_INT(dev_mode);

SET_ITEM_INT(install_signal_handlers);

SET_ITEM_INT(use_hash_seed);

SET_ITEM_UINT(hash_seed);

SET_ITEM_INT(faulthandler);

SET_ITEM_INT(tracemalloc);

SET_ITEM_INT(import_time);

SET_ITEM_INT(show_ref_count);

SET_ITEM_INT(dump_refs);

SET_ITEM_INT(malloc_stats);

SET_ITEM_WSTR(filesystem_encoding);

SET_ITEM_WSTR(filesystem_errors);

SET_ITEM_WSTR(pycache_prefix);

SET_ITEM_WSTR(program_name);

SET_ITEM_INT(parse_argv);

SET_ITEM_WSTRLIST(argv);

SET_ITEM_WSTRLIST(xoptions);

SET_ITEM_WSTRLIST(warnoptions);

SET_ITEM_WSTR(pythonpath_env);

SET_ITEM_WSTR(home);

SET_ITEM_WSTRLIST(module_search_paths);

SET_ITEM_WSTR(executable);

SET_ITEM_WSTR(base_executable);

SET_ITEM_WSTR(prefix);

SET_ITEM_WSTR(base_prefix);

SET_ITEM_WSTR(exec_prefix);

SET_ITEM_WSTR(base_exec_prefix);

SET_ITEM_WSTR(platlibdir);

SET_ITEM_INT(site_import);

SET_ITEM_INT(bytes_warning);

SET_ITEM_INT(inspect);

SET_ITEM_INT(interactive);

SET_ITEM_INT(optimization_level);

SET_ITEM_INT(parser_debug);

SET_ITEM_INT(write_bytecode);

SET_ITEM_INT(verbose);

SET_ITEM_INT(quiet);

SET_ITEM_INT(user_site_directory);

SET_ITEM_INT(configure_c_stdio);

SET_ITEM_INT(buffered_stdio);

SET_ITEM_WSTR(stdio_encoding);

SET_ITEM_WSTR(stdio_errors);

#ifdef MS_WINDOWS

SET_ITEM_INT(legacy_windows_stdio);

#endif

SET_ITEM_INT(skip_source_first_line);

SET_ITEM_WSTR(run_command);

SET_ITEM_WSTR(run_module);

SET_ITEM_WSTR(run_filename);

SET_ITEM_INT(_install_importlib);

SET_ITEM_WSTR(check_hash_pycs_mode);

SET_ITEM_INT(pathconfig_warnings);

SET_ITEM_INT(_init_main);

SET_ITEM_INT(_isolated_interpreter);

SET_ITEM_WSTRLIST(orig_argv);

return dict;

fail:

Py_DECREF(dict);

return NULL;

#undef FROM_WSTRING

#undef SET_ITEM

#undef SET_ITEM_INT

#undef SET_ITEM_UINT

#undef SET_ITEM_WSTR

#undef SET_ITEM_WSTRLIST

}

static const char*

config_get_env(const PyConfig *config, const char *name)

{

return _Py_GetEnv(config->use_environment, name);

}

/* Get a copy of the environment variable as wchar_t*.

Return 0 on success, but *dest can be NULL.

Return -1 on memory allocation failure. Return -2 on decoding error. */

static PyStatus