Google Git Google Git
Sign in
chromium/external/github.com/python/cpython/cdf010b10c673e1ec4faaf3f8f9be39237986880/./Python/initconfig.c
blob: 363739a1a1b43c97546ab3557ed74652f42defa7 [file]
#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_pyhash.h" // _Py_HashSecret
#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
#ifdef __APPLE__
/* Enable system log by default on non-macOS Apple platforms */
# if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
#define USE_SYSTEM_LOGGER_DEFAULT 1;
# else
#define USE_SYSTEM_LOGGER_DEFAULT 0;
# 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 {
int *ptr;
int not;
} PyConfigGlobalVar;
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(cpu_count, INT, PUBLIC, NO_SYS),
SPEC(lazy_imports, INT, PUBLIC, NO_SYS),
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(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(thread_inherit_context, INT, READ_ONLY, NO_SYS),
SPEC(context_aware_warnings, INT, READ_ONLY, NO_SYS),
SPEC(import_time, UINT, 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(pymalloc_hugepages, 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(remote_debug, BOOL, 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_OPT, 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),
SPEC(_deferred_cmdline_option, INT, 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);
static void initconfig_free_wstr(wchar_t *member);
static void initconfig_free_wstr_list(PyWideStringList *list);
static void initconfig_free_config(const PyConfig *config);
/* --- Command line options --------------------------------------- */
/*
* Help text markup (matching Lib/_colorize.py Argparse theme).
*
* Color spans, #X{...} where "}" resets to default color:
* #b{...} label bold yellow
* #B{...} summary label yellow
* #E{...} env var (primary) bold cyan
* #e{...} env var reference cyan
* #h{...} heading bold blue
* #L{...} long option bold cyan
* #s{...} short option bold green
* #S{...} summary short opt green
*
* Runtime substitutions (no "{" follows):
* #P program name (bold magenta)
* #D path separator (DELIM)
* #H PYTHONHOMEHELP default search path
*
* fprint_help() walks the string, expanding color codes only when colorize=1
* and substituting runtime values regardless.
*/
#if defined(MS_WINDOWS)
# define PYTHONHOMEHELP "<prefix>\\python{major}{minor}"
#else
# define PYTHONHOMEHELP "<prefix>/lib/pythonX.X"
#endif
/* Determine if we can emit ANSI color codes on the given stream.
* Logic mirrors Lib/_colorize.py:can_colorize(). */
static int
_Py_can_colorize(FILE *f)
{
const char *env;
env = Py_GETENV("PYTHON_COLORS");
if (env) {
if (strcmp(env, "0") == 0) {
return 0;
}
if (strcmp(env, "1") == 0) {
return 1;
}
}
if (getenv("NO_COLOR")) {
return 0;
}
if (getenv("FORCE_COLOR")) {
return 1;
}
env = getenv("TERM");
if (env && strcmp(env, "dumb") == 0) {
return 0;
}
#if defined(MS_WINDOWS) && defined(HAVE_WINDOWS_CONSOLE_IO)
{
DWORD mode = 0;
DWORD nStdHandle = (f == stderr) ? STD_ERROR_HANDLE
: STD_OUTPUT_HANDLE;
HANDLE handle = GetStdHandle(nStdHandle);
if (!GetConsoleMode(handle, &mode)
|| !(mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING))
{
return 0;
}
}
#endif
return isatty(fileno(f));
}
/* Walk help text, expanding markup:
* #X{...} color span (only emitted when colorize=1; '}' resets).
* #X runtime substitution (program name, DELIM, PYTHONHOMEHELP).
* See the markup table above the macro/comment block. */
static void
fprint_help(FILE *f, const char *text, int colorize, const wchar_t *program)
{
for (const char *p = text; *p; ) {
if (*p == '#' && p[1]) {
char code = p[1];
if (p[2] == '{') {
/* Color span open */
const char *seq = NULL;
switch (code) {
case 'h': seq = "\x1b[1;34m"; break; // heading
case 'E': seq = "\x1b[1;36m"; break; // env var primary
case 'e': seq = "\x1b[36m"; break; // env var reference
case 'L': seq = "\x1b[1;36m"; break; // long option
case 'b': seq = "\x1b[1;33m"; break; // label
case 'B': seq = "\x1b[33m"; break; // summary label
case 's': seq = "\x1b[1;32m"; break; // short option
case 'S': seq = "\x1b[32m"; break; // summary short option
}
if (colorize && seq) fputs(seq, f);
p += 3; // skip "#X{"
continue;
}
/* Runtime substitution */
switch (code) {
case 'P': // program name with bold magenta
if (colorize) fputs("\x1b[1;35m", f);
if (program) fprintf(f, "%ls", program);
if (colorize) fputs("\x1b[0m", f);
break;
case 'D':
fputc((char)DELIM, f);
break;
case 'H':
fputs(PYTHONHOMEHELP, f);
break;
default: // unknown: emit literally
fputc('#', f);
fputc(code, f);
break;
}
p += 2; // skip "#X"
continue;
}
if (*p == '}') {
if (colorize) fputs("\x1b[0m", f);
p++;
continue;
}
fputc(*p++, f);
}
}
/* Short usage message */
static const char usage_line[] =
"#h{usage:} #P [#S{option}] #S{...} "
"[#S{-c} #B{cmd} | #S{-m} #B{mod} | #S{file} | #S{-}] "
"[#S{arg}] #S{...}\n"
;
/* Long help message */
/* Lines sorted by option name; keep in sync with usage_envvars* below */
static const char usage_help[] =
"#h{Options (and corresponding environment variables):}\n"
"#s{-b} : issue warnings about converting bytes/bytearray to str and comparing\n"
" bytes/bytearray with str or bytes with int. (#S{-bb}: issue errors)\n"
" deprecated since 3.15 and will become no-op in 3.17.\n"
"#s{-B} : don't write .pyc files on import; also #e{PYTHONDONTWRITEBYTECODE}#B{=x}\n"
"#s{-c} #b{cmd} : program passed in as string (terminates option list)\n"
"#s{-d} : turn on parser debugging output (for experts only, only works on\n"
" debug builds); also #e{PYTHONDEBUG}#B{=x}\n"
"#s{-E} : ignore #e{PYTHON*} environment variables (such as #e{PYTHONPATH})\n"
"#s{-h} : print this help message and exit (also #S{-?} or #e{--help})\n"
"#s{-i} : inspect interactively after running script; forces a prompt even\n"
" if stdin does not appear to be a terminal; also #e{PYTHONINSPECT}#B{=x}\n"
"#s{-I} : isolate Python from the user's environment (implies #S{-E}, #S{-P} and #S{-s})\n"
"#s{-m} #b{mod} : run library module as a script (terminates option list)\n"
"#s{-O} : remove assert and __debug__-dependent statements; add .opt-1 before\n"
" .pyc extension; also #e{PYTHONOPTIMIZE}#B{=x}\n"
"#s{-OO} : do #S{-O} changes and also discard docstrings; add .opt-2 before\n"
" .pyc extension\n"
"#s{-P} : don't prepend a potentially unsafe path to sys.path; also\n"
" #e{PYTHONSAFEPATH}\n"
"#s{-q} : don't print version and copyright messages on interactive startup\n"
"#s{-s} : don't add user site directory to sys.path; also #e{PYTHONNOUSERSITE}#B{=x}\n"
"#s{-S} : don't imply 'import site' on initialization\n"
"#s{-u} : force the stdout and stderr streams to be unbuffered;\n"
" this option has no effect on stdin; also #e{PYTHONUNBUFFERED}#B{=x}\n"
"#s{-v} : verbose (trace import statements); also #e{PYTHONVERBOSE}#B{=x}\n"
" can be supplied multiple times to increase verbosity\n"
"#s{-V} : print the Python version number and exit (also #e{--version})\n"
" when given twice, print more information about the build\n"
"#s{-W} #b{arg} : warning control; #B{arg} is action:message:category:module:lineno\n"
" also #e{PYTHONWARNINGS}#B{=arg}\n"
"#s{-x} : skip first line of source, allowing use of non-Unix forms of #!cmd\n"
"#s{-X} #b{opt} : set implementation-specific option\n"
"#L{--check-hash-based-pycs} #b{always|default|never}:\n"
" control how Python invalidates hash-based .pyc files\n"
"#L{--help-env}: print help about Python environment variables and exit\n"
"#L{--help-xoptions}: print help about implementation-specific #S{-X} options and exit\n"
"#L{--help-all}: print complete help information and exit\n"
"\n"
"#h{Arguments:}\n"
"#s{file} : program read from script file\n"
"#s{-} : program read from stdin (default; interactive mode if a tty)\n"
"#s{arg} #b{...}: arguments passed to program in sys.argv[1:]\n"
;
static const char usage_xoptions[] =
"#h{The following implementation-specific options are available:}\n"
"#s{-X} #L{context_aware_warnings}#b{=[0|1]}: if true (#B{1}) then the warnings module will\n"
" use a context variables; if false (#B{0}) then the warnings module will\n"
" use module globals, which is not concurrent-safe; set to true for\n"
" free-threaded builds and false otherwise; also\n"
" #e{PYTHON_CONTEXT_AWARE_WARNINGS}\n"
"#s{-X} #L{cpu_count}#b{=N}: override the return value of os.cpu_count();\n"
" #S{-X} #e{cpu_count}#B{=default} cancels overriding; also #e{PYTHON_CPU_COUNT}\n"
"#s{-X} #L{dev} : enable Python Development Mode; also #e{PYTHONDEVMODE}\n"
"#s{-X} #L{disable-remote-debug}: disable remote debugging; also #e{PYTHON_DISABLE_REMOTE_DEBUG}\n"
"#s{-X} #L{faulthandler}: dump the Python traceback on fatal errors;\n"
" also #e{PYTHONFAULTHANDLER}\n"
"#s{-X} #L{frozen_modules}#b{=[on|off]}: whether to use frozen modules; the default is \"#B{on}\"\n"
" for installed Python and \"#B{off}\" for a local build;\n"
" also #e{PYTHON_FROZEN_MODULES}\n"
#ifdef Py_GIL_DISABLED
"#s{-X} #L{gil}#b{=[0|1]}: enable (#B{1}) or disable (#B{0}) the GIL; also #e{PYTHON_GIL}\n"
#endif
"#s{-X} #L{importtime}#b{[=2]}: show how long each import takes; use #S{-X} #e{importtime}#B{=2} to\n"
" log imports of already-loaded modules; also #e{PYTHONPROFILEIMPORTTIME}\n"
"#s{-X} #L{int_max_str_digits}#b{=N}: limit the size of int<->str conversions;\n"
" 0 disables the limit; also #e{PYTHONINTMAXSTRDIGITS}\n"
"#s{-X} #L{lazy_imports}#b{=[all|normal]}: control global lazy imports;\n"
" default is #B{normal}; also #e{PYTHON_LAZY_IMPORTS}\n"
"#s{-X} #L{no_debug_ranges}: don't include extra location information in code objects;\n"
" also #e{PYTHONNODEBUGRANGES}\n"
"#s{-X} #L{pathconfig_warnings}#b{=[0|1]}: if true (#B{1}) then path configuration is allowed\n"
" to log warnings into stderr; if false (#B{0}) suppress these warnings;\n"
" set to true by default; also #e{PYTHON_PATHCONFIG_WARNINGS}\n"
"#s{-X} #L{perf}: support the Linux \"perf\" profiler; also #e{PYTHONPERFSUPPORT}#B{=1}\n"
"#s{-X} #L{perf_jit}: support the Linux \"perf\" profiler with DWARF support;\n"
" also #e{PYTHON_PERF_JIT_SUPPORT}#B{=1}\n"
#ifdef Py_DEBUG
"#s{-X} #L{presite}#b{=MOD}: import this module before site; also #e{PYTHON_PRESITE}\n"
#endif
"#s{-X} #L{pycache_prefix}#b{=PATH}: write .pyc files to a parallel tree instead of to the\n"
" code tree; also #e{PYTHONPYCACHEPREFIX}\n"
#ifdef Py_STATS
"#s{-X} #L{pystats}: enable pystats collection at startup; also #e{PYTHONSTATS}\n"
#endif
"#s{-X} #L{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"
"#s{-X} #L{thread_inherit_context}#b{=[0|1]}: enable (#B{1}) or disable (#B{0}) threads inheriting\n"
" context vars by default; enabled by default in the free-threaded\n"
" build and disabled otherwise; also #e{PYTHON_THREAD_INHERIT_CONTEXT}\n"
#ifdef Py_GIL_DISABLED
"#s{-X} #L{tlbc}#b{=[0|1]}: enable (#B{1}) or disable (#B{0}) thread-local bytecode. Also\n"
" #e{PYTHON_TLBC}\n"
#endif
"#s{-X} #L{tracemalloc}#b{[=N]}: trace Python memory allocations; N sets a traceback limit\n"
" of #B{N} frames (default: #B{1}); also #e{PYTHONTRACEMALLOC}#B{=N}\n"
"#s{-X} #L{utf8}#b{[=0|1]}: enable (#B{1}) or disable (#B{0}) UTF-8 mode; also #e{PYTHONUTF8}\n"
"#s{-X} #L{warn_default_encoding}: enable opt-in EncodingWarning for 'encoding=None';\n"
" also #e{PYTHONWARNDEFAULTENCODING}\n"
;
/* Envvars that don't have equivalent command-line options are listed first */
static const char usage_envvars[] =
"#h{Environment variables that change behavior:}\n"
"#E{PYTHONASYNCIODEBUG}: enable asyncio debug mode\n"
"#E{PYTHON_BASIC_REPL}: use the traditional parser-based REPL\n"
"#E{PYTHONBREAKPOINT}: if this variable is set to #B{0}, it disables the default\n"
" debugger. It can be set to the callable of your debugger of\n"
" choice.\n"
"#E{PYTHONCASEOK} : ignore case in 'import' statements (Windows)\n"
"#E{PYTHONCOERCECLOCALE}: if this variable is set to #B{0}, it disables the locale\n"
" coercion behavior. Use #e{PYTHONCOERCECLOCALE}#B{=warn} to request\n"
" display of locale coercion and locale compatibility warnings\n"
" on stderr.\n"
"#E{PYTHON_COLORS} : if this variable is set to #B{1}, the interpreter will colorize\n"
" various kinds of output. Setting it to #B{0} deactivates\n"
" this behavior.\n"
#ifdef Py_TRACE_REFS
"#E{PYTHONDUMPREFS} : dump objects and reference counts still alive after shutdown\n"
"#E{PYTHONDUMPREFSFILE}: dump objects and reference counts to the specified file\n"
#endif
#ifdef __APPLE__
"#E{PYTHONEXECUTABLE}: set sys.argv[0] to this value (macOS only)\n"
#endif
"#E{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"
"#E{PYTHON_HISTORY} : the location of a .python_history file.\n"
"#E{PYTHONHOME} : alternate <prefix> directory (or <prefix>#D<exec_prefix>).\n"
" The default module search path uses #H.\n"
"#E{PYTHONIOENCODING}: encoding[:errors] used for stdin/stdout/stderr\n"
#ifdef MS_WINDOWS
"#E{PYTHONLEGACYWINDOWSFSENCODING}: use legacy \"mbcs\" encoding for file system\n"
"#E{PYTHONLEGACYWINDOWSSTDIO}: use legacy Windows stdio\n"
#endif
"#E{PYTHONMALLOC} : set the Python memory allocators and/or install debug hooks\n"
" on Python memory allocators. Use #e{PYTHONMALLOC}#B{=debug} to\n"
" install debug hooks.\n"
"#E{PYTHONMALLOCSTATS}: print memory allocator statistics\n"
"#E{PYTHONPATH} : '#D'-separated list of directories prefixed to the\n"
" default module search path. The result is sys.path.\n"
"#E{PYTHONPLATLIBDIR}: override sys.platlibdir\n"
"#E{PYTHONSTARTUP} : file executed on interactive startup (no default)\n"
"#E{PYTHONUSERBASE} : defines the user base directory (site.USER_BASE)\n"
"\n"
"#h{These variables have equivalent command-line options (see }#e{--help} for details):\n"
"#E{PYTHON_CONTEXT_AWARE_WARNINGS}: if true (#B{1}), enable thread-safe warnings\n"
" module behaviour (#S{-X} #e{context_aware_warnings})\n"
"#E{PYTHON_CPU_COUNT}: override the return value of os.cpu_count() (#S{-X} #e{cpu_count})\n"
"#E{PYTHONDEBUG} : enable parser debug mode (#S{-d})\n"
"#E{PYTHONDEVMODE} : enable Python Development Mode (#S{-X} #e{dev})\n"
"#E{PYTHONDONTWRITEBYTECODE}: don't write .pyc files (#S{-B})\n"
"#E{PYTHONFAULTHANDLER}: dump the Python traceback on fatal errors (#S{-X} #e{faulthandler})\n"
"#E{PYTHON_FROZEN_MODULES}: whether to use frozen modules; the default is \"#B{on}\"\n"
" for installed Python and \"#B{off}\" for a local build\n"
" (#S{-X} #e{frozen_modules})\n"
#ifdef Py_GIL_DISABLED
"#E{PYTHON_GIL} : when set to #B{0}, disables the GIL (#S{-X} #e{gil})\n"
#endif
"#E{PYTHONINSPECT} : inspect interactively after running script (#S{-i})\n"
"#E{PYTHONINTMAXSTRDIGITS}: limit the size of int<->str conversions;\n"
" 0 disables the limit (#S{-X} #e{int_max_str_digits}#B{=N})\n"
"#E{PYTHON_LAZY_IMPORTS}: control global lazy imports (#S{-X} #e{lazy_imports})\n"
"#E{PYTHONNODEBUGRANGES}: don't include extra location information in code objects\n"
" (#S{-X} #e{no_debug_ranges})\n"
"#E{PYTHONNOUSERSITE}: disable user site directory (#S{-s})\n"
"#E{PYTHONOPTIMIZE} : enable level 1 optimizations (#S{-O})\n"
"#E{PYTHON_PERF_JIT_SUPPORT}: enable Linux \"perf\" profiler support with JIT\n"
" (#S{-X} #e{perf_jit})\n"
"#E{PYTHONPERFSUPPORT}: support the Linux \"perf\" profiler (#S{-X} #e{perf})\n"
#ifdef Py_DEBUG
"#E{PYTHON_PRESITE}: import this module before site (#S{-X} #e{presite})\n"
#endif
"#E{PYTHONPROFILEIMPORTTIME}: show how long each import takes (#S{-X} #e{importtime})\n"
"#E{PYTHONPYCACHEPREFIX}: root directory for bytecode cache (pyc) files\n"
" (#S{-X} #e{pycache_prefix})\n"
"#E{PYTHONSAFEPATH} : don't prepend a potentially unsafe path to sys.path.\n"
#ifdef Py_STATS
"#E{PYTHONSTATS} : turns on statistics gathering (#S{-X} #e{pystats})\n"
#endif
"#E{PYTHON_THREAD_INHERIT_CONTEXT}: if true (#B{1}), threads inherit context vars\n"
" (#S{-X} #e{thread_inherit_context})\n"
#ifdef Py_GIL_DISABLED
"#E{PYTHON_TLBC} : when set to #B{0}, disables thread-local bytecode (#S{-X} #e{tlbc})\n"
#endif
"#E{PYTHONTRACEMALLOC}: trace Python memory allocations (#S{-X} #e{tracemalloc})\n"
"#E{PYTHONUNBUFFERED}: disable stdout/stderr buffering (#S{-u})\n"
"#E{PYTHONUTF8} : control the UTF-8 mode (#S{-X} #e{utf8})\n"
"#E{PYTHONVERBOSE} : trace import statements (#S{-v})\n"
"#E{PYTHONWARNDEFAULTENCODING}: enable opt-in EncodingWarning for 'encoding=None'\n"
" (#S{-X} #e{warn_default_encoding})\n"
"#E{PYTHONWARNINGS} : warning control (#S{-W})\n"
;
/* --- Global configuration variables ----------------------------- */
// Variable removed from Python limited C API 3.16, but kept in the stable ABI
PyAPI_DATA(int) Py_UTF8Mode;
/* UTF-8 mode (PEP 540): if equal to 1, use the UTF-8 encoding, and change
stdin and stdout error handler to "surrogateescape". */
int Py_UTF8Mode = 0;
static PyObject *
_Py_GetGlobalVariablesAsDict(void)
{
extern const char *Py_FileSystemDefaultEncoding;
extern const char *Py_FileSystemDefaultEncodeErrors;
extern int Py_HasFileSystemDefaultEncoding;
extern int _Py_HasFileSystemDefaultEncodeErrors;
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(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);
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)
{
int use_environment = 1;
PyThreadState *tstate = PyThreadState_GetUnchecked();
if (tstate != NULL) {
const PyConfig *config = &tstate->interp->config;
use_environment = config->use_environment;
}
if (!use_environment) {
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); }
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->pymalloc_hugepages >= 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);
#ifdef MS_WINDOWS
/* stdio_encoding can be NULL in the legacy Windows stdio mode. */
assert(config->stdio_encoding != NULL || config->legacy_windows_stdio);
assert(config->legacy_windows_stdio >= 0);
#else
assert(config->stdio_encoding != NULL);
#endif
assert(config->stdio_errors != NULL);
/* -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);
// lazy_imports can be -1 (default) or 1 (on). 0 is rejected later
// for embedders with an error message.
assert(config->lazy_imports >= -1 && config->lazy_imports <= 1);
// config->use_frozen_modules is initialized later
// by _PyConfig_InitImportConfig().
assert(config->thread_inherit_context >= 0);
assert(config->context_aware_warnings >= 0);
#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->import_time = -1;
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->remote_debug = -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;
#ifdef MS_WINDOWS
config->legacy_windows_stdio = -1;
#endif
#ifdef Py_DEBUG
config->use_frozen_modules = 0;
#else
config->use_frozen_modules = 1;
#endif
config->safe_path = 0;
config->int_max_str_digits = -1;
config->_is_python_build = 0;
config->code_debug_ranges = 1;
config->cpu_count = -1;
config->lazy_imports = -1;
#ifdef Py_GIL_DISABLED
config->thread_inherit_context = 1;
config->context_aware_warnings = 1;
#else
config->thread_inherit_context = 0;
config->context_aware_warnings = 0;
#endif
#ifdef __APPLE__
config->use_system_logger = USE_SYSTEM_LOGGER_DEFAULT;
#endif
#ifdef Py_GIL_DISABLED
config->enable_gil = _PyConfig_GIL_DEFAULT;
config->tlbc_enabled = 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
#ifdef Py_GIL_DISABLED
config->thread_inherit_context = 1;
config->context_aware_warnings = 1;
#else
config->thread_inherit_context = 0;
config->context_aware_warnings = 0;
#endif
#ifdef __APPLE__
config->use_system_logger = USE_SYSTEM_LOGGER_DEFAULT;
#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->tracemalloc = 0;
config->perf_profiling = 0;
config->int_max_str_digits = _PY_LONG_DEFAULT_MAX_STR_DIGITS;
config->safe_path = 1;
config->pathconfig_warnings = 0;
#ifdef Py_GIL_DISABLED
config->thread_inherit_context = 1;
#else
config->thread_inherit_context = 0;
#endif
#ifdef MS_WINDOWS
config->legacy_windows_stdio = 0;
#endif
#ifdef __APPLE__
config->use_system_logger = USE_SYSTEM_LOGGER_DEFAULT;
#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");
}
static inline void*
config_get_spec_member(const PyConfig *config, const PyConfigSpec *spec)
{
return (char *)config + spec->offset;
}
static inline void*
preconfig_get_spec_member(const PyPreConfig *preconfig, const PyConfigSpec *spec)
{
return (char *)preconfig + spec->offset;
}
PyStatus
_PyConfig_Copy(PyConfig *config, const PyConfig *config2)
{
PyConfig_Clear(config);
PyStatus status;
const PyConfigSpec *spec = PYCONFIG_SPEC;
for (; spec->name != NULL; spec++) {
void *member = config_get_spec_member(config, spec);
const void *member2 = config_get_spec_member((PyConfig*)config2, spec);
switch (spec->type) {
case PyConfig_MEMBER_INT:
case PyConfig_MEMBER_UINT:
case PyConfig_MEMBER_BOOL:
{
*(int*)member = *(int*)member2;
break;
}
case PyConfig_MEMBER_ULONG:
{
*(unsigned long*)member = *(unsigned long*)member2;
break;
}
case PyConfig_MEMBER_WSTR:
case PyConfig_MEMBER_WSTR_OPT:
{
const wchar_t *str = *(const wchar_t**)member2;
status = PyConfig_SetString(config, (wchar_t**)member, str);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
break;
}
case PyConfig_MEMBER_WSTR_LIST:
{
if (_PyWideStringList_Copy((PyWideStringList*)member,
(const PyWideStringList*)member2) < 0) {
return _PyStatus_NO_MEMORY();
}
break;
}
default:
Py_UNREACHABLE();
}
}
return _PyStatus_OK();
}
PyObject *
_PyConfig_AsDict(const PyConfig *config)
{
PyObject *dict = PyDict_New();
if (dict == NULL) {
return NULL;
}
const PyConfigSpec *spec = PYCONFIG_SPEC;
for (; spec->name != NULL; spec++) {
PyObject *obj = config_get(config, spec, 0);
if (obj == NULL) {
Py_DECREF(dict);
return NULL;
}
int res = PyDict_SetItemString(dict, spec->name, obj);
Py_DECREF(obj);
if (res < 0) {
Py_DECREF(dict);
return NULL;
}
}
return dict;
}
static void
config_dict_invalid_value(const char *name)
{
PyErr_Format(PyExc_ValueError, "invalid config value: %s", name);
}
static int
config_dict_get_int(PyObject *dict, const char *name, int *result)
{
PyObject *item = config_dict_get(dict, name);
if (item == NULL) {
return -1;
}
int value = PyLong_AsInt(item);
Py_DECREF(item);
if (value == -1 && PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_TypeError)) {
config_dict_invalid_type(name);
}
else if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
config_dict_invalid_value(name);
}
return -1;
}
*result = value;
return 0;
}
static int
config_dict_get_ulong(PyObject *dict, const char *name, unsigned long *result)
{
PyObject *item = config_dict_get(dict, name);
if (item == NULL) {
return -1;
}
unsigned long value = PyLong_AsUnsignedLong(item);
Py_DECREF(item);
if (value == (unsigned long)-1 && PyErr_Occurred()) {
if (PyErr_ExceptionMatches(PyExc_TypeError)) {
config_dict_invalid_type(name);
}
else if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
config_dict_invalid_value(name);
}
return -1;
}
*result = value;
return 0;
}
static int
config_dict_get_wstr(PyObject *dict, const char *name, PyConfig *config,
wchar_t **result)
{
PyObject *item = config_dict_get(dict, name);
if (item == NULL) {
return -1;
}
PyStatus status;
if (item == Py_None) {
status = PyConfig_SetString(config, result, NULL);
}
else if (!PyUnicode_Check(item)) {
config_dict_invalid_type(name);
goto error;
}
else {
wchar_t *wstr = PyUnicode_AsWideCharString(item, NULL);
if (wstr == NULL) {
goto error;
}
status = PyConfig_SetString(config, result, wstr);
PyMem_Free(wstr);
}
if (_PyStatus_EXCEPTION(status)) {
PyErr_NoMemory();
goto error;
}
Py_DECREF(item);
return 0;
error:
Py_DECREF(item);
return -1;
}
static int
config_dict_get_wstrlist(PyObject *dict, const char *name, PyConfig *config,
PyWideStringList *result)
{
PyObject *list = config_dict_get(dict, name);
if (list == NULL) {
return -1;
}
int is_list = PyList_CheckExact(list);
if (!is_list && !PyTuple_CheckExact(list)) {
Py_DECREF(list);
config_dict_invalid_type(name);
return -1;
}
PyWideStringList wstrlist = _PyWideStringList_INIT;
Py_ssize_t len = is_list ? PyList_GET_SIZE(list) : PyTuple_GET_SIZE(list);
for (Py_ssize_t i=0; i < len; i++) {
PyObject *item = is_list ? PyList_GET_ITEM(list, i) : PyTuple_GET_ITEM(list, i);
if (item == Py_None) {
config_dict_invalid_value(name);
goto error;
}
else if (!PyUnicode_Check(item)) {
config_dict_invalid_type(name);
goto error;
}
wchar_t *wstr = PyUnicode_AsWideCharString(item, NULL);
if (wstr == NULL) {
goto error;
}
PyStatus status = PyWideStringList_Append(&wstrlist, wstr);
PyMem_Free(wstr);
if (_PyStatus_EXCEPTION(status)) {
PyErr_NoMemory();
goto error;
}
}
if (_PyWideStringList_Copy(result, &wstrlist) < 0) {
PyErr_NoMemory();
goto error;
}
_PyWideStringList_Clear(&wstrlist);
Py_DECREF(list);
return 0;
error:
_PyWideStringList_Clear(&wstrlist);
Py_DECREF(list);
return -1;
}
static int
config_dict_get_xoptions(PyObject *dict, const char *name, PyConfig *config,
PyWideStringList *result)
{
PyObject *xoptions = config_dict_get(dict, name);
if (xoptions == NULL) {
return -1;
}
if (!PyDict_CheckExact(xoptions)) {
Py_DECREF(xoptions);
config_dict_invalid_type(name);
return -1;
}
Py_ssize_t pos = 0;
PyObject *key, *value;
PyWideStringList wstrlist = _PyWideStringList_INIT;
while (PyDict_Next(xoptions, &pos, &key, &value)) {
PyObject *item;
if (value != Py_True) {
item = PyUnicode_FromFormat("%S=%S", key, value);
if (item == NULL) {
goto error;
}
}
else {
item = Py_NewRef(key);
}
wchar_t *wstr = PyUnicode_AsWideCharString(item, NULL);
Py_DECREF(item);
if (wstr == NULL) {
goto error;
}
PyStatus status = PyWideStringList_Append(&wstrlist, wstr);
PyMem_Free(wstr);
if (_PyStatus_EXCEPTION(status)) {
PyErr_NoMemory();
goto error;
}
}
if (_PyWideStringList_Copy(result, &wstrlist) < 0) {
PyErr_NoMemory();
goto error;
}
_PyWideStringList_Clear(&wstrlist);
Py_DECREF(xoptions);
return 0;
error:
_PyWideStringList_Clear(&wstrlist);
Py_DECREF(xoptions);
return -1;
}
int
_PyConfig_FromDict(PyConfig *config, PyObject *dict)
{
if (!PyDict_Check(dict)) {
PyErr_SetString(PyExc_TypeError, "dict expected");
return -1;
}
const PyConfigSpec *spec = PYCONFIG_SPEC;
for (; spec->name != NULL; spec++) {
char *member = (char *)config + spec->offset;
switch (spec->type) {
case PyConfig_MEMBER_INT:
case PyConfig_MEMBER_UINT:
case PyConfig_MEMBER_BOOL:
{
int value;
if (config_dict_get_int(dict, spec->name, &value) < 0) {
return -1;
}
if (spec->type == PyConfig_MEMBER_BOOL
|| spec->type == PyConfig_MEMBER_UINT)
{
if (value < 0) {
config_dict_invalid_value(spec->name);
return -1;
}
}
*(int*)member = value;
break;
}
case PyConfig_MEMBER_ULONG:
{
if (config_dict_get_ulong(dict, spec->name,
(unsigned long*)member) < 0) {
return -1;
}
break;
}
case PyConfig_MEMBER_WSTR:
{
wchar_t **wstr = (wchar_t**)member;
if (config_dict_get_wstr(dict, spec->name, config, wstr) < 0) {
return -1;
}
if (*wstr == NULL) {
config_dict_invalid_value(spec->name);
return -1;
}
break;
}
case PyConfig_MEMBER_WSTR_OPT:
{
wchar_t **wstr = (wchar_t**)member;
if (config_dict_get_wstr(dict, spec->name, config, wstr) < 0) {
return -1;
}
break;
}
case PyConfig_MEMBER_WSTR_LIST:
{
if (strcmp(spec->name, "xoptions") == 0) {
if (config_dict_get_xoptions(dict, spec->name, config,
(PyWideStringList*)member) < 0) {
return -1;
}
}
else {
if (config_dict_get_wstrlist(dict, spec->name, config,
(PyWideStringList*)member) < 0) {
return -1;
}
}
break;
}
default:
Py_UNREACHABLE();
}
}
if (!(config->_config_init == _PyConfig_INIT_COMPAT
|| config->_config_init == _PyConfig_INIT_PYTHON
|| config->_config_init == _PyConfig_INIT_ISOLATED))
{
config_dict_invalid_value("_config_init");
return -1;
}
if (config->hash_seed > MAX_HASH_SEED) {
config_dict_invalid_value("hash_seed");
return -1;
}
return 0;
}
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
config_get_env_dup(PyConfig *config,
wchar_t **dest,
wchar_t *wname, char *name,
const char *decode_err_msg)
{
assert(*dest == NULL);
assert(config->use_environment >= 0);
if (!config->use_environment) {
*dest = NULL;
return _PyStatus_OK();
}
#ifdef MS_WINDOWS
const wchar_t *var = _wgetenv(wname);
if (!var || var[0] == '\0') {
*dest = NULL;
return _PyStatus_OK();
}
return PyConfig_SetString(config, dest, var);
#else
const char *var = getenv(name);
if (!var || var[0] == '\0') {
*dest = NULL;
return _PyStatus_OK();
}
return config_set_bytes_string(config, dest, var, decode_err_msg);
#endif
}
#define CONFIG_GET_ENV_DUP(CONFIG, DEST, WNAME, NAME) \
config_get_env_dup(CONFIG, DEST, WNAME, NAME, "cannot decode " NAME)
static void
config_read_preconfig(PyConfig *config)
{
#define COPY_FLAG(ATTR) \
if (config->ATTR == -1) { \
config->ATTR = preconfig->ATTR; \
}
const PyPreConfig *preconfig = &_PyRuntime.preconfig;
COPY_FLAG(isolated);
COPY_FLAG(use_environment);
COPY_FLAG(dev_mode);
#undef COPY_FLAG
}
static const wchar_t*
config_get_xoption(const PyConfig *config, wchar_t *name)
{
return _Py_get_xoption(&config->xoptions, name);
}
static const wchar_t*
config_get_xoption_value(const PyConfig *config, wchar_t *name)
{
const wchar_t *xoption = config_get_xoption(config, name);
if (xoption == NULL) {
return NULL;
}
const wchar_t *sep = wcschr(xoption, L'=');
return sep ? sep + 1 : L"";
}
static PyStatus
config_init_hash_seed(PyConfig *config)
{
static_assert(sizeof(_Py_HashSecret_t) == sizeof(_Py_HashSecret.uc),
"_Py_HashSecret_t has wrong size");
const char *seed_text = config_get_env(config, "PYTHONHASHSEED");
/* Convert a text seed to a numeric one */
if (seed_text && strcmp(seed_text, "random") != 0) {
const char *endptr = seed_text;
unsigned long seed;
errno = 0;
seed = strtoul(seed_text, (char **)&endptr, 10);
if (*endptr != '\0'
|| seed > MAX_HASH_SEED
|| (errno == ERANGE && seed == ULONG_MAX))
{
return _PyStatus_ERR("PYTHONHASHSEED must be \"random\" "
"or an integer in range [0; 4294967295]");
}
/* Use a specific hash */
config->use_hash_seed = 1;
config->hash_seed = seed;
}
else {
/* Use a random hash */
config->use_hash_seed = 0;
config->hash_seed = 0;
}
return _PyStatus_OK();
}
static int
config_wstr_to_int(const wchar_t *wstr, int *result)
{
const wchar_t *endptr = wstr;
errno = 0;
long value = wcstol(wstr, (wchar_t **)&endptr, 10);
if (*endptr != '\0' || errno == ERANGE) {
return -1;
}
if (value < INT_MIN || value > INT_MAX) {
return -1;
}
*result = (int)value;
return 0;
}
static PyStatus
config_read_gil(PyConfig *config, size_t len, wchar_t first_char)
{
if (len == 1 && first_char == L'0') {
#ifdef Py_GIL_DISABLED
config->enable_gil = _PyConfig_GIL_DISABLE;
#else
return _PyStatus_ERR("Disabling the GIL is not supported by this build");
#endif
}
else if (len == 1 && first_char == L'1') {
#ifdef Py_GIL_DISABLED
config->enable_gil = _PyConfig_GIL_ENABLE;
#else
return _PyStatus_OK();
#endif
}
else {
return _PyStatus_ERR("PYTHON_GIL / -X gil must be \"0\" or \"1\"");
}
return _PyStatus_OK();
}
static PyStatus
config_read_env_vars(PyConfig *config)
{
PyStatus status;
int use_env = config->use_environment;
/* Get environment variables */
_Py_get_env_flag(use_env, &config->parser_debug, "PYTHONDEBUG");
_Py_get_env_flag(use_env, &config->verbose, "PYTHONVERBOSE");
_Py_get_env_flag(use_env, &config->optimization_level, "PYTHONOPTIMIZE");
if (!config->inspect && _Py_GetEnv(use_env, "PYTHONINSPECT")) {
config->inspect = 1;
}
int dont_write_bytecode = 0;
_Py_get_env_flag(use_env, &dont_write_bytecode, "PYTHONDONTWRITEBYTECODE");
if (dont_write_bytecode) {
config->write_bytecode = 0;
}
int no_user_site_directory = 0;
_Py_get_env_flag(use_env, &no_user_site_directory, "PYTHONNOUSERSITE");
if (no_user_site_directory) {
config->user_site_directory = 0;
}
int unbuffered_stdio = 0;
_Py_get_env_flag(use_env, &unbuffered_stdio, "PYTHONUNBUFFERED");
if (unbuffered_stdio) {
config->buffered_stdio = 0;
}
#ifdef MS_WINDOWS
_Py_get_env_flag(use_env, &config->legacy_windows_stdio,
"PYTHONLEGACYWINDOWSSTDIO");
#endif
if (config_get_env(config, "PYTHONDUMPREFS")) {
config->dump_refs = 1;
}
if (config_get_env(config, "PYTHONMALLOCSTATS")) {
config->malloc_stats = 1;
}
{
const char *env = _Py_GetEnv(use_env, "PYTHON_PYMALLOC_HUGEPAGES");
if (env) {
int value;
if (_Py_str_to_int(env, &value) < 0 || value < 0) {
/* PYTHON_PYMALLOC_HUGEPAGES=text or negative
behaves as PYTHON_PYMALLOC_HUGEPAGES=1 */
value = 1;
}
config->pymalloc_hugepages = (value > 0);
}
}
if (config->dump_refs_file == NULL) {
status = CONFIG_GET_ENV_DUP(config, &config->dump_refs_file,
L"PYTHONDUMPREFSFILE", "PYTHONDUMPREFSFILE");
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->pythonpath_env == NULL) {
status = CONFIG_GET_ENV_DUP(config, &config->pythonpath_env,
L"PYTHONPATH", "PYTHONPATH");
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if(config->platlibdir == NULL) {
status = CONFIG_GET_ENV_DUP(config, &config->platlibdir,
L"PYTHONPLATLIBDIR", "PYTHONPLATLIBDIR");
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->use_hash_seed < 0) {
status = config_init_hash_seed(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config_get_env(config, "PYTHONSAFEPATH")) {
config->safe_path = 1;
}
const char *gil = config_get_env(config, "PYTHON_GIL");
if (gil != NULL) {
size_t len = strlen(gil);
status = config_read_gil(config, len, gil[0]);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
return _PyStatus_OK();
}
static PyStatus
config_init_cpu_count(PyConfig *config)
{
const char *env = config_get_env(config, "PYTHON_CPU_COUNT");
if (env) {
int cpu_count = -1;
if (strcmp(env, "default") == 0) {
cpu_count = -1;
}
else if (_Py_str_to_int(env, &cpu_count) < 0 || cpu_count < 1) {
goto error;
}
config->cpu_count = cpu_count;
}
const wchar_t *xoption = config_get_xoption(config, L"cpu_count");
if (xoption) {
int cpu_count = -1;
const wchar_t *sep = wcschr(xoption, L'=');
if (sep) {
if (wcscmp(sep + 1, L"default") == 0) {
cpu_count = -1;
}
else if (config_wstr_to_int(sep + 1, &cpu_count) < 0 || cpu_count < 1) {
goto error;
}
}
else {
goto error;
}
config->cpu_count = cpu_count;
}
return _PyStatus_OK();
error:
return _PyStatus_ERR("-X cpu_count=n option: n is missing or an invalid number, "
"n must be greater than 0");
}
static PyStatus
config_init_thread_inherit_context(PyConfig *config)
{
const char *env = config_get_env(config, "PYTHON_THREAD_INHERIT_CONTEXT");
if (env) {
int enabled;
if (_Py_str_to_int(env, &enabled) < 0 || (enabled < 0) || (enabled > 1)) {
return _PyStatus_ERR(
"PYTHON_THREAD_INHERIT_CONTEXT=N: N is missing or invalid");
}
config->thread_inherit_context = enabled;
}
const wchar_t *xoption = config_get_xoption(config, L"thread_inherit_context");
if (xoption) {
int enabled;
const wchar_t *sep = wcschr(xoption, L'=');
if (!sep || (config_wstr_to_int(sep + 1, &enabled) < 0) || (enabled < 0) || (enabled > 1)) {
return _PyStatus_ERR(
"-X thread_inherit_context=n: n is missing or invalid");
}
config->thread_inherit_context = enabled;
}
return _PyStatus_OK();
}
static PyStatus
config_init_context_aware_warnings(PyConfig *config)
{
const char *env = config_get_env(config, "PYTHON_CONTEXT_AWARE_WARNINGS");
if (env) {
int enabled;
if (_Py_str_to_int(env, &enabled) < 0 || (enabled < 0) || (enabled > 1)) {
return _PyStatus_ERR(
"PYTHON_CONTEXT_AWARE_WARNINGS=N: N is missing or invalid");
}
config->context_aware_warnings = enabled;
}
const wchar_t *xoption = config_get_xoption(config, L"context_aware_warnings");
if (xoption) {
int enabled;
const wchar_t *sep = wcschr(xoption, L'=');
if (!sep || (config_wstr_to_int(sep + 1, &enabled) < 0) || (enabled < 0) || (enabled > 1)) {
return _PyStatus_ERR(
"-X context_aware_warnings=n: n is missing or invalid");
}
config->context_aware_warnings = enabled;
}
return _PyStatus_OK();
}
static PyStatus
config_init_tlbc(PyConfig *config)
{
#ifdef Py_GIL_DISABLED
const char *env = config_get_env(config, "PYTHON_TLBC");
if (env) {
int enabled;
if (_Py_str_to_int(env, &enabled) < 0 || (enabled < 0) || (enabled > 1)) {
return _PyStatus_ERR(
"PYTHON_TLBC=N: N is missing or invalid");
}
config->tlbc_enabled = enabled;
}
const wchar_t *xoption = config_get_xoption(config, L"tlbc");
if (xoption) {
int enabled;
const wchar_t *sep = wcschr(xoption, L'=');
if (!sep || (config_wstr_to_int(sep + 1, &enabled) < 0) || (enabled < 0) || (enabled > 1)) {
return _PyStatus_ERR(
"-X tlbc=n: n is missing or invalid");
}
config->tlbc_enabled = enabled;
}
return _PyStatus_OK();
#else
return _PyStatus_OK();
#endif
}
static PyStatus
config_init_perf_profiling(PyConfig *config)
{
int active = 0;
const char *env = config_get_env(config, "PYTHONPERFSUPPORT");
if (env) {
if (_Py_str_to_int(env, &active) != 0) {
active = 0;
}
if (active) {
config->perf_profiling = 1;
}
}
const wchar_t *xoption = config_get_xoption(config, L"perf");
if (xoption) {
config->perf_profiling = 1;
}
env = config_get_env(config, "PYTHON_PERF_JIT_SUPPORT");
if (env) {
if (_Py_str_to_int(env, &active) != 0) {
active = 0;
}
if (active) {
config->perf_profiling = 2;
}
}
xoption = config_get_xoption(config, L"perf_jit");
if (xoption) {
config->perf_profiling = 2;
}
return _PyStatus_OK();
}
static PyStatus
config_init_remote_debug(PyConfig *config)
{
#ifndef Py_REMOTE_DEBUG
config->remote_debug = 0;
#else
int active = 1;
const char *env = Py_GETENV("PYTHON_DISABLE_REMOTE_DEBUG");
if (env) {
active = 0;
}
const wchar_t *xoption = config_get_xoption(config, L"disable-remote-debug");
if (xoption) {
active = 0;
}
config->remote_debug = active;
#endif
return _PyStatus_OK();
}
static PyStatus
config_init_tracemalloc(PyConfig *config)
{
int nframe;
int valid;
const char *env = config_get_env(config, "PYTHONTRACEMALLOC");
if (env) {
if (!_Py_str_to_int(env, &nframe)) {
valid = (nframe >= 0);
}
else {
valid = 0;
}
if (!valid) {
return _PyStatus_ERR("PYTHONTRACEMALLOC: invalid number of frames");
}
config->tracemalloc = nframe;
}
const wchar_t *xoption = config_get_xoption(config, L"tracemalloc");
if (xoption) {
const wchar_t *sep = wcschr(xoption, L'=');
if (sep) {
if (!config_wstr_to_int(sep + 1, &nframe)) {
valid = (nframe >= 0);
}
else {
valid = 0;
}
if (!valid) {
return _PyStatus_ERR("-X tracemalloc=NFRAME: "
"invalid number of frames");
}
}
else {
/* -X tracemalloc behaves as -X tracemalloc=1 */
nframe = 1;
}
config->tracemalloc = nframe;
}
return _PyStatus_OK();
}
static PyStatus
config_init_int_max_str_digits(PyConfig *config)
{
int maxdigits;
const char *env = config_get_env(config, "PYTHONINTMAXSTRDIGITS");
if (env) {
bool valid = 0;
if (!_Py_str_to_int(env, &maxdigits)) {
valid = ((maxdigits == 0) || (maxdigits >= _PY_LONG_MAX_STR_DIGITS_THRESHOLD));
}
if (!valid) {
#define STRINGIFY(VAL) _STRINGIFY(VAL)
#define _STRINGIFY(VAL) #VAL
return _PyStatus_ERR(
"PYTHONINTMAXSTRDIGITS: invalid limit; must be >= "
STRINGIFY(_PY_LONG_MAX_STR_DIGITS_THRESHOLD)
" or 0 for unlimited.");
}
config->int_max_str_digits = maxdigits;
}
const wchar_t *xoption = config_get_xoption(config, L"int_max_str_digits");
if (xoption) {
const wchar_t *sep = wcschr(xoption, L'=');
bool valid = 0;
if (sep) {
if (!config_wstr_to_int(sep + 1, &maxdigits)) {
valid = ((maxdigits == 0) || (maxdigits >= _PY_LONG_MAX_STR_DIGITS_THRESHOLD));
}
}
if (!valid) {
return _PyStatus_ERR(
"-X int_max_str_digits: invalid limit; must be >= "
STRINGIFY(_PY_LONG_MAX_STR_DIGITS_THRESHOLD)
" or 0 for unlimited.");
#undef _STRINGIFY
#undef STRINGIFY
}
config->int_max_str_digits = maxdigits;
}
if (config->int_max_str_digits < 0) {
config->int_max_str_digits = _PY_LONG_DEFAULT_MAX_STR_DIGITS;
}
return _PyStatus_OK();
}
static PyStatus
config_init_pycache_prefix(PyConfig *config)
{
assert(config->pycache_prefix == NULL);
const wchar_t *xoption = config_get_xoption(config, L"pycache_prefix");
if (xoption) {
const wchar_t *sep = wcschr(xoption, L'=');
if (sep && wcslen(sep) > 1) {
config->pycache_prefix = _PyMem_RawWcsdup(sep + 1);
if (config->pycache_prefix == NULL) {
return _PyStatus_NO_MEMORY();
}
}
else {
// PYTHONPYCACHEPREFIX env var ignored
// if "-X pycache_prefix=" option is used
config->pycache_prefix = NULL;
}
return _PyStatus_OK();
}
return CONFIG_GET_ENV_DUP(config, &config->pycache_prefix,
L"PYTHONPYCACHEPREFIX",
"PYTHONPYCACHEPREFIX");
}
#ifdef Py_DEBUG
static PyStatus
config_init_run_presite(PyConfig *config)
{
assert(config->run_presite == NULL);
const wchar_t *xoption = config_get_xoption(config, L"presite");
if (xoption) {
const wchar_t *sep = wcschr(xoption, L'=');
if (sep && wcslen(sep) > 1) {
config->run_presite = _PyMem_RawWcsdup(sep + 1);
if (config->run_presite == NULL) {
return _PyStatus_NO_MEMORY();
}
}
else {
// PYTHON_PRESITE env var ignored
// if "-X presite=" option is used
config->run_presite = NULL;
}
return _PyStatus_OK();
}
return CONFIG_GET_ENV_DUP(config, &config->run_presite,
L"PYTHON_PRESITE",
"PYTHON_PRESITE");
}
#endif
static PyStatus
config_init_import_time(PyConfig *config)
{
int importtime = 0;
const char *env = config_get_env(config, "PYTHONPROFILEIMPORTTIME");
if (env) {
if (_Py_str_to_int(env, &importtime) != 0) {
importtime = 1;
}
if (importtime < 0 || importtime > 2) {
return _PyStatus_ERR(
"PYTHONPROFILEIMPORTTIME: numeric values other than 1 and 2 "
"are reserved for future use.");
}
}
const wchar_t *x_value = config_get_xoption_value(config, L"importtime");
if (x_value) {
if (*x_value == 0 || config_wstr_to_int(x_value, &importtime) != 0) {
importtime = 1;
}
if (importtime < 0 || importtime > 2) {
return _PyStatus_ERR(
"-X importtime: values other than 1 and 2 "
"are reserved for future use.");
}
}
config->import_time = importtime;
return _PyStatus_OK();
}
static PyStatus
config_init_lazy_imports(PyConfig *config)
{
int lazy_imports = -1;
const char *env = config_get_env(config, "PYTHON_LAZY_IMPORTS");
if (env) {
if (strcmp(env, "all") == 0) {
lazy_imports = 1;
}
else if (strcmp(env, "normal") == 0) {
lazy_imports = -1;
}
else {
return _PyStatus_ERR("PYTHON_LAZY_IMPORTS: invalid value; "
"expected 'all' or 'normal'");
}
config->lazy_imports = lazy_imports;
}
const wchar_t *x_value = config_get_xoption_value(config, L"lazy_imports");
if (x_value) {
if (wcscmp(x_value, L"all") == 0) {
lazy_imports = 1;
}
else if (wcscmp(x_value, L"normal") == 0) {
lazy_imports = -1;
}
else {
return _PyStatus_ERR("-X lazy_imports: invalid value; "
"expected 'all' or 'normal'");
}
config->lazy_imports = lazy_imports;
}
return _PyStatus_OK();
}
static PyStatus
config_init_pathconfig_warnings(PyConfig *config)
{
const char *env = config_get_env(config, "PYTHON_PATHCONFIG_WARNINGS");
if (env) {
int enabled;
if (_Py_str_to_int(env, &enabled) < 0 || (enabled < 0) || (enabled > 1)) {
return _PyStatus_ERR(
"PYTHON_PATHCONFIG_WARNINGS=N: N is missing or invalid");
}
config->pathconfig_warnings = enabled;
}
const wchar_t *xoption = config_get_xoption(config, L"pathconfig_warnings");
if (xoption) {
int enabled;
const wchar_t *sep = wcschr(xoption, L'=');
if (!sep || (config_wstr_to_int(sep + 1, &enabled) < 0) || (enabled < 0) || (enabled > 1)) {
return _PyStatus_ERR(
"-X pathconfig_warnings=n: n is missing or invalid");
}
config->pathconfig_warnings = enabled;
}
return _PyStatus_OK();
}
static PyStatus
config_read_complex_options(PyConfig *config)
{
/* More complex options configured by env var and -X option */
if (config->faulthandler < 0) {
if (config_get_env(config, "PYTHONFAULTHANDLER")
|| config_get_xoption(config, L"faulthandler")) {
config->faulthandler = 1;
}
}
if (config_get_env(config, "PYTHONNODEBUGRANGES")
|| config_get_xoption(config, L"no_debug_ranges")) {
config->code_debug_ranges = 0;
}
PyStatus status;
if (config->import_time < 0) {
status = config_init_import_time(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->lazy_imports < 0) {
status = config_init_lazy_imports(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->tracemalloc < 0) {
status = config_init_tracemalloc(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->perf_profiling < 0) {
status = config_init_perf_profiling(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->remote_debug < 0) {
status = config_init_remote_debug(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->int_max_str_digits < 0) {
status = config_init_int_max_str_digits(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->cpu_count < 0) {
status = config_init_cpu_count(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->pycache_prefix == NULL) {
status = config_init_pycache_prefix(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
#ifdef Py_DEBUG
if (config->run_presite == NULL) {
status = config_init_run_presite(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
#endif
status = config_init_thread_inherit_context(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
status = config_init_context_aware_warnings(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
status = config_init_tlbc(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
status = config_init_pathconfig_warnings(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
return _PyStatus_OK();
}
static const wchar_t *
config_get_stdio_errors(const PyPreConfig *preconfig)
{
if (preconfig->utf8_mode) {
/* UTF-8 Mode uses UTF-8/surrogateescape */
return L"surrogateescape";
}
#ifndef MS_WINDOWS
const char *loc = setlocale(LC_CTYPE, NULL);
if (loc != NULL) {
/* surrogateescape is the default in the legacy C and POSIX locales */
if (strcmp(loc, "C") == 0 || strcmp(loc, "POSIX") == 0) {
return L"surrogateescape";
}
#ifdef PY_COERCE_C_LOCALE
/* surrogateescape is the default in locale coercion target locales */
if (_Py_IsLocaleCoercionTarget(loc)) {
return L"surrogateescape";
}
#endif
}
return L"strict";
#else
/* On Windows, always use surrogateescape by default */
return L"surrogateescape";
#endif
}
// See also config_get_fs_encoding()
static PyStatus
config_get_locale_encoding(PyConfig *config, const PyPreConfig *preconfig,
wchar_t **locale_encoding)
{
wchar_t *encoding;
if (preconfig->utf8_mode) {
encoding = _PyMem_RawWcsdup(L"utf-8");
}
else {
encoding = _Py_GetLocaleEncoding();
}
if (encoding == NULL) {
return _PyStatus_NO_MEMORY();
}
PyStatus status = PyConfig_SetString(config, locale_encoding, encoding);
PyMem_RawFree(encoding);
return status;
}
static PyStatus
config_init_stdio_encoding(PyConfig *config,
const PyPreConfig *preconfig)
{
PyStatus status;
// Exit if encoding and errors are defined
if (config->stdio_encoding != NULL && config->stdio_errors != NULL) {
return _PyStatus_OK();
}
/* PYTHONIOENCODING environment variable */
const char *opt = config_get_env(config, "PYTHONIOENCODING");
if (opt) {
char *pythonioencoding = _PyMem_RawStrdup(opt);
if (pythonioencoding == NULL) {
return _PyStatus_NO_MEMORY();
}
char *errors = strchr(pythonioencoding, ':');
if (errors) {
*errors = '\0';
errors++;
if (!errors[0]) {
errors = NULL;
}
}
/* Does PYTHONIOENCODING contain an encoding? */
if (pythonioencoding[0]) {
if (config->stdio_encoding == NULL) {
status = CONFIG_SET_BYTES_STR(config, &config->stdio_encoding,
pythonioencoding,
"PYTHONIOENCODING environment variable");
if (_PyStatus_EXCEPTION(status)) {
PyMem_RawFree(pythonioencoding);
return status;
}
}
/* If the encoding is set but not the error handler,
use "strict" error handler by default.
PYTHONIOENCODING=latin1 behaves as
PYTHONIOENCODING=latin1:strict. */
if (!errors) {
errors = "strict";
}
}
if (config->stdio_errors == NULL && errors != NULL) {
status = CONFIG_SET_BYTES_STR(config, &config->stdio_errors,
errors,
"PYTHONIOENCODING environment variable");
if (_PyStatus_EXCEPTION(status)) {
PyMem_RawFree(pythonioencoding);
return status;
}
}
PyMem_RawFree(pythonioencoding);
}
/* Choose the default error handler based on the current locale. */
if (config->stdio_encoding == NULL
#ifdef MS_WINDOWS
/* gh-86427: it is determined for each stream: create_stdio() uses
_Py_device_encoding(), falling back to the locale encoding. */
&& !config->legacy_windows_stdio
#endif
) {
status = config_get_locale_encoding(config, preconfig,
&config->stdio_encoding);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->stdio_errors == NULL) {
const wchar_t *errors = config_get_stdio_errors(preconfig);
assert(errors != NULL);
status = PyConfig_SetString(config, &config->stdio_errors, errors);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
return _PyStatus_OK();
}
// See also config_get_locale_encoding()
static PyStatus
config_get_fs_encoding(PyConfig *config, const PyPreConfig *preconfig,
wchar_t **fs_encoding)
{
#ifdef _Py_FORCE_UTF8_FS_ENCODING
return PyConfig_SetString(config, fs_encoding, L"utf-8");
#elif defined(MS_WINDOWS)
const wchar_t *encoding;
if (preconfig->legacy_windows_fs_encoding) {
// Legacy Windows filesystem encoding: mbcs/replace
encoding = L"mbcs";
}
else {
// Windows defaults to utf-8/surrogatepass (PEP 529)
encoding = L"utf-8";
}
return PyConfig_SetString(config, fs_encoding, encoding);
#else // !MS_WINDOWS
if (preconfig->utf8_mode) {
return PyConfig_SetString(config, fs_encoding, L"utf-8");
}
if (_Py_GetForceASCII()) {
return PyConfig_SetString(config, fs_encoding, L"ascii");
}
return config_get_locale_encoding(config, preconfig, fs_encoding);
#endif // !MS_WINDOWS
}
static PyStatus
config_init_fs_encoding(PyConfig *config, const PyPreConfig *preconfig)
{
PyStatus status;
if (config->filesystem_encoding == NULL) {
status = config_get_fs_encoding(config, preconfig,
&config->filesystem_encoding);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->filesystem_errors == NULL) {
const wchar_t *errors;
#ifdef MS_WINDOWS
if (preconfig->legacy_windows_fs_encoding) {
errors = L"replace";
}
else {
errors = L"surrogatepass";
}
#else
errors = L"surrogateescape";
#endif
status = PyConfig_SetString(config, &config->filesystem_errors, errors);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
return _PyStatus_OK();
}
static PyStatus
config_init_import(PyConfig *config, int compute_path_config)
{
PyStatus status;
status = _PyConfig_InitPathConfig(config, compute_path_config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
const char *env = config_get_env(config, "PYTHON_FROZEN_MODULES");
if (env == NULL) {
}
else if (strcmp(env, "on") == 0) {
config->use_frozen_modules = 1;
}
else if (strcmp(env, "off") == 0) {
config->use_frozen_modules = 0;
} else {
return PyStatus_Error("bad value for PYTHON_FROZEN_MODULES "
"(expected \"on\" or \"off\")");
}
/* -X frozen_modules=[on|off] */
const wchar_t *value = config_get_xoption_value(config, L"frozen_modules");
if (value == NULL) {
}
else if (wcscmp(value, L"on") == 0) {
config->use_frozen_modules = 1;
}
else if (wcscmp(value, L"off") == 0) {
config->use_frozen_modules = 0;
}
else if (wcslen(value) == 0) {
// "-X frozen_modules" and "-X frozen_modules=" both imply "on".
config->use_frozen_modules = 1;
}
else {
return PyStatus_Error("bad value for option -X frozen_modules "
"(expected \"on\" or \"off\")");
}
assert(config->use_frozen_modules >= 0);
return _PyStatus_OK();
}
PyStatus
_PyConfig_InitImportConfig(PyConfig *config)
{
return config_init_import(config, 1);
}
static PyStatus
config_read(PyConfig *config, int compute_path_config)
{
PyStatus status;
const PyPreConfig *preconfig = &_PyRuntime.preconfig;
if (config->use_environment) {
status = config_read_env_vars(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
/* -X options */
if (config_get_xoption(config, L"showrefcount")) {
config->show_ref_count = 1;
}
const wchar_t *x_gil = config_get_xoption_value(config, L"gil");
if (x_gil != NULL) {
size_t len = wcslen(x_gil);
status = config_read_gil(config, len, x_gil[0]);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
#ifdef Py_STATS
if (config_get_xoption(config, L"pystats")) {
config->_pystats = 1;
}
else if (config_get_env(config, "PYTHONSTATS")) {
config->_pystats = 1;
}
if (config->_pystats < 0) {
config->_pystats = 0;
}
#endif
status = config_read_complex_options(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
if (config->_install_importlib) {
status = config_init_import(config, compute_path_config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
/* default values */
if (config->dev_mode) {
if (config->faulthandler < 0) {
config->faulthandler = 1;
}
}
if (config->faulthandler < 0) {
config->faulthandler = 0;
}
if (config->tracemalloc < 0) {
config->tracemalloc = 0;
}
if (config->lazy_imports < 0) {
config->lazy_imports = -1; // Default is auto/unset
}
if (config->perf_profiling < 0) {
config->perf_profiling = 0;
}
if (config->remote_debug < 0) {
config->remote_debug = -1;
}
if (config->use_hash_seed < 0) {
config->use_hash_seed = 0;
config->hash_seed = 0;
}
if (config->filesystem_encoding == NULL || config->filesystem_errors == NULL) {
status = config_init_fs_encoding(config, preconfig);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
status = config_init_stdio_encoding(config, preconfig);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
if (config->argv.length < 1) {
/* Ensure at least one (empty) argument is seen */
status = PyWideStringList_Append(&config->argv, L"");
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->check_hash_pycs_mode == NULL) {
status = PyConfig_SetString(config, &config->check_hash_pycs_mode,
L"default");
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
if (config->configure_c_stdio < 0) {
config->configure_c_stdio = 1;
}
// Only parse arguments once.
if (config->parse_argv == 1) {
config->parse_argv = 2;
}
return _PyStatus_OK();
}
static void
config_init_stdio(const PyConfig *config)
{
#if defined(MS_WINDOWS) || defined(__CYGWIN__)
/* don't translate newlines (\r\n <=> \n) */
_setmode(fileno(stdin), O_BINARY);
_setmode(fileno(stdout), O_BINARY);
_setmode(fileno(stderr), O_BINARY);
#endif
if (!config->buffered_stdio) {
#ifdef HAVE_SETVBUF
setvbuf(stdin, (char *)NULL, _IONBF, BUFSIZ);
setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
setvbuf(stderr, (char *)NULL, _IONBF, BUFSIZ);
#else /* !HAVE_SETVBUF */
setbuf(stdin, (char *)NULL);
setbuf(stdout, (char *)NULL);
setbuf(stderr, (char *)NULL);
#endif /* !HAVE_SETVBUF */
}
else if (config->interactive) {
#ifdef MS_WINDOWS
/* Doesn't have to have line-buffered -- use unbuffered */
/* Any set[v]buf(stdin, ...) screws up Tkinter :-( */
setvbuf(stdout, (char *)NULL, _IONBF, BUFSIZ);
#else /* !MS_WINDOWS */
#ifdef HAVE_SETVBUF
setvbuf(stdin, (char *)NULL, _IOLBF, BUFSIZ);
setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
#endif /* HAVE_SETVBUF */
#endif /* !MS_WINDOWS */
/* Leave stderr alone - it should be unbuffered anyway. */
}
}
/* Write the configuration:
- set Py_xxx global configuration variables
- initialize C standard streams (stdin, stdout, stderr) */
PyStatus
_PyConfig_Write(const PyConfig *config, _PyRuntimeState *runtime)
{
if (config->configure_c_stdio) {
config_init_stdio(config);
}
/* Write the new pre-configuration into _PyRuntime */
PyPreConfig *preconfig = &runtime->preconfig;
preconfig->isolated = config->isolated;
preconfig->use_environment = config->use_environment;
preconfig->dev_mode = config->dev_mode;
if (_Py_SetArgcArgv(config->orig_argv.length,
config->orig_argv.items) < 0)
{
return _PyStatus_NO_MEMORY();
}
#ifdef PYMALLOC_USE_HUGEPAGES
runtime->allocators.use_hugepages = config->pymalloc_hugepages;
#endif
return _PyStatus_OK();
}
/* --- PyConfig command line parser -------------------------- */
static void
config_usage(int error, const wchar_t* program)
{
FILE *f = error ? stderr : stdout;
int colorize = _Py_can_colorize(f);
fprint_help(f, usage_line, colorize, program);
if (error) {
fprintf(f, "Try `python -h' for more information.\n");
}
else {
fprint_help(f, usage_help, colorize, NULL);
}
}
static void
config_envvars_usage(void)
{
int colorize = _Py_can_colorize(stdout);
fprint_help(stdout, usage_envvars, colorize, NULL);
}
static void
config_xoptions_usage(void)
{
int colorize = _Py_can_colorize(stdout);
fprint_help(stdout, usage_xoptions, colorize, NULL);
}
static void
config_complete_usage(const wchar_t* program)
{
config_usage(0, program);
putchar('\n');
config_envvars_usage();
putchar('\n');
config_xoptions_usage();
}
/* Parse the command line arguments */
static PyStatus
config_parse_cmdline(PyConfig *config, PyWideStringList *warnoptions,
Py_ssize_t *opt_index)
{
// Only store the first option
#define DEFER_OPTION(OPTION) \
do { \
if (config->_deferred_cmdline_option == 0) { \
config->_deferred_cmdline_option = (OPTION); \
} \
} while (0)
PyStatus status;
const PyWideStringList *argv = &config->argv;
int print_version = 0;
struct _PyOS_GetOpt getopt;
_PyOS_GetOpt_Init(&getopt, argv->length, argv->items);
do {
int c = _PyOS_GetOpt(&getopt);
if (c == -1) {
break;
}
if (c == 'c') {
if (config->run_command == NULL) {
/* -c is the last option; following arguments
that look like options are left for the
command to interpret. */
size_t len = wcslen(getopt.arg) + 1 + 1;
wchar_t *command = PyMem_RawMalloc(sizeof(wchar_t) * len);
if (command == NULL) {
return _PyStatus_NO_MEMORY();
}
memcpy(command, getopt.arg, (len - 2) * sizeof(wchar_t));
command[len - 2] = '\n';
command[len - 1] = 0;
config->run_command = command;
}
break;
}
if (c == 'm') {
/* -m is the last option; following arguments
that look like options are left for the
module to interpret. */
if (config->run_module == NULL) {
config->run_module = _PyMem_RawWcsdup(getopt.arg);
if (config->run_module == NULL) {
return _PyStatus_NO_MEMORY();
}
}
break;
}
switch (c) {
// Integers represent long options, see Python/getopt.c
case 1:
// --check-hash-based-pycs option
if (wcscmp(getopt.arg, L"always") == 0
|| wcscmp(getopt.arg, L"never") == 0
|| wcscmp(getopt.arg, L"default") == 0)
{
status = PyConfig_SetString(config, &config->check_hash_pycs_mode,
getopt.arg);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
} else {
DEFER_OPTION(c);
}
break;
case 2:
// --help-all option
DEFER_OPTION(c);
break;
case 3:
// --help-env option
DEFER_OPTION(c);
break;
case 4:
// --help-xoptions option
DEFER_OPTION(c);
break;
case 'b':
config->bytes_warning++;
break;
case 'd':
config->parser_debug++;
break;
case 'i':
config->inspect++;
config->interactive++;
break;
case 'E':
case 'I':
case 'X':
/* option handled by _PyPreCmdline_Read() */
break;
case 'O':
config->optimization_level++;
break;
case 'P':
config->safe_path = 1;
break;
case 'B':
config->write_bytecode = 0;
break;
case 's':
config->user_site_directory = 0;
break;
case 'S':
config->site_import = 0;
break;
case 't':
/* ignored for backwards compatibility */
break;
case 'u':
config->buffered_stdio = 0;
break;
case 'v':
config->verbose++;
break;
case 'x':
config->skip_source_first_line = 1;
break;
case 'h':
case '?':
DEFER_OPTION(c);
break;
case 'V':
print_version++;
break;
case 'W':
status = PyWideStringList_Append(warnoptions, getopt.arg);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
break;
case 'q':
config->quiet++;
break;
case 'R':
config->use_hash_seed = 0;
break;
/* This space reserved for other options */
default:
/* unknown argument: parsing failed */
DEFER_OPTION(c);
break;
}
} while (config->_deferred_cmdline_option == 0);
if (print_version >= 2) {
DEFER_OPTION('W');
}
else if (print_version >= 1) {
DEFER_OPTION('V');
}
if (config->run_command == NULL && config->run_module == NULL
&& getopt.index < argv->length
&& wcscmp(argv->items[getopt.index], L"-") != 0
&& config->run_filename == NULL)
{
config->run_filename = _PyMem_RawWcsdup(argv->items[getopt.index]);
if (config->run_filename == NULL) {
return _PyStatus_NO_MEMORY();
}
}
if (config->run_command != NULL || config->run_module != NULL) {
/* Backup getopt.index */
getopt.index--;
}
*opt_index = getopt.index;
return _PyStatus_OK();
#undef DEFER_OPTION
}
int
_PyConfig_ProcessDeferredCmdlineOption(PyConfig *config)
{
int c = config->_deferred_cmdline_option;
config->_deferred_cmdline_option = 0;
if (c == 0) {
// There is no deferred option
return -1;
}
// Select the program name
const PyWideStringList *argv = &config->argv;
const wchar_t* program = config->program_name;
if (!program && argv->length >= 1) {
program = argv->items[0];
}
if (!program) {
program = L"python";
}
switch (c) {
case 'h':
case '?':
config_usage(0, program);
return 0;
case 'V':
printf("Python %s\n", PY_VERSION);
return 0;
case 'W': // -VV or more -V options
printf("Python %s\n", Py_GetVersion());
return 0;
// Integers represent long options, see Python/getopt.c
case 1:
// check-hash-based-pycs
fprintf(stderr, "--check-hash-based-pycs must be one of "
"'default', 'always', or 'never'\n");
config_usage(1, program);
return 2;
case 2:
// help-all
config_complete_usage(program);
return 0;
case 3:
// help-env
config_envvars_usage();
return 0;
case 4:
// help-xoptions
config_xoptions_usage();
return 0;
case '_':
// Unknown option or missing argument
_Py_FALLTHROUGH;
default:
config_usage(1, program);
return 2;
}
}
#ifdef MS_WINDOWS
# define WCSTOK wcstok_s
#else
# define WCSTOK wcstok
#endif
/* Get warning options from PYTHONWARNINGS environment variable. */
static PyStatus
config_init_env_warnoptions(PyConfig *config, PyWideStringList *warnoptions)
{
PyStatus status;
/* CONFIG_GET_ENV_DUP requires dest to be initialized to NULL */
wchar_t *env = NULL;
status = CONFIG_GET_ENV_DUP(config, &env,
L"PYTHONWARNINGS", "PYTHONWARNINGS");
if (_PyStatus_EXCEPTION(status)) {
return status;
}
/* env var is not set or is empty */
if (env == NULL) {
return _PyStatus_OK();
}
wchar_t *warning, *context = NULL;
for (warning = WCSTOK(env, L",", &context);
warning != NULL;
warning = WCSTOK(NULL, L",", &context))
{
status = PyWideStringList_Append(warnoptions, warning);
if (_PyStatus_EXCEPTION(status)) {
PyMem_RawFree(env);
return status;
}
}
PyMem_RawFree(env);
return _PyStatus_OK();
}
static PyStatus
warnoptions_append(PyConfig *config, PyWideStringList *options,
const wchar_t *option)
{
/* config_init_warnoptions() add existing config warnoptions at the end:
ensure that the new option is not already present in this list to
prevent change the options order when config_init_warnoptions() is
called twice. */
if (_PyWideStringList_Find(&config->warnoptions, option)) {
/* Already present: do nothing */
return _PyStatus_OK();
}
if (_PyWideStringList_Find(options, option)) {
/* Already present: do nothing */
return _PyStatus_OK();
}
return PyWideStringList_Append(options, option);
}
static PyStatus
warnoptions_extend(PyConfig *config, PyWideStringList *options,
const PyWideStringList *options2)
{
const Py_ssize_t len = options2->length;
wchar_t *const *items = options2->items;
for (Py_ssize_t i = 0; i < len; i++) {
PyStatus status = warnoptions_append(config, options, items[i]);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
return _PyStatus_OK();
}
static PyStatus
config_init_warnoptions(PyConfig *config,
const PyWideStringList *cmdline_warnoptions,
const PyWideStringList *env_warnoptions,
const PyWideStringList *sys_warnoptions)
{
PyStatus status;
PyWideStringList options = _PyWideStringList_INIT;
/* Priority of warnings options, lowest to highest:
*
* - any implicit filters added by _warnings.c/warnings.py
* - PyConfig.dev_mode: "default" filter
* - PYTHONWARNINGS environment variable
* - '-W' command line options
* - PyConfig.bytes_warning ('-b' and '-bb' command line options):
* "default::BytesWarning" or "error::BytesWarning" filter
* - early PySys_AddWarnOption() calls
* - PyConfig.warnoptions
*
* PyConfig.warnoptions is copied to sys.warnoptions. Since the warnings
* module works on the basis of "the most recently added filter will be
* checked first", we add the lowest precedence entries first so that later
* entries override them.
*/
if (config->dev_mode) {
status = warnoptions_append(config, &options, L"default");
if (_PyStatus_EXCEPTION(status)) {
goto error;
}
}
status = warnoptions_extend(config, &options, env_warnoptions);
if (_PyStatus_EXCEPTION(status)) {
goto error;
}
status = warnoptions_extend(config, &options, cmdline_warnoptions);
if (_PyStatus_EXCEPTION(status)) {
goto error;
}
/* If the bytes_warning_flag isn't set, bytesobject.c and bytearrayobject.c
* don't even try to emit a warning, so we skip setting the filter in that
* case.
*/
if (config->bytes_warning) {
const wchar_t *filter;
if (config->bytes_warning> 1) {
filter = L"error::BytesWarning";
}
else {
filter = L"default::BytesWarning";
}
status = warnoptions_append(config, &options, filter);
if (_PyStatus_EXCEPTION(status)) {
goto error;
}
}
status = warnoptions_extend(config, &options, sys_warnoptions);
if (_PyStatus_EXCEPTION(status)) {
goto error;
}
/* Always add all PyConfig.warnoptions options */
status = _PyWideStringList_Extend(&options, &config->warnoptions);
if (_PyStatus_EXCEPTION(status)) {
goto error;
}
_PyWideStringList_Clear(&config->warnoptions);
config->warnoptions = options;
return _PyStatus_OK();
error:
_PyWideStringList_Clear(&options);
return status;
}
static PyStatus
config_update_argv(PyConfig *config, Py_ssize_t opt_index)
{
const PyWideStringList *cmdline_argv = &config->argv;
PyWideStringList config_argv = _PyWideStringList_INIT;
/* Copy argv to be able to modify it (to force -c/-m) */
if (cmdline_argv->length <= opt_index) {
/* Ensure at least one (empty) argument is seen */
PyStatus status = PyWideStringList_Append(&config_argv, L"");
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}
else {
PyWideStringList slice;
slice.length = cmdline_argv->length - opt_index;
slice.items = &cmdline_argv->items[opt_index];
if (_PyWideStringList_Copy(&config_argv, &slice) < 0) {
return _PyStatus_NO_MEMORY();
}
}
assert(config_argv.length >= 1);
wchar_t *arg0 = NULL;
if (config->run_command != NULL) {
/* Force sys.argv[0] = '-c' */
arg0 = L"-c";
}
else if (config->run_module != NULL) {
/* Force sys.argv[0] = '-m'*/
arg0 = L"-m";
}
if (arg0 != NULL) {
arg0 = _PyMem_RawWcsdup(arg0);
if (arg0 == NULL) {
_PyWideStringList_Clear(&config_argv);
return _PyStatus_NO_MEMORY();
}
PyMem_RawFree(config_argv.items[0]);
config_argv.items[0] = arg0;
}
_PyWideStringList_Clear(&config->argv);
config->argv = config_argv;
return _PyStatus_OK();
}
static PyStatus
core_read_precmdline(PyConfig *config, _PyPreCmdline *precmdline)
{
PyStatus status;
if (config->parse_argv == 1) {
if (_PyWideStringList_Copy(&precmdline->argv, &config->argv) < 0) {
return _PyStatus_NO_MEMORY();
}
}
PyPreConfig preconfig;
status = _PyPreConfig_InitFromPreConfig(&preconfig, &_PyRuntime.preconfig);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
_PyPreConfig_GetConfig(&preconfig, config);
status = _PyPreCmdline_Read(precmdline, &preconfig);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
status = _PyPreCmdline_SetConfig(precmdline, config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
return _PyStatus_OK();
}
/* Get run_filename absolute path */
static PyStatus
config_run_filename_abspath(PyConfig *config)
{
if (!config->run_filename) {
return _PyStatus_OK();
}
#ifndef MS_WINDOWS
if (_Py_isabs(config->run_filename)) {
/* path is already absolute */
return _PyStatus_OK();
}
#endif
wchar_t *abs_filename;
if (_Py_abspath(config->run_filename, &abs_filename) < 0) {
/* failed to get the absolute path of the command line filename:
ignore the error, keep the relative path */
return _PyStatus_OK();
}
if (abs_filename == NULL) {
return _PyStatus_NO_MEMORY();
}
PyMem_RawFree(config->run_filename);
config->run_filename = abs_filename;
return _PyStatus_OK();
}
static PyStatus
config_read_cmdline(PyConfig *config)
{
PyStatus status;
PyWideStringList cmdline_warnoptions = _PyWideStringList_INIT;
PyWideStringList env_warnoptions = _PyWideStringList_INIT;
PyWideStringList sys_warnoptions = _PyWideStringList_INIT;
if (config->parse_argv < 0) {
config->parse_argv = 1;
}
if (config->parse_argv == 1) {
Py_ssize_t opt_index;
status = config_parse_cmdline(config, &cmdline_warnoptions, &opt_index);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
status = config_run_filename_abspath(config);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
status = config_update_argv(config, opt_index);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
}
else {
status = config_run_filename_abspath(config);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
}
if (config->use_environment) {
status = config_init_env_warnoptions(config, &env_warnoptions);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
}
/* Handle early PySys_AddWarnOption() calls */
status = _PySys_ReadPreinitWarnOptions(&sys_warnoptions);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
status = config_init_warnoptions(config,
&cmdline_warnoptions,
&env_warnoptions,
&sys_warnoptions);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
status = _PyStatus_OK();
done:
_PyWideStringList_Clear(&cmdline_warnoptions);
_PyWideStringList_Clear(&env_warnoptions);
_PyWideStringList_Clear(&sys_warnoptions);
return status;
}
PyStatus
_PyConfig_SetPyArgv(PyConfig *config, const _PyArgv *args)
{
PyStatus status = _Py_PreInitializeFromConfig(config, args);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
return _PyArgv_AsWstrList(args, &config->argv);
}
/* Set config.argv: decode argv using Py_DecodeLocale(). Pre-initialize Python
if needed to ensure that encodings are properly configured. */
PyStatus
PyConfig_SetBytesArgv(PyConfig *config, Py_ssize_t argc, char * const *argv)
{
_PyArgv args = {
.argc = argc,
.use_bytes_argv = 1,
.bytes_argv = argv,
.wchar_argv = NULL};
return _PyConfig_SetPyArgv(config, &args);
}
PyStatus
PyConfig_SetArgv(PyConfig *config, Py_ssize_t argc, wchar_t * const *argv)
{
_PyArgv args = {
.argc = argc,
.use_bytes_argv = 0,
.bytes_argv = NULL,
.wchar_argv = argv};
return _PyConfig_SetPyArgv(config, &args);
}
PyStatus
PyConfig_SetWideStringList(PyConfig *config, PyWideStringList *list,
Py_ssize_t length, wchar_t **items)
{
PyStatus status = _Py_PreInitializeFromConfig(config, NULL);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
PyWideStringList list2 = {.length = length, .items = items};
if (_PyWideStringList_Copy(list, &list2) < 0) {
return _PyStatus_NO_MEMORY();
}
return _PyStatus_OK();
}
#ifdef __CYGWIN__
// Cygwin strips ".exe" suffix from argv[0].
// Add again the ".exe" suffix.
static PyStatus
config_argv0_add_exe(PyConfig *config)
{
if (config->argv.length < 1) {
return _PyStatus_OK();
}
const wchar_t *argv0 = config->argv.items[0];
size_t len = wcslen(argv0);
if (len >= 5 && wcscmp(argv0 + len - 4, L".exe") == 0) {
return _PyStatus_OK();
}
wchar_t *exe = PyMem_RawMalloc((len + 4 + 1) * sizeof(wchar_t));
if (exe == NULL) {
return _PyStatus_NO_MEMORY();
}
wcscpy(exe, argv0);
wcscat(exe, L".exe");
FILE *fp = _Py_wfopen(exe, L"rb");
if (fp != NULL) {
fclose(fp);
PyMem_RawFree(config->argv.items[0]);
config->argv.items[0] = exe;
}
else {
PyMem_RawFree(exe);
}
return _PyStatus_OK();
}
#endif
/* Read the configuration into PyConfig from:
* Command line arguments
* Environment variables
The only side effects are to modify config and to call _Py_SetArgcArgv(). */
PyStatus
_PyConfig_Read(PyConfig *config, int compute_path_config)
{
PyStatus status;
status = _Py_PreInitializeFromConfig(config, NULL);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
config_read_preconfig(config);
// Set default values
if (config->bytes_warning < 0) {
config->bytes_warning = 0;
}
if (config->inspect < 0) {
config->inspect = 0;
}
if (config->interactive < 0) {
config->interactive = 0;
}
if (config->optimization_level < 0) {
config->optimization_level = 0;
}
if (config->parser_debug < 0) {
config->parser_debug = 0;
}
if (config->quiet < 0) {
config->quiet = 0;
}
if (config->use_environment < 0) {
config->use_environment = 0;
}
if (config->verbose < 0) {
config->verbose = 0;
}
if (config->write_bytecode < 0) {
config->write_bytecode = 1;
}
if (config->buffered_stdio < 0) {
config->buffered_stdio = 1;
}
if (config->isolated < 0) {
config->isolated = 0;
}
#ifdef MS_WINDOWS
if (config->legacy_windows_stdio < 0) {
config->legacy_windows_stdio = 0;
}
#endif
if (config->pathconfig_warnings < 0) {
config->pathconfig_warnings = 1;
}
if (config->site_import < 0) {
config->site_import = 1;
}
if (config->user_site_directory < 0) {
config->user_site_directory = 1;
}
#ifdef __CYGWIN__
status = config_argv0_add_exe(config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
#endif
if (config->orig_argv.length == 0
&& !(config->argv.length == 1
&& wcscmp(config->argv.items[0], L"") == 0))
{
if (_PyWideStringList_Copy(&config->orig_argv, &config->argv) < 0) {
return _PyStatus_NO_MEMORY();
}
}
_PyPreCmdline precmdline = _PyPreCmdline_INIT;
status = core_read_precmdline(config, &precmdline);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
assert(config->isolated >= 0);
if (config->isolated) {
config->safe_path = 1;
config->use_environment = 0;
config->user_site_directory = 0;
}
status = config_read_cmdline(config);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
/* Handle early PySys_AddXOption() calls */
status = _PySys_ReadPreinitXOptions(config);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
status = config_read(config, compute_path_config);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}
assert(config_check_consistency(config));
status = _PyStatus_OK();
done:
_PyPreCmdline_Clear(&precmdline);
return status;
}
PyStatus
PyConfig_Read(PyConfig *config)
{
return _PyConfig_Read(config, 0);
}
PyObject*
_Py_GetConfigsAsDict(void)
{
PyObject *result = NULL;
PyObject *dict = NULL;
result = PyDict_New();
if (result == NULL) {
goto error;
}
/* global result */
dict = _Py_GetGlobalVariablesAsDict();
if (dict == NULL) {
goto error;
}
if (PyDict_SetItemString(result, "global_config", dict) < 0) {
goto error;
}
Py_CLEAR(dict);
/* pre config */
PyInterpreterState *interp = _PyInterpreterState_GET();
const PyPreConfig *pre_config = &interp->runtime->preconfig;
dict = _PyPreConfig_AsDict(pre_config);
if (dict == NULL) {
goto error;
}
if (PyDict_SetItemString(result, "pre_config", dict) < 0) {
goto error;
}
Py_CLEAR(dict);
/* core config */
const PyConfig *config = _PyInterpreterState_GetConfig(interp);
dict = _PyConfig_AsDict(config);
if (dict == NULL) {
goto error;
}
if (PyDict_SetItemString(result, "config", dict) < 0) {
goto error;
}
Py_CLEAR(dict);
return result;
error:
Py_XDECREF(result);
Py_XDECREF(dict);
return NULL;
}
static void
init_dump_ascii_wstr(const wchar_t *str)
{
if (str == NULL) {
PySys_WriteStderr("(not set)");
return;
}
PySys_WriteStderr("'");
for (; *str != L'\0'; str++) {
unsigned int ch = (unsigned int)*str;
if (ch == L'\'') {
PySys_WriteStderr("\\'");
} else if (0x20 <= ch && ch < 0x7f) {
PySys_WriteStderr("%c", ch);
}
else if (ch <= 0xff) {
PySys_WriteStderr("\\x%02x", ch);
}
#if SIZEOF_WCHAR_T > 2
else if (ch > 0xffff) {
PySys_WriteStderr("\\U%08x", ch);
}
#endif
else {
PySys_WriteStderr("\\u%04x", ch);
}
}
PySys_WriteStderr("'");
}
/* Dump the Python path configuration into sys.stderr */
void
_Py_DumpPathConfig(PyThreadState *tstate)
{
PyObject *exc = _PyErr_GetRaisedException(tstate);
PySys_WriteStderr("Python path configuration:\n");
#define DUMP_CONFIG(NAME, FIELD) \
do { \
PySys_WriteStderr(" " NAME " = "); \
init_dump_ascii_wstr(config->FIELD); \
PySys_WriteStderr("\n"); \
} while (0)
const PyConfig *config = _PyInterpreterState_GetConfig(tstate->interp);
DUMP_CONFIG("PYTHONHOME", home);
DUMP_CONFIG("PYTHONPATH", pythonpath_env);
DUMP_CONFIG("program name", program_name);
PySys_WriteStderr(" isolated = %i\n", config->isolated);
PySys_WriteStderr(" environment = %i\n", config->use_environment);
PySys_WriteStderr(" user site = %i\n", config->user_site_directory);
PySys_WriteStderr(" safe_path = %i\n", config->safe_path);
PySys_WriteStderr(" import site = %i\n", config->site_import);
PySys_WriteStderr(" is in build tree = %i\n", config->_is_python_build);
DUMP_CONFIG("stdlib dir", stdlib_dir);
DUMP_CONFIG("sys.path[0]", sys_path_0);
#undef DUMP_CONFIG
#define DUMP_SYS(NAME) \
do { \
PySys_FormatStderr(" sys.%s = ", #NAME); \
if (PySys_GetOptionalAttrString(#NAME, &obj) < 0) { \
PyErr_Clear(); \
} \
if (obj != NULL) { \
PySys_FormatStderr("%A", obj); \
Py_DECREF(obj); \
} \
else { \
PySys_WriteStderr("(not set)"); \
} \
PySys_FormatStderr("\n"); \
} while (0)
PyObject *obj;
DUMP_SYS(_base_executable);
DUMP_SYS(base_prefix);
DUMP_SYS(base_exec_prefix);
DUMP_SYS(platlibdir);
DUMP_SYS(executable);
DUMP_SYS(prefix);
DUMP_SYS(exec_prefix);
#undef DUMP_SYS
PyObject *sys_path;
(void) PySys_GetOptionalAttrString("path", &sys_path);
if (sys_path != NULL && PyList_Check(sys_path)) {
PySys_WriteStderr(" sys.path = [\n");
Py_ssize_t len = PyList_GET_SIZE(sys_path);
for (Py_ssize_t i=0; i < len; i++) {
PyObject *path = PyList_GET_ITEM(sys_path, i);
PySys_FormatStderr(" %A,\n", path);
}
PySys_WriteStderr(" ]\n");
}
Py_XDECREF(sys_path);
_PyErr_SetRaisedException(tstate, exc);
}
// --- PyInitConfig API ---------------------------------------------------
struct PyInitConfig {
PyPreConfig preconfig;
PyConfig config;
struct _inittab *inittab;
Py_ssize_t inittab_size;
PyStatus status;
char *err_msg;
};
static PyInitConfig*
initconfig_alloc(void)
{
return calloc(1, sizeof(PyInitConfig));
}
PyInitConfig*
PyInitConfig_Create(void)
{
PyInitConfig *config = initconfig_alloc();
if (config == NULL) {
return NULL;
}
PyPreConfig_InitIsolatedConfig(&config->preconfig);
PyConfig_InitIsolatedConfig(&config->config);
config->status = _PyStatus_OK();
return config;
}
void
PyInitConfig_Free(PyInitConfig *config)
{
if (config == NULL) {
return;
}
initconfig_free_config(&config->config);
PyMem_RawFree(config->inittab);
free(config->err_msg);
free(config);
}
int
PyInitConfig_GetError(PyInitConfig* config, const char **perr_msg)
{
assert(!_PyStatus_IS_EXIT(config->status));
if (_PyStatus_IS_ERROR(config->status) && config->status.err_msg != NULL) {
*perr_msg = config->status.err_msg;
return 1;
}
else {
*perr_msg = NULL;
return 0;
}
}
int
PyInitConfig_GetExitCode(PyInitConfig* config, int *exitcode)
{
assert(!_PyStatus_IS_EXIT(config->status));
return 0;
}
static void
initconfig_set_error(PyInitConfig *config, const char *err_msg)
{
config->status = _PyStatus_ERR(err_msg);
}
static const PyConfigSpec*
initconfig_find_spec(const PyConfigSpec *spec, const char *name)
{
for (; spec->name != NULL; spec++) {
if (strcmp(name, spec->name) == 0) {
return spec;
}
}
return NULL;
}
int
PyInitConfig_HasOption(PyInitConfig *config, const char *name)
{
const PyConfigSpec *spec = initconfig_find_spec(PYCONFIG_SPEC, name);
if (spec == NULL) {
spec = initconfig_find_spec(PYPRECONFIG_SPEC, name);
}
return (spec != NULL);
}
static const PyConfigSpec*
initconfig_prepare(PyInitConfig *config, const char *name, void **raw_member)
{
const PyConfigSpec *spec = initconfig_find_spec(PYCONFIG_SPEC, name);
if (spec != NULL) {
*raw_member = config_get_spec_member(&config->config, spec);
return spec;
}
spec = initconfig_find_spec(PYPRECONFIG_SPEC, name);
if (spec != NULL) {
*raw_member = preconfig_get_spec_member(&config->preconfig, spec);
return spec;
}
initconfig_set_error(config, "unknown config option name");
return NULL;
}
int
PyInitConfig_GetInt(PyInitConfig *config, const char *name, int64_t *value)
{
void *raw_member;
const PyConfigSpec *spec = initconfig_prepare(config, name, &raw_member);
if (spec == NULL) {
return -1;
}
switch (spec->type) {
case PyConfig_MEMBER_INT:
case PyConfig_MEMBER_UINT:
case PyConfig_MEMBER_BOOL:
{
int *member = raw_member;
*value = *member;
break;
}
case PyConfig_MEMBER_ULONG:
{
unsigned long *member = raw_member;
#if SIZEOF_LONG >= 8
if ((unsigned long)INT64_MAX < *member) {
initconfig_set_error(config,
"config option value doesn't fit into int64_t");
return -1;
}
#endif
*value = *member;
break;
}
default:
initconfig_set_error(config, "config option type is not int");
return -1;
}
return 0;
}
static char*
wstr_to_utf8(PyInitConfig *config, wchar_t *wstr)
{
char *utf8;
size_t utf8_len;
int res = _Py_EncodeUTF8(wstr, &utf8, &utf8_len,
NULL, 1, _Py_ERROR_STRICT);
if (res == -2) {
initconfig_set_error(config, "encoding error");
return NULL;
}
if (res < 0) {
config->status = _PyStatus_NO_MEMORY();
return NULL;
}
// Copy to use the malloc() memory allocator
size_t size = utf8_len + 1;
char *str = malloc(size);
if (str == NULL) {
PyMem_RawFree(utf8);
config->status = _PyStatus_NO_MEMORY();
return NULL;
}
memcpy(str, utf8, size);
PyMem_RawFree(utf8);
return str;
}
int
PyInitConfig_GetStr(PyInitConfig *config, const char *name, char **value)
{
void *raw_member;
const PyConfigSpec *spec = initconfig_prepare(config, name, &raw_member);
if (spec == NULL) {
return -1;
}
if (spec->type != PyConfig_MEMBER_WSTR
&& spec->type != PyConfig_MEMBER_WSTR_OPT)
{
initconfig_set_error(config, "config option type is not string");
return -1;
}
wchar_t **member = raw_member;
if (*member == NULL) {
*value = NULL;
return 0;
}
*value = wstr_to_utf8(config, *member);
if (*value == NULL) {
return -1;
}
return 0;
}
int
PyInitConfig_GetStrList(PyInitConfig *config, const char *name, size_t *length, char ***items)
{
void *raw_member;
const PyConfigSpec *spec = initconfig_prepare(config, name, &raw_member);
if (spec == NULL) {
return -1;
}
if (spec->type != PyConfig_MEMBER_WSTR_LIST) {
initconfig_set_error(config, "config option type is not string list");
return -1;
}
PyWideStringList *list = raw_member;
*length = list->length;
*items = malloc(list->length * sizeof(char*));
if (*items == NULL) {
config->status = _PyStatus_NO_MEMORY();
return -1;
}
for (Py_ssize_t i=0; i < list->length; i++) {
(*items)[i] = wstr_to_utf8(config, list->items[i]);
if ((*items)[i] == NULL) {
PyInitConfig_FreeStrList(i, *items);
return -1;
}
}
return 0;
}
void
PyInitConfig_FreeStrList(size_t length, char **items)
{
for (size_t i=0; i < length; i++) {
free(items[i]);
}
free(items);
}
int
PyInitConfig_SetInt(PyInitConfig *config, const char *name, int64_t value)
{
void *raw_member;
const PyConfigSpec *spec = initconfig_prepare(config, name, &raw_member);
if (spec == NULL) {
return -1;
}
switch (spec->type) {
case PyConfig_MEMBER_INT:
{
if (value < (int64_t)INT_MIN || (int64_t)INT_MAX < value) {
initconfig_set_error(config,
"config option value is out of int range");
return -1;
}
int int_value = (int)value;
int *member = raw_member;
*member = int_value;
break;
}
case PyConfig_MEMBER_UINT:
case PyConfig_MEMBER_BOOL:
{
if (value < 0 || (uint64_t)UINT_MAX < (uint64_t)value) {
initconfig_set_error(config,
"config option value is out of unsigned int range");
return -1;
}
int int_value = (int)value;
int *member = raw_member;
*member = int_value;
break;
}
case PyConfig_MEMBER_ULONG:
{
if (value < 0 || (uint64_t)ULONG_MAX < (uint64_t)value) {
initconfig_set_error(config,
"config option value is out of unsigned long range");
return -1;
}
unsigned long ulong_value = (unsigned long)value;
unsigned long *member = raw_member;
*member = ulong_value;
break;
}
default:
initconfig_set_error(config, "config option type is not int");
return -1;
}
if (strcmp(name, "hash_seed") == 0) {
config->config.use_hash_seed = 1;
}
return 0;
}
static wchar_t*
utf8_to_wstr(PyInitConfig *config, const char *str)
{
wchar_t *wstr;
size_t wlen;
int res = _Py_DecodeUTF8(str, strlen(str), &wstr, &wlen, _Py_ERROR_STRICT);
if (res == _Py_CODEC_DECODE_ERROR) {
initconfig_set_error(config, "decoding error");
return NULL;
}
if (res < 0) {
assert(res == _Py_CODEC_MEMORY_ERROR);
config->status = _PyStatus_NO_MEMORY();
return NULL;
}
// Copy to use the malloc() memory allocator
size_t size = (wlen + 1) * sizeof(wchar_t);
wchar_t *wstr2 = malloc(size);
if (wstr2 == NULL) {
PyMem_RawFree(wstr);
config->status = _PyStatus_NO_MEMORY();
return NULL;
}
memcpy(wstr2, wstr, size);
PyMem_RawFree(wstr);
return wstr2;
}
int
PyInitConfig_SetStr(PyInitConfig *config, const char *name, const char* value)
{
void *raw_member;
const PyConfigSpec *spec = initconfig_prepare(config, name, &raw_member);
if (spec == NULL) {
return -1;
}
if (spec->type != PyConfig_MEMBER_WSTR
&& spec->type != PyConfig_MEMBER_WSTR_OPT) {
initconfig_set_error(config, "config option type is not string");
return -1;
}
if (value == NULL && spec->type != PyConfig_MEMBER_WSTR_OPT) {
initconfig_set_error(config, "config option string cannot be NULL");
}
wchar_t **member = raw_member;
*member = utf8_to_wstr(config, value);
if (*member == NULL) {
return -1;
}
return 0;
}
static void
initconfig_free_wstr(wchar_t *member)
{
if (member) {
free(member);
}
}
static void
initconfig_free_wstr_list(PyWideStringList *list)
{
for (Py_ssize_t i = 0; i < list->length; i++) {
free(list->items[i]);
}
free(list->items);
}
static void
initconfig_free_config(const PyConfig *config)
{
const PyConfigSpec *spec = PYCONFIG_SPEC;
for (; spec->name != NULL; spec++) {
void *member = config_get_spec_member(config, spec);
if (spec->type == PyConfig_MEMBER_WSTR
|| spec->type == PyConfig_MEMBER_WSTR_OPT)
{
wchar_t *wstr = *(wchar_t **)member;
initconfig_free_wstr(wstr);
}
else if (spec->type == PyConfig_MEMBER_WSTR_LIST) {
initconfig_free_wstr_list(member);
}
}
}
static int
initconfig_set_str_list(PyInitConfig *config, PyWideStringList *list,
Py_ssize_t length, char * const *items)
{
PyWideStringList wlist = _PyWideStringList_INIT;
size_t size = sizeof(wchar_t*) * length;
wlist.items = (wchar_t **)malloc(size);
if (wlist.items == NULL) {
config->status = _PyStatus_NO_MEMORY();
return -1;
}
for (Py_ssize_t i = 0; i < length; i++) {
wchar_t *arg = utf8_to_wstr(config, items[i]);
if (arg == NULL) {
initconfig_free_wstr_list(&wlist);
return -1;
}
wlist.items[i] = arg;
wlist.length++;
}
initconfig_free_wstr_list(list);
*list = wlist;
return 0;
}
int
PyInitConfig_SetStrList(PyInitConfig *config, const char *name,
size_t length, char * const *items)
{
void *raw_member;
const PyConfigSpec *spec = initconfig_prepare(config, name, &raw_member);
if (spec == NULL) {
return -1;
}
if (spec->type != PyConfig_MEMBER_WSTR_LIST) {
initconfig_set_error(config, "config option type is not strings list");
return -1;
}
PyWideStringList *list = raw_member;
if (initconfig_set_str_list(config, list, length, items) < 0) {
return -1;
}
if (strcmp(name, "module_search_paths") == 0) {
config->config.module_search_paths_set = 1;
}
return 0;
}
int
PyInitConfig_AddModule(PyInitConfig *config, const char *name,
PyObject* (*initfunc)(void))
{
size_t size = sizeof(struct _inittab) * (config->inittab_size + 2);
struct _inittab *new_inittab = PyMem_RawRealloc(config->inittab, size);
if (new_inittab == NULL) {
config->status = _PyStatus_NO_MEMORY();
return -1;
}
config->inittab = new_inittab;
struct _inittab *entry = &config->inittab[config->inittab_size];
entry->name = name;
entry->initfunc = initfunc;
// Terminator entry
entry = &config->inittab[config->inittab_size + 1];
entry->name = NULL;
entry->initfunc = NULL;
config->inittab_size++;
return 0;
}
int
Py_InitializeFromInitConfig(PyInitConfig *config)
{
if (config->inittab_size >= 1) {
if (PyImport_ExtendInittab(config->inittab) < 0) {
config->status = _PyStatus_NO_MEMORY();
return -1;
}
}
_PyPreConfig_GetConfig(&config->preconfig, &config->config);
config->status = Py_PreInitializeFromArgs(
&config->preconfig,
config->config.argv.length,
config->config.argv.items);
if (_PyStatus_EXCEPTION(config->status)) {
return -1;
}
config->status = Py_InitializeFromConfig(&config->config);
if (_PyStatus_EXCEPTION(config->status)) {
return -1;
}
return 0;
}
// --- PyConfig_Get() -------------------------------------------------------
static const PyConfigSpec*
config_generic_find_spec(const PyConfigSpec *spec, const char *name)
{
for (; spec->name != NULL; spec++) {
if (spec->visibility == PyConfig_MEMBER_INIT_ONLY) {
continue;
}
if (strcmp(name, spec->name) == 0) {
return spec;
}
}
return NULL;
}
static const PyConfigSpec*
config_find_spec(const char *name)
{
return config_generic_find_spec(PYCONFIG_SPEC, name);
}
static const PyConfigSpec*
preconfig_find_spec(const char *name)
{
return config_generic_find_spec(PYPRECONFIG_SPEC, name);
}
static int
config_add_xoption(PyObject *dict, const wchar_t *str)
{
PyObject *name = NULL, *value = NULL;
const wchar_t *name_end = wcschr(str, L'=');
if (!name_end) {
name = PyUnicode_FromWideChar(str, -1);
if (name == NULL) {
goto error;
}
value = Py_NewRef(Py_True);
}
else {
name = PyUnicode_FromWideChar(str, name_end - str);
if (name == NULL) {
goto error;
}
value = PyUnicode_FromWideChar(name_end + 1, -1);
if (value == NULL) {
goto error;
}
}
if (PyDict_SetItem(dict, name, value) < 0) {
goto error;
}
Py_DECREF(name);
Py_DECREF(value);
return 0;
error:
Py_XDECREF(name);
Py_XDECREF(value);
return -1;
}
PyObject*
_PyConfig_CreateXOptionsDict(const PyConfig *config)
{
PyObject *dict = PyDict_New();
if (dict == NULL) {
return NULL;
}
Py_ssize_t nxoption = config->xoptions.length;
wchar_t **xoptions = config->xoptions.items;
for (Py_ssize_t i=0; i < nxoption; i++) {
const wchar_t *option = xoptions[i];
if (config_add_xoption(dict, option) < 0) {
Py_DECREF(dict);
return NULL;
}
}
return dict;
}
static int
config_get_sys_write_bytecode(const PyConfig *config, int *value)
{
PyObject *attr = PySys_GetAttrString("dont_write_bytecode");
if (attr == NULL) {
return -1;
}
int is_true = PyObject_IsTrue(attr);
Py_DECREF(attr);
if (is_true < 0) {
return -1;
}
*value = (!is_true);
return 0;
}
static PyObject*
config_get(const PyConfig *config, const PyConfigSpec *spec,
int use_sys)
{
if (use_sys) {
if (spec->sys.attr != NULL) {
return PySys_GetAttrString(spec->sys.attr);
}
if (strcmp(spec->name, "write_bytecode") == 0) {
int value;
if (config_get_sys_write_bytecode(config, &value) < 0) {
return NULL;
}
return PyBool_FromLong(value);
}
if (strcmp(spec->name, "int_max_str_digits") == 0) {
PyInterpreterState *interp = _PyInterpreterState_GET();
int maxdigits = _Py_atomic_load_int(&interp->long_state.max_str_digits);
return PyLong_FromLong(maxdigits);
}
}
void *member = config_get_spec_member(config, spec);
switch (spec->type) {
case PyConfig_MEMBER_INT:
case PyConfig_MEMBER_UINT:
{
int value = *(int *)member;
return PyLong_FromLong(value);
}
case PyConfig_MEMBER_BOOL:
{
int value = *(int *)member;
return PyBool_FromLong(value != 0);
}
case PyConfig_MEMBER_ULONG:
{
unsigned long value = *(unsigned long *)member;
return PyLong_FromUnsignedLong(value);
}
case PyConfig_MEMBER_WSTR:
case PyConfig_MEMBER_WSTR_OPT:
{
wchar_t *wstr = *(wchar_t **)member;
if (wstr != NULL) {
return PyUnicode_FromWideChar(wstr, -1);
}
else {
return Py_NewRef(Py_None);
}
}
case PyConfig_MEMBER_WSTR_LIST:
{
if (strcmp(spec->name, "xoptions") == 0) {
return _PyConfig_CreateXOptionsDict(config);
}
else {
const PyWideStringList *list = (const PyWideStringList *)member;
return _PyWideStringList_AsTuple(list);
}
}
default:
Py_UNREACHABLE();
}
}
static PyObject*
preconfig_get(const PyPreConfig *preconfig, const PyConfigSpec *spec)
{
// The type of all PYPRECONFIG_SPEC members is INT or BOOL.
assert(spec->type == PyConfig_MEMBER_INT
|| spec->type == PyConfig_MEMBER_BOOL);
char *member = (char *)preconfig + spec->offset;
int value = *(int *)member;
if (spec->type == PyConfig_MEMBER_BOOL) {
return PyBool_FromLong(value != 0);
}
else {
return PyLong_FromLong(value);
}
}
static void
config_unknown_name_error(const char *name)
{
PyErr_Format(PyExc_ValueError, "unknown config option name: %s", name);
}
PyObject*
PyConfig_Get(const char *name)
{
const PyConfigSpec *spec = config_find_spec(name);
if (spec != NULL) {
const PyConfig *config = _Py_GetConfig();
return config_get(config, spec, 1);
}
spec = preconfig_find_spec(name);
if (spec != NULL) {
const PyPreConfig *preconfig = &_PyRuntime.preconfig;
return preconfig_get(preconfig, spec);
}
config_unknown_name_error(name);
return NULL;
}
int
PyConfig_GetInt(const char *name, int *value)
{
assert(!PyErr_Occurred());
PyObject *obj = PyConfig_Get(name);
if (obj == NULL) {
return -1;
}
if (!PyLong_Check(obj)) {
Py_DECREF(obj);
PyErr_Format(PyExc_TypeError, "config option %s is not an int", name);
return -1;
}
int as_int = PyLong_AsInt(obj);
Py_DECREF(obj);
if (as_int == -1 && PyErr_Occurred()) {
PyErr_Format(PyExc_OverflowError,
"config option %s value does not fit into a C int", name);
return -1;
}
*value = as_int;
return 0;
}
static int
config_names_add(PyObject *names, const PyConfigSpec *spec)
{
for (; spec->name != NULL; spec++) {
if (spec->visibility == PyConfig_MEMBER_INIT_ONLY) {
continue;
}
PyObject *name = PyUnicode_FromString(spec->name);
if (name == NULL) {
return -1;
}
int res = PyList_Append(names, name);
Py_DECREF(name);
if (res < 0) {
return -1;
}
}
return 0;
}
PyObject*
PyConfig_Names(void)
{
PyObject *names = PyList_New(0);
if (names == NULL) {
goto error;
}
if (config_names_add(names, PYCONFIG_SPEC) < 0) {
goto error;
}
if (config_names_add(names, PYPRECONFIG_SPEC) < 0) {
goto error;
}
PyObject *frozen = PyFrozenSet_New(names);
Py_DECREF(names);
return frozen;
error:
Py_XDECREF(names);
return NULL;
}
// --- PyConfig_Set() -------------------------------------------------------
static int
config_set_sys_flag(const PyConfigSpec *spec, int int_value)
{
PyInterpreterState *interp = _PyInterpreterState_GET();
PyConfig *config = &interp->config;
if (spec->type == PyConfig_MEMBER_BOOL) {
if (int_value != 0) {
// convert values < 0 and values > 1 to 1
int_value = 1;
}
}
PyObject *value;
if (spec->sys.flag_setter) {
value = spec->sys.flag_setter(int_value);
}
else {
value = config_sys_flag_long(int_value);
}
if (value == NULL) {
return -1;
}
// Set sys.flags.FLAG
Py_ssize_t pos = spec->sys.flag_index;
if (_PySys_SetFlagObj(pos, value) < 0) {
goto error;
}
// Set PyConfig.ATTR
assert(spec->type == PyConfig_MEMBER_INT
|| spec->type == PyConfig_MEMBER_UINT
|| spec->type == PyConfig_MEMBER_BOOL);
int *member = config_get_spec_member(config, spec);
*member = int_value;
// Set sys.dont_write_bytecode attribute
if (strcmp(spec->name, "write_bytecode") == 0) {
if (PySys_SetObject("dont_write_bytecode", value) < 0) {
goto error;
}
}
Py_DECREF(value);
return 0;
error:
Py_DECREF(value);
return -1;
}
// Set PyConfig.ATTR integer member
static int
config_set_int_attr(const PyConfigSpec *spec, int value)
{
PyInterpreterState *interp = _PyInterpreterState_GET();
PyConfig *config = &interp->config;
int *member = config_get_spec_member(config, spec);
*member = value;
return 0;
}
int
PyConfig_Set(const char *name, PyObject *value)
{
if (PySys_Audit("cpython.PyConfig_Set", "sO", name, value) < 0) {
return -1;
}
const PyConfigSpec *spec = config_find_spec(name);
if (spec == NULL) {
spec = preconfig_find_spec(name);
if (spec == NULL) {
config_unknown_name_error(name);
return -1;
}
assert(spec->visibility != PyConfig_MEMBER_PUBLIC);
}
if (spec->visibility != PyConfig_MEMBER_PUBLIC) {
PyErr_Format(PyExc_ValueError, "cannot set read-only option %s",
name);
return -1;
}
int int_value = 0;
int has_int_value = 0;
switch (spec->type) {
case PyConfig_MEMBER_INT:
case PyConfig_MEMBER_UINT:
case PyConfig_MEMBER_BOOL:
if (!PyLong_Check(value)) {
PyErr_Format(PyExc_TypeError, "expected int or bool, got %T", value);
return -1;
}
int_value = PyLong_AsInt(value);
if (int_value == -1 && PyErr_Occurred()) {
return -1;
}
if (int_value < 0 && spec->type != PyConfig_MEMBER_INT) {
PyErr_Format(PyExc_ValueError, "value must be >= 0");
return -1;
}
has_int_value = 1;
break;
case PyConfig_MEMBER_ULONG:
// not implemented: only hash_seed uses this type, and it's read-only
goto cannot_set;
case PyConfig_MEMBER_WSTR:
if (!PyUnicode_CheckExact(value)) {
PyErr_Format(PyExc_TypeError, "expected str, got %T", value);
return -1;
}
break;
case PyConfig_MEMBER_WSTR_OPT:
if (value != Py_None && !PyUnicode_CheckExact(value)) {
PyErr_Format(PyExc_TypeError, "expected str or None, got %T", value);
return -1;
}
break;
case PyConfig_MEMBER_WSTR_LIST:
if (strcmp(spec->name, "xoptions") != 0) {
if (!PyList_Check(value)) {
PyErr_Format(PyExc_TypeError, "expected list[str], got %T",
value);
return -1;
}
for (Py_ssize_t i=0; i < PyList_GET_SIZE(value); i++) {
PyObject *item = PyList_GET_ITEM(value, i);
if (!PyUnicode_Check(item)) {
PyErr_Format(PyExc_TypeError,
"expected str, list item %zd has type %T",
i, item);
return -1;
}
}
}
else {
// xoptions type is dict[str, str]
if (!PyDict_Check(value)) {
PyErr_Format(PyExc_TypeError,
"expected dict[str, str | bool], got %T",
value);
return -1;
}
Py_ssize_t pos = 0;
PyObject *key, *item;
while (PyDict_Next(value, &pos, &key, &item)) {
if (!PyUnicode_Check(key)) {
PyErr_Format(PyExc_TypeError,
"expected str, "
"got dict key type %T", key);
return -1;
}
if (!PyUnicode_Check(item) && !PyBool_Check(item)) {
PyErr_Format(PyExc_TypeError,
"expected str or bool, "
"got dict value type %T", key);
return -1;
}
}
}
break;
default:
Py_UNREACHABLE();
}
if (spec->sys.attr != NULL) {
// Set the sys attribute, but don't set PyInterpreterState.config
// to keep the code simple.
return PySys_SetObject(spec->sys.attr, value);
}
else if (has_int_value) {
if (spec->sys.flag_index >= 0) {
return config_set_sys_flag(spec, int_value);
}
else if (strcmp(spec->name, "int_max_str_digits") == 0) {
return _PySys_SetIntMaxStrDigits(int_value);
}
else {
return config_set_int_attr(spec, int_value);
}
}
cannot_set:
PyErr_Format(PyExc_ValueError, "cannot set option %s", name);
return -1;
}