#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_long.h" // _PY_LONG_MAX_STR_DIGITS_THRESHOLD

#include "pycore_pathconfig.h" // _Py_path_config

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

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

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

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

#include "pycore_pystats.h" // _Py_StatsOn()

#include "pycore_sysmodule.h" // _PySys_SetIntMaxStrDigits()

#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

#include "config_common.h"

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

typedef PyObject* (*config_sys_flag_setter) (int value);

static PyObject*

config_sys_flag_long(int value)

{

return PyLong_FromLong(value);

}

static PyObject*

config_sys_flag_not(int value)

{

value = (!value);

return config_sys_flag_long(value);

}

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

typedef enum {

PyConfig_MEMBER_INT = 0,

PyConfig_MEMBER_UINT = 1,

PyConfig_MEMBER_ULONG = 2,

PyConfig_MEMBER_BOOL = 3,

PyConfig_MEMBER_WSTR = 10,

PyConfig_MEMBER_WSTR_OPT = 11,

PyConfig_MEMBER_WSTR_LIST = 12,

} PyConfigMemberType;

typedef enum {

// Option which cannot be get or set by PyConfig_Get() and PyConfig_Set()

PyConfig_MEMBER_INIT_ONLY = 0,

// Option which cannot be set by PyConfig_Set()

PyConfig_MEMBER_READ_ONLY = 1,

// Public option: can be get and set by PyConfig_Get() and PyConfig_Set()

PyConfig_MEMBER_PUBLIC = 2,

} PyConfigMemberVisibility;

typedef struct {

const char *attr;

int flag_index;

config_sys_flag_setter flag_setter;

} PyConfigSysSpec;

typedef struct {

const char *name;

size_t offset;

PyConfigMemberType type;

PyConfigMemberVisibility visibility;

PyConfigSysSpec sys;

} PyConfigSpec;

#define SPEC(MEMBER, TYPE, VISIBILITY, sys) \

{#MEMBER, offsetof(PyConfig, MEMBER), \

PyConfig_MEMBER_##TYPE, PyConfig_MEMBER_##VISIBILITY, sys}

#define SYS_ATTR(name) {name, -1, NULL}

#define SYS_FLAG_SETTER(index, setter) {NULL, index, setter}

#define SYS_FLAG(index) SYS_FLAG_SETTER(index, NULL)

#define NO_SYS SYS_ATTR(NULL)

// Update _test_embed_set_config when adding new members

static const PyConfigSpec PYCONFIG_SPEC[] = {

// --- Public options -----------

SPEC(argv, WSTR_LIST, PUBLIC, SYS_ATTR("argv")),

SPEC(base_exec_prefix, WSTR_OPT, PUBLIC, SYS_ATTR("base_exec_prefix")),

SPEC(base_executable, WSTR_OPT, PUBLIC, SYS_ATTR("_base_executable")),

SPEC(base_prefix, WSTR_OPT, PUBLIC, SYS_ATTR("base_prefix")),

SPEC(bytes_warning, UINT, PUBLIC, SYS_FLAG(9)),

SPEC(exec_prefix, WSTR_OPT, PUBLIC, SYS_ATTR("exec_prefix")),

SPEC(executable, WSTR_OPT, PUBLIC, SYS_ATTR("executable")),

SPEC(inspect, BOOL, PUBLIC, SYS_FLAG(1)),

SPEC(int_max_str_digits, UINT, PUBLIC, NO_SYS),

SPEC(interactive, BOOL, PUBLIC, SYS_FLAG(2)),

SPEC(module_search_paths, WSTR_LIST, PUBLIC, SYS_ATTR("path")),

SPEC(optimization_level, UINT, PUBLIC, SYS_FLAG(3)),

SPEC(parser_debug, BOOL, PUBLIC, SYS_FLAG(0)),

SPEC(platlibdir, WSTR, PUBLIC, SYS_ATTR("platlibdir")),

SPEC(prefix, WSTR_OPT, PUBLIC, SYS_ATTR("prefix")),

SPEC(pycache_prefix, WSTR_OPT, PUBLIC, SYS_ATTR("pycache_prefix")),

SPEC(quiet, BOOL, PUBLIC, SYS_FLAG(10)),

SPEC(stdlib_dir, WSTR_OPT, PUBLIC, SYS_ATTR("_stdlib_dir")),

SPEC(use_environment, BOOL, PUBLIC, SYS_FLAG_SETTER(7, config_sys_flag_not)),

SPEC(verbose, UINT, PUBLIC, SYS_FLAG(8)),

SPEC(warnoptions, WSTR_LIST, PUBLIC, SYS_ATTR("warnoptions")),

SPEC(write_bytecode, BOOL, PUBLIC, SYS_FLAG_SETTER(4, config_sys_flag_not)),

SPEC(xoptions, WSTR_LIST, PUBLIC, SYS_ATTR("_xoptions")),

// --- Read-only options -----------

#ifdef Py_STATS

SPEC(_pystats, BOOL, READ_ONLY, NO_SYS),

#endif

SPEC(buffered_stdio, BOOL, READ_ONLY, NO_SYS),

SPEC(check_hash_pycs_mode, WSTR, READ_ONLY, NO_SYS),

SPEC(code_debug_ranges, BOOL, READ_ONLY, NO_SYS),

SPEC(configure_c_stdio, BOOL, READ_ONLY, NO_SYS),

SPEC(cpu_count, INT, READ_ONLY, NO_SYS),

SPEC(dev_mode, BOOL, READ_ONLY, NO_SYS), // sys.flags.dev_mode

SPEC(dump_refs, BOOL, READ_ONLY, NO_SYS),

SPEC(dump_refs_file, WSTR_OPT, READ_ONLY, NO_SYS),

#ifdef Py_GIL_DISABLED

SPEC(enable_gil, INT, READ_ONLY, NO_SYS),

SPEC(tlbc_enabled, INT, READ_ONLY, NO_SYS),

#endif

SPEC(faulthandler, BOOL, READ_ONLY, NO_SYS),

SPEC(filesystem_encoding, WSTR, READ_ONLY, NO_SYS),

SPEC(filesystem_errors, WSTR, READ_ONLY, NO_SYS),

SPEC(hash_seed, ULONG, READ_ONLY, NO_SYS),

SPEC(home, WSTR_OPT, READ_ONLY, NO_SYS),

SPEC(import_time, BOOL, READ_ONLY, NO_SYS),

SPEC(install_signal_handlers, BOOL, READ_ONLY, NO_SYS),

SPEC(isolated, BOOL, READ_ONLY, NO_SYS), // sys.flags.isolated

#ifdef MS_WINDOWS

SPEC(legacy_windows_stdio, BOOL, READ_ONLY, NO_SYS),

#endif

SPEC(malloc_stats, BOOL, READ_ONLY, NO_SYS),

SPEC(orig_argv, WSTR_LIST, READ_ONLY, SYS_ATTR("orig_argv")),

SPEC(parse_argv, BOOL, READ_ONLY, NO_SYS),

SPEC(pathconfig_warnings, BOOL, READ_ONLY, NO_SYS),

SPEC(perf_profiling, UINT, READ_ONLY, NO_SYS),

SPEC(program_name, WSTR, READ_ONLY, NO_SYS),

SPEC(run_command, WSTR_OPT, READ_ONLY, NO_SYS),

SPEC(run_filename, WSTR_OPT, READ_ONLY, NO_SYS),

SPEC(run_module, WSTR_OPT, READ_ONLY, NO_SYS),

#ifdef Py_DEBUG

SPEC(run_presite, WSTR_OPT, READ_ONLY, NO_SYS),

#endif

SPEC(safe_path, BOOL, READ_ONLY, NO_SYS),

SPEC(show_ref_count, BOOL, READ_ONLY, NO_SYS),

SPEC(site_import, BOOL, READ_ONLY, NO_SYS), // sys.flags.no_site

SPEC(skip_source_first_line, BOOL, READ_ONLY, NO_SYS),

SPEC(stdio_encoding, WSTR, READ_ONLY, NO_SYS),

SPEC(stdio_errors, WSTR, READ_ONLY, NO_SYS),

SPEC(tracemalloc, UINT, READ_ONLY, NO_SYS),

SPEC(use_frozen_modules, BOOL, READ_ONLY, NO_SYS),

SPEC(use_hash_seed, BOOL, READ_ONLY, NO_SYS),

#ifdef __APPLE__

SPEC(use_system_logger, BOOL, READ_ONLY, NO_SYS),

#endif

SPEC(user_site_directory, BOOL, READ_ONLY, NO_SYS), // sys.flags.no_user_site

SPEC(warn_default_encoding, BOOL, READ_ONLY, NO_SYS),

// --- Init-only options -----------

SPEC(_config_init, UINT, INIT_ONLY, NO_SYS),

SPEC(_init_main, BOOL, INIT_ONLY, NO_SYS),

SPEC(_install_importlib, BOOL, INIT_ONLY, NO_SYS),

SPEC(_is_python_build, BOOL, INIT_ONLY, NO_SYS),

SPEC(module_search_paths_set, BOOL, INIT_ONLY, NO_SYS),

SPEC(pythonpath_env, WSTR_OPT, INIT_ONLY, NO_SYS),

SPEC(sys_path_0, WSTR_OPT, INIT_ONLY, NO_SYS),

// Array terminator

{NULL, 0, 0, 0, NO_SYS},

};

#undef SPEC

#define SPEC(MEMBER, TYPE, VISIBILITY) \

{#MEMBER, offsetof(PyPreConfig, MEMBER), PyConfig_MEMBER_##TYPE, \

PyConfig_MEMBER_##VISIBILITY, NO_SYS}

static const PyConfigSpec PYPRECONFIG_SPEC[] = {

// --- Read-only options -----------

SPEC(allocator, INT, READ_ONLY),

SPEC(coerce_c_locale, BOOL, READ_ONLY),

SPEC(coerce_c_locale_warn, BOOL, READ_ONLY),

SPEC(configure_locale, BOOL, READ_ONLY),

#ifdef MS_WINDOWS

SPEC(legacy_windows_fs_encoding, BOOL, READ_ONLY),

#endif

SPEC(utf8_mode, BOOL, READ_ONLY),

// --- Init-only options -----------

// Members already present in PYCONFIG_SPEC

SPEC(_config_init, INT, INIT_ONLY),

SPEC(dev_mode, BOOL, INIT_ONLY),

SPEC(isolated, BOOL, INIT_ONLY),

SPEC(parse_argv, BOOL, INIT_ONLY),

SPEC(use_environment, BOOL, INIT_ONLY),

// Array terminator

{NULL, 0, 0, 0, NO_SYS},

};

#undef SPEC

#undef SYS_ATTR

#undef SYS_FLAG_SETTER

#undef SYS_FLAG

#undef NO_SYS

// Forward declarations

static PyObject*

config_get(const PyConfig *config, const PyConfigSpec *spec,

int use_sys);

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

/* Lines sorted by option name; keep in sync with usage_envvars* below */

static const char usage_help[] = "\

Options (and corresponding environment variables):\n\

-b : issue warnings about converting bytes/bytearray to str and comparing\n\

bytes/bytearray with str or bytes with int. (-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 -? or --help)\n\

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

-P : don't prepend a potentially unsafe path to sys.path; also\n\

PYTHONSAFEPATH\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=x\n\

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

-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\n\

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

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

--help-env: print help about Python environment variables and exit\n\

--help-xoptions: print help about implementation-specific -X options and exit\n\

--help-all: print complete help information and exit\n\

\n\

Arguments:\n\

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\

";

static const char usage_xoptions[] = "\

The following implementation-specific options are available:\n\

-X cpu_count=N: override the return value of os.cpu_count();\n\

-X cpu_count=default cancels overriding; also PYTHON_CPU_COUNT\n\

-X dev : enable Python Development Mode; also PYTHONDEVMODE\n\

-X faulthandler: dump the Python traceback on fatal errors;\n\

also PYTHONFAULTHANDLER\n\

-X frozen_modules=[on|off]: whether to use frozen modules; the default is \"on\"\n\

for installed Python and \"off\" for a local build;\n\

also PYTHON_FROZEN_MODULES\n\

"

#ifdef Py_GIL_DISABLED

"-X gil=[0|1]: enable (1) or disable (0) the GIL; also PYTHON_GIL\n"

#endif

"\

-X importtime: show how long each import takes; also PYTHONPROFILEIMPORTTIME\n\

-X int_max_str_digits=N: limit the size of int<->str conversions;\n\

0 disables the limit; also PYTHONINTMAXSTRDIGITS\n\

-X no_debug_ranges: don't include extra location information in code objects;\n\

also PYTHONNODEBUGRANGES\n\

-X perf: support the Linux \"perf\" profiler; also PYTHONPERFSUPPORT=1\n\

-X perf_jit: support the Linux \"perf\" profiler with DWARF support;\n\

also PYTHON_PERF_JIT_SUPPORT=1\n\

"

#ifdef Py_DEBUG

"-X presite=MOD: import this module before site; also PYTHON_PRESITE\n"

#endif

"\

-X pycache_prefix=PATH: write .pyc files to a parallel tree instead of to the\n\

code tree; also PYTHONPYCACHEPREFIX\n\

"

#ifdef Py_STATS

"-X pystats: enable pystats collection at startup; also PYTHONSTATS\n"

#endif

"\

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

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

the interactive interpreter; only works on debug builds\n"

#ifdef Py_GIL_DISABLED

"-X tlbc=[0|1]: enable (1) or disable (0) thread-local bytecode. Also\n\

PYTHON_TLBC\n"

#endif

"\

-X tracemalloc[=N]: trace Python memory allocations; N sets a traceback limit\n \

of N frames (default: 1); also PYTHONTRACEMALLOC=N\n\

-X utf8[=0|1]: enable (1) or disable (0) UTF-8 mode; also PYTHONUTF8\n\

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

also PYTHONWARNDEFAULTENCODING\

";

/* Envvars that don't have equivalent command-line options are listed first */

static const char usage_envvars[] =

"Environment variables that change behavior:\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"

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

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

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

" set to an integer in the range [0,4294967295] to get hash\n"

" values with a predictable seed.\n"

"PYTHONMALLOC : set the Python memory allocators and/or install debug hooks\n"

" on Python memory allocators. Use PYTHONMALLOC=debug to\n"

" install debug hooks.\n"

"PYTHONMALLOCSTATS: print memory allocator statistics\n"

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

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

" display of locale coercion and locale compatibility warnings\n"

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

" choice.\n"

"PYTHON_COLORS : if this variable is set to 1, the interpreter will colorize\n"

" various kinds of output. Setting it to 0 deactivates\n"

" this behavior.\n"

"PYTHON_HISTORY : the location of a .python_history file.\n"

"PYTHONASYNCIODEBUG: enable asyncio debug mode\n"

#ifdef Py_TRACE_REFS

"PYTHONDUMPREFS : dump objects and reference counts still alive after shutdown\n"

"PYTHONDUMPREFSFILE: dump objects and reference counts to the specified file\n"

#endif

#ifdef __APPLE__

"PYTHONEXECUTABLE: set sys.argv[0] to this value (macOS only)\n"

#endif

#ifdef MS_WINDOWS

"PYTHONLEGACYWINDOWSFSENCODING: use legacy \"mbcs\" encoding for file system\n"

"PYTHONLEGACYWINDOWSSTDIO: use legacy Windows stdio\n"

#endif

"PYTHONUSERBASE : defines the user base directory (site.USER_BASE)\n"

"PYTHON_BASIC_REPL: use the traditional parser-based REPL\n"

"\n"

"These variables have equivalent command-line options (see --help for details):\n"

"PYTHON_CPU_COUNT: override the return value of os.cpu_count() (-X cpu_count)\n"

"PYTHONDEBUG : enable parser debug mode (-d)\n"

"PYTHONDEVMODE : enable Python Development Mode (-X dev)\n"

"PYTHONDONTWRITEBYTECODE: don't write .pyc files (-B)\n"

"PYTHONFAULTHANDLER: dump the Python traceback on fatal errors (-X faulthandler)\n"

"PYTHON_FROZEN_MODULES: whether to use frozen modules; the default is \"on\"\n"

" for installed Python and \"off\" for a local build\n"

" (-X frozen_modules)\n"

#ifdef Py_GIL_DISABLED

"PYTHON_GIL : when set to 0, disables the GIL (-X gil)\n"

#endif

"PYTHONINSPECT : inspect interactively after running script (-i)\n"

"PYTHONINTMAXSTRDIGITS: limit the size of int<->str conversions;\n"

" 0 disables the limit (-X int_max_str_digits=N)\n"

"PYTHONNODEBUGRANGES: don't include extra location information in code objects\n"

" (-X no_debug_ranges)\n"

"PYTHONNOUSERSITE: disable user site directory (-s)\n"

"PYTHONOPTIMIZE : enable level 1 optimizations (-O)\n"

"PYTHONPERFSUPPORT: support the Linux \"perf\" profiler (-X perf)\n"

"PYTHON_PERF_JIT_SUPPORT: enable Linux \"perf\" profiler support with JIT\n"

" (-X perf_jit)\n"

#ifdef Py_DEBUG

"PYTHON_PRESITE: import this module before site (-X presite)\n"

#endif

"PYTHONPROFILEIMPORTTIME: show how long each import takes (-X importtime)\n"

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

" (-X pycache_prefix)\n"

"PYTHONSAFEPATH : don't prepend a potentially unsafe path to sys.path.\n"

#ifdef Py_STATS

"PYTHONSTATS : turns on statistics gathering (-X pystats)\n"

#endif

#ifdef Py_GIL_DISABLED

"PYTHON_TLBC : when set to 0, disables thread-local bytecode (-X tlbc)\n"

#endif

"PYTHONTRACEMALLOC: trace Python memory allocations (-X tracemalloc)\n"

"PYTHONUNBUFFERED: disable stdout/stderr buffering (-u)\n"

"PYTHONUTF8 : control the UTF-8 mode (-X utf8)\n"

"PYTHONVERBOSE : trace import statements (-v)\n"

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

" (-X warn_default_encoding)\n"

"PYTHONWARNINGS : warning control (-W)\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; /* Previously, was used by Py_FdIsInteractive() */

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)

{

_Py_COMP_DIAG_PUSH

_Py_COMP_DIAG_IGNORE_DEPR_DECLS

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_NewRef(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

_Py_COMP_DIAG_POP

}

char*

Py_GETENV(const char *name)

{

_Py_COMP_DIAG_PUSH

_Py_COMP_DIAG_IGNORE_DEPR_DECLS

if (Py_IgnoreEnvironmentFlag) {

return NULL;

}

return getenv(name);

_Py_COMP_DIAG_POP

}

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

void

_PyErr_SetFromPyStatus(PyStatus status)

{

if (!_PyStatus_IS_ERROR(status)) {

PyErr_Format(PyExc_SystemError,

"_PyErr_SetFromPyStatus() status is not an error");

return;

}

const char *err_msg = status.err_msg;

if (err_msg == NULL || strlen(err_msg) == 0) {

PyErr_Format(PyExc_SystemError,

"_PyErr_SetFromPyStatus() status has no error message");

return;

}

if (strcmp(err_msg, _PyStatus_NO_MEMORY_ERRMSG) == 0) {

PyErr_NoMemory();

return;

}

const char *func = status.func;

if (func) {

PyErr_Format(PyExc_RuntimeError, "%s: %s", func, err_msg);

}

else {

PyErr_Format(PyExc_RuntimeError, "%s", err_msg);

}

}

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

static void

_PyWideStringList_ClearEx(PyWideStringList *list,

bool use_default_allocator)

{

assert(_PyWideStringList_CheckConsistency(list));

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

if (use_default_allocator) {

_PyMem_DefaultRawFree(list->items[i]);

}

else {

PyMem_RawFree(list->items[i]);

}

}

if (use_default_allocator) {

_PyMem_DefaultRawFree(list->items);

}

else {

PyMem_RawFree(list->items);

}

list->length = 0;

list->items = NULL;

}

void

_PyWideStringList_Clear(PyWideStringList *list)

{

_PyWideStringList_ClearEx(list, false);

}

static int

_PyWideStringList_CopyEx(PyWideStringList *list,

const PyWideStringList *list2,

bool use_default_allocator)

{

assert(_PyWideStringList_CheckConsistency(list));

assert(_PyWideStringList_CheckConsistency(list2));

if (list2->length == 0) {

_PyWideStringList_ClearEx(list, use_default_allocator);

return 0;

}

PyWideStringList copy = _PyWideStringList_INIT;

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

if (use_default_allocator) {

copy.items = _PyMem_DefaultRawMalloc(size);

}

else {

copy.items = PyMem_RawMalloc(size);

}

if (copy.items == NULL) {

return -1;

}

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

wchar_t *item;

if (use_default_allocator) {

item = _PyMem_DefaultRawWcsdup(list2->items[i]);

}

else {

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

}

if (item == NULL) {

_PyWideStringList_ClearEx(&copy, use_default_allocator);

return -1;

}

copy.items[i] = item;

copy.length = i + 1;

}

_PyWideStringList_ClearEx(list, use_default_allocator);

*list = copy;

return 0;

}

int

_PyWideStringList_Copy(PyWideStringList *list, const PyWideStringList *list2)

{

return _PyWideStringList_CopyEx(list, list2, false);

}

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;

}

static PyObject*

_PyWideStringList_AsTuple(const PyWideStringList *list)

{

assert(_PyWideStringList_CheckConsistency(list));

PyObject *tuple = PyTuple_New(list->length);

if (tuple == 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(tuple);

return NULL;

}

PyTuple_SET_ITEM(tuple, i, item);

}

return tuple;

}

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

void

_Py_ClearArgcArgv(void)

{

_PyWideStringList_ClearEx(&_PyRuntime.orig_argv, true);

}

static int

_Py_SetArgcArgv(Py_ssize_t argc, wchar_t * const *argv)

{

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

// XXX _PyRuntime.orig_argv only gets cleared by Py_Main(),

// so it currently leaks for embedders.

return _PyWideStringList_CopyEx(&_PyRuntime.orig_argv, &argv_list, true);

}

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

void

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

{

*argc = (int)_PyRuntime.orig_argv.length;

*argv = _PyRuntime.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->code_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(_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->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);

assert(config->_is_python_build >= 0);

assert(config->safe_path >= 0);

assert(config->int_max_str_digits >= 0);

// cpu_count can be -1 if the user doesn't override it.

assert(config->cpu_count != 0);

// config->use_frozen_modules is initialized later

// by _PyConfig_InitImportConfig().

#ifdef __APPLE__

assert(config->use_system_logger >= 0);

#endif

#ifdef Py_STATS

assert(config->_pystats >= 0);

#endif

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

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

#ifdef Py_DEBUG

CLEAR(config->run_presite);

#endif

_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->perf_profiling = -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;