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

#include <stdlib.h> // getenv()

#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 : turn on parser debugging output (for experts only, only works on\n\

debug builds); 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\

-X warn_default_encoding: enable opt-in EncodingWarning for 'encoding=None'\n\

-X no_debug_ranges: disable the inclusion of the tables mapping extra location \n\

information (end line, start column offset and end column offset) to every \n\

instruction in code objects. This is useful when smaller code objects and pyc \n\

files are desired as well as suppressing the extra visual location indicators \n\

when the interpreter displays tracebacks.\n\

-X frozen_modules=[on|off]: whether or not frozen modules should be used.\n\

The default is \"on\" (or \"off\" if you are running a local build).\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"

"PYTHONWARNDEFAULTENCODING: enable opt-in EncodingWarning for 'encoding=None'.\n"

"PYTHONNODEBUGRANGES: If this variable is set, it disables the inclusion of the \n"

" tables mapping extra location information (end line, start column offset \n"

" and end column offset) to every instruction in code objects. This is useful \n"

" when smaller cothe de objects and pyc files are desired as well as suppressing the \n"

" extra visual location indicators when the interpreter displays tracebacks.\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

}

char*

Py_GETENV(const char *name)

{

if (Py_IgnoreEnvironmentFlag) {

return NULL;

}

return getenv(name);

}

/* --- 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 MAX_HASH_SEED 4294967295UL

#ifndef NDEBUG

static int

config_check_consistency(const PyConfig *config)

{

/* Check config consistency */

assert(config->isolated >= 0);

assert(config->use_environment >= 0);

assert(config->dev_mode >= 0);

assert(config->install_signal_handlers >= 0);

assert(config->use_hash_seed >= 0);

assert(config->hash_seed <= MAX_HASH_SEED);

assert(config->faulthandler >= 0);

assert(config->tracemalloc >= 0);

assert(config->import_time >= 0);

assert(config->no_debug_ranges >= 0);

assert(config->show_ref_count >= 0);

assert(config->dump_refs >= 0);

assert(config->malloc_stats >= 0);

assert(config->site_import >= 0);

assert(config->bytes_warning >= 0);

assert(config->warn_default_encoding >= 0);

assert(config->inspect >= 0);

assert(config->interactive >= 0);

assert(config->optimization_level >= 0);

assert(config->parser_debug >= 0);

assert(config->write_bytecode >= 0);

assert(config->verbose >= 0);

assert(config->quiet >= 0);

assert(config->user_site_directory >= 0);

assert(config->parse_argv >= 0);

assert(config->configure_c_stdio >= 0);

assert(config->buffered_stdio >= 0);

assert(config->program_name != NULL);

assert(_PyWideStringList_CheckConsistency(&config->orig_argv));

assert(_PyWideStringList_CheckConsistency(&config->argv));

/* sys.argv must be non-empty: empty argv is replaced with [''] */

assert(config->argv.length >= 1);

assert(_PyWideStringList_CheckConsistency(&config->xoptions));

assert(_PyWideStringList_CheckConsistency(&config->warnoptions));

assert(_PyWideStringList_CheckConsistency(&config->module_search_paths));

assert(config->module_search_paths_set >= 0);

assert(config->platlibdir != NULL);

assert(config->filesystem_encoding != NULL);

assert(config->filesystem_errors != NULL);

assert(config->stdio_encoding != NULL);

assert(config->stdio_errors != NULL);

#ifdef MS_WINDOWS

assert(config->legacy_windows_stdio >= 0);

#endif

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

assert(!(config->run_command != NULL && config->run_module != NULL));

assert(config->check_hash_pycs_mode != NULL);

assert(config->_install_importlib >= 0);

assert(config->pathconfig_warnings >= 0);

return 1;

}

#endif

/* 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->stdlib_dir);

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->warn_default_encoding = 0;

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

config->use_frozen_modules = -1;

}

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

COPY_ATTR(show_ref_count);

COPY_ATTR(dump_refs);

COPY_ATTR(dump_refs_file);

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

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

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

COPY_WSTRLIST(orig_argv);

#undef COPY_ATTR

#undef COPY_WSTR_ATTR

#undef COPY_WSTRLIST

return _PyStatus_OK();

}

PyObject *

_PyConfig_AsDict(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) \