2018-08-01 15:56:14 +00:00
|
|
|
#include "Python.h"
|
2020-04-15 02:01:58 +00:00
|
|
|
#include "pycore_fileutils.h" // _Py_HasFileSystemDefaultEncodeErrors
|
|
|
|
#include "pycore_getopt.h" // _PyOS_GetOpt()
|
|
|
|
#include "pycore_initconfig.h" // _PyStatus_OK()
|
2020-04-14 15:52:15 +00:00
|
|
|
#include "pycore_interp.h" // _PyInterpreterState.runtime
|
2022-09-02 16:35:08 +00:00
|
|
|
#include "pycore_long.h" // _PY_LONG_MAX_STR_DIGITS_THRESHOLD
|
2020-04-15 02:01:58 +00:00
|
|
|
#include "pycore_pathconfig.h" // _Py_path_config
|
2023-02-28 11:50:52 +00:00
|
|
|
#include "pycore_pyerrors.h" // _PyErr_GetRaisedException()
|
2020-04-15 02:01:58 +00:00
|
|
|
#include "pycore_pylifecycle.h" // _Py_PreInitializeFromConfig()
|
2020-04-15 00:57:50 +00:00
|
|
|
#include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()
|
2020-04-14 15:52:15 +00:00
|
|
|
#include "pycore_pystate.h" // _PyThreadState_GET()
|
2023-09-06 15:54:59 +00:00
|
|
|
#include "pycore_pystats.h" // _Py_StatsOn()
|
2020-04-15 02:01:58 +00:00
|
|
|
|
|
|
|
#include "osdefs.h" // DELIM
|
2021-10-13 17:25:53 +00:00
|
|
|
|
2020-04-14 15:52:15 +00:00
|
|
|
#include <locale.h> // setlocale()
|
2021-10-13 17:25:53 +00:00
|
|
|
#include <stdlib.h> // getenv()
|
2019-03-01 15:25:19 +00:00
|
|
|
#if defined(MS_WINDOWS) || defined(__CYGWIN__)
|
|
|
|
# ifdef HAVE_IO_H
|
|
|
|
# include <io.h>
|
|
|
|
# endif
|
|
|
|
# ifdef HAVE_FCNTL_H
|
2020-04-14 15:52:15 +00:00
|
|
|
# include <fcntl.h> // O_BINARY
|
2019-03-01 15:25:19 +00:00
|
|
|
# endif
|
2018-08-29 11:25:36 +00:00
|
|
|
#endif
|
|
|
|
|
2024-04-02 20:35:52 +00:00
|
|
|
#include "config_common.h"
|
|
|
|
|
|
|
|
|
2023-09-30 17:24:06 +00:00
|
|
|
/* --- PyConfig spec ---------------------------------------------- */
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
PyConfig_MEMBER_INT = 0,
|
|
|
|
PyConfig_MEMBER_UINT = 1,
|
|
|
|
PyConfig_MEMBER_ULONG = 2,
|
2024-03-06 09:29:27 +00:00
|
|
|
PyConfig_MEMBER_BOOL = 3,
|
2023-09-30 17:24:06 +00:00
|
|
|
|
|
|
|
PyConfig_MEMBER_WSTR = 10,
|
|
|
|
PyConfig_MEMBER_WSTR_OPT = 11,
|
|
|
|
PyConfig_MEMBER_WSTR_LIST = 12,
|
|
|
|
} PyConfigMemberType;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
const char *name;
|
|
|
|
size_t offset;
|
|
|
|
PyConfigMemberType type;
|
|
|
|
} PyConfigSpec;
|
|
|
|
|
|
|
|
#define SPEC(MEMBER, TYPE) \
|
|
|
|
{#MEMBER, offsetof(PyConfig, MEMBER), PyConfig_MEMBER_##TYPE}
|
|
|
|
|
2024-03-06 09:29:27 +00:00
|
|
|
// Update _test_embed_set_config when adding new members
|
2023-09-30 17:24:06 +00:00
|
|
|
static const PyConfigSpec PYCONFIG_SPEC[] = {
|
|
|
|
SPEC(_config_init, UINT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(isolated, BOOL),
|
|
|
|
SPEC(use_environment, BOOL),
|
|
|
|
SPEC(dev_mode, BOOL),
|
|
|
|
SPEC(install_signal_handlers, BOOL),
|
|
|
|
SPEC(use_hash_seed, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(hash_seed, ULONG),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(faulthandler, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(tracemalloc, UINT),
|
2024-05-06 14:30:30 +00:00
|
|
|
SPEC(perf_profiling, UINT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(import_time, BOOL),
|
|
|
|
SPEC(code_debug_ranges, BOOL),
|
|
|
|
SPEC(show_ref_count, BOOL),
|
|
|
|
SPEC(dump_refs, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(dump_refs_file, WSTR_OPT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(malloc_stats, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(filesystem_encoding, WSTR),
|
|
|
|
SPEC(filesystem_errors, WSTR),
|
|
|
|
SPEC(pycache_prefix, WSTR_OPT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(parse_argv, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(orig_argv, WSTR_LIST),
|
|
|
|
SPEC(argv, WSTR_LIST),
|
|
|
|
SPEC(xoptions, WSTR_LIST),
|
|
|
|
SPEC(warnoptions, WSTR_LIST),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(site_import, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(bytes_warning, UINT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(warn_default_encoding, BOOL),
|
|
|
|
SPEC(inspect, BOOL),
|
|
|
|
SPEC(interactive, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(optimization_level, UINT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(parser_debug, BOOL),
|
|
|
|
SPEC(write_bytecode, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(verbose, UINT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(quiet, BOOL),
|
|
|
|
SPEC(user_site_directory, BOOL),
|
|
|
|
SPEC(configure_c_stdio, BOOL),
|
|
|
|
SPEC(buffered_stdio, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(stdio_encoding, WSTR),
|
|
|
|
SPEC(stdio_errors, WSTR),
|
|
|
|
#ifdef MS_WINDOWS
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(legacy_windows_stdio, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
#endif
|
|
|
|
SPEC(check_hash_pycs_mode, WSTR),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(use_frozen_modules, BOOL),
|
|
|
|
SPEC(safe_path, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(int_max_str_digits, INT),
|
2023-10-10 10:00:09 +00:00
|
|
|
SPEC(cpu_count, INT),
|
2024-03-11 15:02:58 +00:00
|
|
|
#ifdef Py_GIL_DISABLED
|
|
|
|
SPEC(enable_gil, INT),
|
|
|
|
#endif
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(pathconfig_warnings, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(program_name, WSTR),
|
|
|
|
SPEC(pythonpath_env, WSTR_OPT),
|
|
|
|
SPEC(home, WSTR_OPT),
|
|
|
|
SPEC(platlibdir, WSTR),
|
2023-10-02 19:59:05 +00:00
|
|
|
SPEC(sys_path_0, WSTR_OPT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(module_search_paths_set, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(module_search_paths, WSTR_LIST),
|
|
|
|
SPEC(stdlib_dir, WSTR_OPT),
|
|
|
|
SPEC(executable, WSTR_OPT),
|
|
|
|
SPEC(base_executable, WSTR_OPT),
|
|
|
|
SPEC(prefix, WSTR_OPT),
|
|
|
|
SPEC(base_prefix, WSTR_OPT),
|
|
|
|
SPEC(exec_prefix, WSTR_OPT),
|
|
|
|
SPEC(base_exec_prefix, WSTR_OPT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(skip_source_first_line, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
SPEC(run_command, WSTR_OPT),
|
|
|
|
SPEC(run_module, WSTR_OPT),
|
|
|
|
SPEC(run_filename, WSTR_OPT),
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(_install_importlib, BOOL),
|
|
|
|
SPEC(_init_main, BOOL),
|
|
|
|
SPEC(_is_python_build, BOOL),
|
2023-09-30 17:24:06 +00:00
|
|
|
#ifdef Py_STATS
|
2024-03-06 09:29:27 +00:00
|
|
|
SPEC(_pystats, BOOL),
|
2023-10-14 21:32:57 +00:00
|
|
|
#endif
|
|
|
|
#ifdef Py_DEBUG
|
|
|
|
SPEC(run_presite, WSTR_OPT),
|
2023-09-30 17:24:06 +00:00
|
|
|
#endif
|
|
|
|
{NULL, 0, 0},
|
|
|
|
};
|
|
|
|
|
|
|
|
#undef SPEC
|
|
|
|
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
/* --- Command line options --------------------------------------- */
|
|
|
|
|
|
|
|
/* Short usage message (with %s for argv0) */
|
|
|
|
static const char usage_line[] =
|
|
|
|
"usage: %ls [option] ... [-c cmd | -m mod | file | -] [arg] ...\n";
|
|
|
|
|
2022-06-01 09:50:01 +00:00
|
|
|
/* Long help message */
|
|
|
|
/* Lines sorted by option name; keep in sync with usage_envvars* below */
|
|
|
|
static const char usage_help[] = "\
|
|
|
|
Options (and corresponding environment variables):\n\
|
2024-03-13 13:03:13 +00:00
|
|
|
-b : issue warnings about converting bytes/bytearray to str and comparing\n\
|
|
|
|
bytes/bytearray with str or bytes with int. (-bb: issue errors)\n\
|
2019-03-01 15:25:19 +00:00
|
|
|
-B : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x\n\
|
|
|
|
-c cmd : program passed in as string (terminates option list)\n\
|
2020-12-02 17:56:17 +00:00
|
|
|
-d : turn on parser debugging output (for experts only, only works on\n\
|
|
|
|
debug builds); also PYTHONDEBUG=x\n\
|
2019-03-01 15:25:19 +00:00
|
|
|
-E : ignore PYTHON* environment variables (such as PYTHONPATH)\n\
|
2022-05-26 14:31:39 +00:00
|
|
|
-h : print this help message and exit (also -? or --help)\n\
|
2019-03-01 15:25:19 +00:00
|
|
|
-i : inspect interactively after running script; forces a prompt even\n\
|
|
|
|
if stdin does not appear to be a terminal; also PYTHONINSPECT=x\n\
|
|
|
|
-I : isolate Python from the user's environment (implies -E and -s)\n\
|
|
|
|
-m mod : run library module as a script (terminates option list)\n\
|
|
|
|
-O : remove assert and __debug__-dependent statements; add .opt-1 before\n\
|
|
|
|
.pyc extension; also PYTHONOPTIMIZE=x\n\
|
|
|
|
-OO : do -O changes and also discard docstrings; add .opt-2 before\n\
|
|
|
|
.pyc extension\n\
|
2024-02-23 09:27:07 +00:00
|
|
|
-P : don't prepend a potentially unsafe path to sys.path; also\n\
|
|
|
|
PYTHONSAFEPATH\n\
|
2019-03-01 15:25:19 +00:00
|
|
|
-q : don't print version and copyright messages on interactive startup\n\
|
2024-03-19 17:26:32 +00:00
|
|
|
-s : don't add user site directory to sys.path; also PYTHONNOUSERSITE=x\n\
|
2019-03-01 15:25:19 +00:00
|
|
|
-S : don't imply 'import site' on initialization\n\
|
|
|
|
-u : force the stdout and stderr streams to be unbuffered;\n\
|
|
|
|
this option has no effect on stdin; also PYTHONUNBUFFERED=x\n\
|
|
|
|
-v : verbose (trace import statements); also PYTHONVERBOSE=x\n\
|
|
|
|
can be supplied multiple times to increase verbosity\n\
|
|
|
|
-V : print the Python version number and exit (also --version)\n\
|
|
|
|
when given twice, print more information about the build\n\
|
|
|
|
-W arg : warning control; arg is action:message:category:module:lineno\n\
|
|
|
|
also PYTHONWARNINGS=arg\n\
|
|
|
|
-x : skip first line of source, allowing use of non-Unix forms of #!cmd\n\
|
2022-06-01 09:50:01 +00:00
|
|
|
-X opt : set implementation-specific option\n\
|
2019-03-01 15:25:19 +00:00
|
|
|
--check-hash-based-pycs always|default|never:\n\
|
2022-06-01 09:50:01 +00:00
|
|
|
control how Python invalidates hash-based .pyc files\n\
|
2024-02-23 09:27:07 +00:00
|
|
|
--help-env: print help about Python environment variables and exit\n\
|
|
|
|
--help-xoptions: print help about implementation-specific -X options and exit\n\
|
|
|
|
--help-all: print complete help information and exit\n\
|
|
|
|
\n\
|
2022-06-01 09:50:01 +00:00
|
|
|
Arguments:\n\
|
2019-03-01 15:25:19 +00:00
|
|
|
file : program read from script file\n\
|
|
|
|
- : program read from stdin (default; interactive mode if a tty)\n\
|
2022-06-01 09:50:01 +00:00
|
|
|
arg ...: arguments passed to program in sys.argv[1:]\n\
|
2019-03-01 15:25:19 +00:00
|
|
|
";
|
2022-06-01 09:50:01 +00:00
|
|
|
|
|
|
|
static const char usage_xoptions[] = "\
|
|
|
|
The following implementation-specific options are available:\n\
|
2024-03-19 17:26:32 +00:00
|
|
|
-X cpu_count=N: override the return value of os.cpu_count();\n\
|
|
|
|
-X cpu_count=default cancels overriding; also PYTHON_CPU_COUNT\n\
|
|
|
|
-X dev : enable Python Development Mode; also PYTHONDEVMODE\n\
|
|
|
|
-X faulthandler: dump the Python traceback on fatal errors;\n\
|
|
|
|
also PYTHONFAULTHANDLER\n\
|
|
|
|
-X frozen_modules=[on|off]: whether to use frozen modules; the default is \"on\"\n\
|
|
|
|
for installed Python and \"off\" for a local build;\n\
|
|
|
|
also PYTHON_FROZEN_MODULES\n\
|
2024-03-19 21:30:25 +00:00
|
|
|
"
|
|
|
|
#ifdef Py_GIL_DISABLED
|
|
|
|
"-X gil=[0|1]: enable (1) or disable (0) the GIL; also PYTHON_GIL\n"
|
|
|
|
#endif
|
|
|
|
"\
|
2024-03-19 17:26:32 +00:00
|
|
|
-X importtime: show how long each import takes; also PYTHONPROFILEIMPORTTIME\n\
|
|
|
|
-X int_max_str_digits=N: limit the size of int<->str conversions;\n\
|
|
|
|
0 disables the limit; also PYTHONINTMAXSTRDIGITS\n\
|
|
|
|
-X no_debug_ranges: don't include extra location information in code objects;\n\
|
|
|
|
also PYTHONNODEBUGRANGES\n\
|
|
|
|
-X perf: support the Linux \"perf\" profiler; also PYTHONPERFSUPPORT=1\n\
|
2024-03-13 19:15:44 +00:00
|
|
|
"
|
2023-10-14 21:32:57 +00:00
|
|
|
#ifdef Py_DEBUG
|
2024-03-19 17:26:32 +00:00
|
|
|
"-X presite=MOD: import this module before site; also PYTHON_PRESITE\n"
|
2023-10-14 21:32:57 +00:00
|
|
|
#endif
|
2024-03-13 19:15:44 +00:00
|
|
|
"\
|
2024-03-19 17:26:32 +00:00
|
|
|
-X pycache_prefix=PATH: write .pyc files to a parallel tree instead of to the\n\
|
|
|
|
code tree; also PYTHONPYCACHEPREFIX\n\
|
2024-03-13 19:15:44 +00:00
|
|
|
"
|
|
|
|
#ifdef Py_STATS
|
2024-03-19 17:26:32 +00:00
|
|
|
"-X pystats: enable pystats collection at startup; also PYTHONSTATS\n"
|
2024-03-13 19:15:44 +00:00
|
|
|
#endif
|
|
|
|
"\
|
|
|
|
-X showrefcount: output the total reference count and number of used\n\
|
|
|
|
memory blocks when the program finishes or after each statement in\n\
|
2024-03-19 17:26:32 +00:00
|
|
|
the interactive interpreter; only works on debug builds\n\
|
|
|
|
-X tracemalloc[=N]: trace Python memory allocations; N sets a traceback limit\n\
|
|
|
|
of N frames (default: 1); also PYTHONTRACEMALLOC=N\n\
|
|
|
|
-X utf8[=0|1]: enable (1) or disable (0) UTF-8 mode; also PYTHONUTF8\n\
|
|
|
|
-X warn_default_encoding: enable opt-in EncodingWarning for 'encoding=None';\n\
|
|
|
|
also PYTHONWARNDEFAULTENCODING\
|
|
|
|
";
|
2022-06-01 09:50:01 +00:00
|
|
|
|
|
|
|
/* Envvars that don't have equivalent command-line options are listed first */
|
|
|
|
static const char usage_envvars[] =
|
|
|
|
"Environment variables that change behavior:\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
"PYTHONSTARTUP : file executed on interactive startup (no default)\n"
|
|
|
|
"PYTHONPATH : '%lc'-separated list of directories prefixed to the\n"
|
|
|
|
" default module search path. The result is sys.path.\n"
|
|
|
|
"PYTHONHOME : alternate <prefix> directory (or <prefix>%lc<exec_prefix>).\n"
|
|
|
|
" The default module search path uses %s.\n"
|
2024-03-19 17:26:32 +00:00
|
|
|
"PYTHONPLATLIBDIR: override sys.platlibdir\n"
|
|
|
|
"PYTHONCASEOK : ignore case in 'import' statements (Windows)\n"
|
|
|
|
"PYTHONIOENCODING: encoding[:errors] used for stdin/stdout/stderr\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
"PYTHONHASHSEED : if this variable is set to 'random', a random value is used\n"
|
|
|
|
" to seed the hashes of str and bytes objects. It can also be\n"
|
|
|
|
" set to an integer in the range [0,4294967295] to get hash\n"
|
|
|
|
" values with a predictable seed.\n"
|
|
|
|
"PYTHONMALLOC : set the Python memory allocators and/or install debug hooks\n"
|
|
|
|
" on Python memory allocators. Use PYTHONMALLOC=debug to\n"
|
|
|
|
" install debug hooks.\n"
|
2024-06-18 17:12:58 +00:00
|
|
|
"PYTHONMALLOCSTATS: print memory allocator statistics\n"
|
2019-03-01 15:25:19 +00:00
|
|
|
"PYTHONCOERCECLOCALE: if this variable is set to 0, it disables the locale\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
" coercion behavior. Use PYTHONCOERCECLOCALE=warn to request\n"
|
|
|
|
" display of locale coercion and locale compatibility warnings\n"
|
|
|
|
" on stderr.\n"
|
2019-03-01 15:25:19 +00:00
|
|
|
"PYTHONBREAKPOINT: if this variable is set to 0, it disables the default\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
" debugger. It can be set to the callable of your debugger of\n"
|
|
|
|
" choice.\n"
|
|
|
|
"PYTHON_COLORS : if this variable is set to 1, the interpreter will colorize\n"
|
|
|
|
" various kinds of output. Setting it to 0 deactivates\n"
|
|
|
|
" this behavior.\n"
|
|
|
|
"PYTHON_HISTORY : the location of a .python_history file.\n"
|
2024-06-18 17:12:58 +00:00
|
|
|
"PYTHONASYNCIODEBUG: enable asyncio debug mode\n"
|
|
|
|
#ifdef Py_TRACE_REFS
|
|
|
|
"PYTHONDUMPREFS : dump objects and reference counts still alive after shutdown\n"
|
|
|
|
"PYTHONDUMPREFSFILE: dump objects and reference counts to the specified file\n"
|
|
|
|
#endif
|
|
|
|
#ifdef __APPLE__
|
|
|
|
"PYTHONEXECUTABLE: set sys.argv[0] to this value (macOS only)\n"
|
|
|
|
#endif
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
"PYTHONLEGACYWINDOWSFSENCODING: use legacy \"mbcs\" encoding for file system\n"
|
|
|
|
"PYTHONLEGACYWINDOWSSTDIO: use legacy Windows stdio\n"
|
|
|
|
#endif
|
|
|
|
"PYTHONUSERBASE : defines the user base directory (site.USER_BASE)\n"
|
|
|
|
"PYTHON_BASIC_REPL: use the traditional parser-based REPL\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
"\n"
|
|
|
|
"These variables have equivalent command-line options (see --help for details):\n"
|
2024-03-19 17:26:32 +00:00
|
|
|
"PYTHON_CPU_COUNT: override the return value of os.cpu_count() (-X cpu_count)\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
"PYTHONDEBUG : enable parser debug mode (-d)\n"
|
2024-03-19 17:26:32 +00:00
|
|
|
"PYTHONDEVMODE : enable Python Development Mode (-X dev)\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
"PYTHONDONTWRITEBYTECODE: don't write .pyc files (-B)\n"
|
2024-03-13 20:59:16 +00:00
|
|
|
"PYTHONFAULTHANDLER: dump the Python traceback on fatal errors (-X faulthandler)\n"
|
2024-03-19 17:26:32 +00:00
|
|
|
"PYTHON_FROZEN_MODULES: whether to use frozen modules; the default is \"on\"\n"
|
|
|
|
" for installed Python and \"off\" for a local build\n"
|
2024-03-13 20:59:16 +00:00
|
|
|
" (-X frozen_modules)\n"
|
|
|
|
#ifdef Py_GIL_DISABLED
|
|
|
|
"PYTHON_GIL : when set to 0, disables the GIL (-X gil)\n"
|
|
|
|
#endif
|
2024-02-23 09:27:07 +00:00
|
|
|
"PYTHONINSPECT : inspect interactively after running script (-i)\n"
|
2024-03-19 17:26:32 +00:00
|
|
|
"PYTHONINTMAXSTRDIGITS: limit the size of int<->str conversions;\n"
|
|
|
|
" 0 disables the limit (-X int_max_str_digits=N)\n"
|
|
|
|
"PYTHONNODEBUGRANGES: don't include extra location information in code objects\n"
|
|
|
|
" (-X no_debug_ranges)\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
"PYTHONNOUSERSITE: disable user site directory (-s)\n"
|
|
|
|
"PYTHONOPTIMIZE : enable level 1 optimizations (-O)\n"
|
2024-03-14 10:09:19 +00:00
|
|
|
"PYTHONPERFSUPPORT: support the Linux \"perf\" profiler (-X perf)\n"
|
2024-06-18 17:12:58 +00:00
|
|
|
"PYTHON_PERF_JIT_SUPPORT: enable Linux \"perf\" profiler support with JIT\n"
|
|
|
|
" (-X perf_jit)\n"
|
2024-03-13 19:15:44 +00:00
|
|
|
#ifdef Py_DEBUG
|
2024-03-19 17:26:32 +00:00
|
|
|
"PYTHON_PRESITE: import this module before site (-X presite)\n"
|
2024-03-13 19:15:44 +00:00
|
|
|
#endif
|
2024-03-14 10:09:19 +00:00
|
|
|
"PYTHONPROFILEIMPORTTIME: show how long each import takes (-X importtime)\n"
|
2024-03-13 20:59:16 +00:00
|
|
|
"PYTHONPYCACHEPREFIX: root directory for bytecode cache (pyc) files\n"
|
|
|
|
" (-X pycache_prefix)\n"
|
2024-02-23 09:27:07 +00:00
|
|
|
"PYTHONSAFEPATH : don't prepend a potentially unsafe path to sys.path.\n"
|
2023-09-06 15:54:59 +00:00
|
|
|
#ifdef Py_STATS
|
2024-03-13 20:59:16 +00:00
|
|
|
"PYTHONSTATS : turns on statistics gathering (-X pystats)\n"
|
2023-09-06 15:54:59 +00:00
|
|
|
#endif
|
2024-03-14 10:09:19 +00:00
|
|
|
"PYTHONTRACEMALLOC: trace Python memory allocations (-X tracemalloc)\n"
|
2024-03-13 19:15:44 +00:00
|
|
|
"PYTHONUNBUFFERED: disable stdout/stderr buffering (-u)\n"
|
2024-03-19 17:26:32 +00:00
|
|
|
"PYTHONUTF8 : control the UTF-8 mode (-X utf8)\n"
|
2024-03-13 19:15:44 +00:00
|
|
|
"PYTHONVERBOSE : trace import statements (-v)\n"
|
2024-03-13 20:59:16 +00:00
|
|
|
"PYTHONWARNDEFAULTENCODING: enable opt-in EncodingWarning for 'encoding=None'\n"
|
|
|
|
" (-X warn_default_encoding)\n"
|
2024-03-19 17:26:32 +00:00
|
|
|
"PYTHONWARNINGS : warning control (-W)\n"
|
2023-09-06 15:54:59 +00:00
|
|
|
;
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
#if defined(MS_WINDOWS)
|
|
|
|
# define PYTHONHOMEHELP "<prefix>\\python{major}{minor}"
|
|
|
|
#else
|
|
|
|
# define PYTHONHOMEHELP "<prefix>/lib/pythonX.X"
|
|
|
|
#endif
|
2018-08-01 15:56:14 +00:00
|
|
|
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
/* --- Global configuration variables ----------------------------- */
|
2018-08-29 11:25:36 +00:00
|
|
|
|
2018-08-01 15:56:14 +00:00
|
|
|
/* UTF-8 mode (PEP 540): if equals to 1, use the UTF-8 encoding, and change
|
2019-05-23 02:12:27 +00:00
|
|
|
stdin and stdout error handler to "surrogateescape". */
|
|
|
|
int Py_UTF8Mode = 0;
|
2018-08-01 15:56:14 +00:00
|
|
|
int Py_DebugFlag = 0; /* Needed by parser.c */
|
|
|
|
int Py_VerboseFlag = 0; /* Needed by import.c */
|
|
|
|
int Py_QuietFlag = 0; /* Needed by sysmodule.c */
|
2022-06-17 13:19:28 +00:00
|
|
|
int Py_InteractiveFlag = 0; /* Previously, was used by Py_FdIsInteractive() */
|
2018-08-01 15:56:14 +00:00
|
|
|
int Py_InspectFlag = 0; /* Needed to determine whether to exit at SystemExit */
|
|
|
|
int Py_OptimizeFlag = 0; /* Needed by compile.c */
|
|
|
|
int Py_NoSiteFlag = 0; /* Suppress 'import site' */
|
|
|
|
int Py_BytesWarningFlag = 0; /* Warn on str(bytes) and str(buffer) */
|
|
|
|
int Py_FrozenFlag = 0; /* Needed by getpath.c */
|
|
|
|
int Py_IgnoreEnvironmentFlag = 0; /* e.g. PYTHONPATH, PYTHONHOME */
|
|
|
|
int Py_DontWriteBytecodeFlag = 0; /* Suppress writing bytecode files (*.pyc) */
|
|
|
|
int Py_NoUserSiteDirectory = 0; /* for -s and site.py */
|
|
|
|
int Py_UnbufferedStdioFlag = 0; /* Unbuffered binary std{in,out,err} */
|
|
|
|
int Py_HashRandomizationFlag = 0; /* for -R and PYTHONHASHSEED */
|
|
|
|
int Py_IsolatedFlag = 0; /* for -I, isolate from user's env */
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
int Py_LegacyWindowsFSEncodingFlag = 0; /* Uses mbcs instead of utf-8 */
|
|
|
|
int Py_LegacyWindowsStdioFlag = 0; /* Uses FileIO instead of WindowsConsoleIO */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2019-03-25 22:19:57 +00:00
|
|
|
static PyObject *
|
2018-11-13 23:24:28 +00:00
|
|
|
_Py_GetGlobalVariablesAsDict(void)
|
|
|
|
{
|
2022-06-17 14:12:00 +00:00
|
|
|
_Py_COMP_DIAG_PUSH
|
|
|
|
_Py_COMP_DIAG_IGNORE_DEPR_DECLS
|
2018-11-13 23:24:28 +00:00
|
|
|
PyObject *dict, *obj;
|
|
|
|
|
|
|
|
dict = PyDict_New();
|
|
|
|
if (dict == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SET_ITEM(KEY, EXPR) \
|
|
|
|
do { \
|
|
|
|
obj = (EXPR); \
|
|
|
|
if (obj == NULL) { \
|
|
|
|
return NULL; \
|
|
|
|
} \
|
|
|
|
int res = PyDict_SetItemString(dict, (KEY), obj); \
|
|
|
|
Py_DECREF(obj); \
|
|
|
|
if (res < 0) { \
|
|
|
|
goto fail; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
#define SET_ITEM_INT(VAR) \
|
|
|
|
SET_ITEM(#VAR, PyLong_FromLong(VAR))
|
|
|
|
#define FROM_STRING(STR) \
|
|
|
|
((STR != NULL) ? \
|
|
|
|
PyUnicode_FromString(STR) \
|
2022-11-10 08:03:39 +00:00
|
|
|
: Py_NewRef(Py_None))
|
2018-11-13 23:24:28 +00:00
|
|
|
#define SET_ITEM_STR(VAR) \
|
|
|
|
SET_ITEM(#VAR, FROM_STRING(VAR))
|
|
|
|
|
|
|
|
SET_ITEM_STR(Py_FileSystemDefaultEncoding);
|
|
|
|
SET_ITEM_INT(Py_HasFileSystemDefaultEncoding);
|
|
|
|
SET_ITEM_STR(Py_FileSystemDefaultEncodeErrors);
|
|
|
|
SET_ITEM_INT(_Py_HasFileSystemDefaultEncodeErrors);
|
|
|
|
|
|
|
|
SET_ITEM_INT(Py_UTF8Mode);
|
|
|
|
SET_ITEM_INT(Py_DebugFlag);
|
|
|
|
SET_ITEM_INT(Py_VerboseFlag);
|
|
|
|
SET_ITEM_INT(Py_QuietFlag);
|
|
|
|
SET_ITEM_INT(Py_InteractiveFlag);
|
|
|
|
SET_ITEM_INT(Py_InspectFlag);
|
|
|
|
|
|
|
|
SET_ITEM_INT(Py_OptimizeFlag);
|
|
|
|
SET_ITEM_INT(Py_NoSiteFlag);
|
|
|
|
SET_ITEM_INT(Py_BytesWarningFlag);
|
|
|
|
SET_ITEM_INT(Py_FrozenFlag);
|
|
|
|
SET_ITEM_INT(Py_IgnoreEnvironmentFlag);
|
|
|
|
SET_ITEM_INT(Py_DontWriteBytecodeFlag);
|
|
|
|
SET_ITEM_INT(Py_NoUserSiteDirectory);
|
|
|
|
SET_ITEM_INT(Py_UnbufferedStdioFlag);
|
|
|
|
SET_ITEM_INT(Py_HashRandomizationFlag);
|
|
|
|
SET_ITEM_INT(Py_IsolatedFlag);
|
|
|
|
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
SET_ITEM_INT(Py_LegacyWindowsFSEncodingFlag);
|
|
|
|
SET_ITEM_INT(Py_LegacyWindowsStdioFlag);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return dict;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
Py_DECREF(dict);
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
#undef FROM_STRING
|
|
|
|
#undef SET_ITEM
|
|
|
|
#undef SET_ITEM_INT
|
|
|
|
#undef SET_ITEM_STR
|
2022-06-17 14:12:00 +00:00
|
|
|
_Py_COMP_DIAG_POP
|
2018-11-13 23:24:28 +00:00
|
|
|
}
|
|
|
|
|
2021-10-13 01:39:50 +00:00
|
|
|
char*
|
|
|
|
Py_GETENV(const char *name)
|
|
|
|
{
|
2022-06-17 14:12:00 +00:00
|
|
|
_Py_COMP_DIAG_PUSH
|
|
|
|
_Py_COMP_DIAG_IGNORE_DEPR_DECLS
|
2021-10-13 01:39:50 +00:00
|
|
|
if (Py_IgnoreEnvironmentFlag) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return getenv(name);
|
2022-06-17 14:12:00 +00:00
|
|
|
_Py_COMP_DIAG_POP
|
2021-10-13 01:39:50 +00:00
|
|
|
}
|
2018-11-13 23:24:28 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
/* --- PyStatus ----------------------------------------------- */
|
2019-05-17 21:54:00 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus PyStatus_Ok(void)
|
|
|
|
{ return _PyStatus_OK(); }
|
2019-05-17 21:54:00 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus PyStatus_Error(const char *err_msg)
|
2019-05-17 21:54:00 +00:00
|
|
|
{
|
2020-11-04 23:45:56 +00:00
|
|
|
assert(err_msg != NULL);
|
2019-05-27 14:39:22 +00:00
|
|
|
return (PyStatus){._type = _PyStatus_TYPE_ERROR,
|
2020-11-04 23:45:56 +00:00
|
|
|
.err_msg = err_msg};
|
2019-05-17 21:54:00 +00:00
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus PyStatus_NoMemory(void)
|
|
|
|
{ return PyStatus_Error("memory allocation failed"); }
|
2019-05-17 21:54:00 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus PyStatus_Exit(int exitcode)
|
|
|
|
{ return _PyStatus_EXIT(exitcode); }
|
2019-05-17 21:54:00 +00:00
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
int PyStatus_IsError(PyStatus status)
|
|
|
|
{ return _PyStatus_IS_ERROR(status); }
|
2019-05-17 21:54:00 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
int PyStatus_IsExit(PyStatus status)
|
|
|
|
{ return _PyStatus_IS_EXIT(status); }
|
2019-05-17 21:54:00 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
int PyStatus_Exception(PyStatus status)
|
|
|
|
{ return _PyStatus_EXCEPTION(status); }
|
2019-05-17 21:54:00 +00:00
|
|
|
|
2023-09-01 10:43:30 +00:00
|
|
|
void
|
2020-11-04 23:45:56 +00:00
|
|
|
_PyErr_SetFromPyStatus(PyStatus status)
|
|
|
|
{
|
|
|
|
if (!_PyStatus_IS_ERROR(status)) {
|
|
|
|
PyErr_Format(PyExc_SystemError,
|
2023-09-01 10:43:30 +00:00
|
|
|
"_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;
|
2020-11-04 23:45:56 +00:00
|
|
|
}
|
2023-09-01 10:43:30 +00:00
|
|
|
|
|
|
|
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);
|
2020-11-04 23:45:56 +00:00
|
|
|
}
|
|
|
|
else {
|
2023-09-01 10:43:30 +00:00
|
|
|
PyErr_Format(PyExc_RuntimeError, "%s", err_msg);
|
2020-11-04 23:45:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-17 21:54:00 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
/* --- PyWideStringList ------------------------------------------------ */
|
2019-03-15 14:08:05 +00:00
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
int
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_CheckConsistency(const PyWideStringList *list)
|
2019-03-15 14:08:05 +00:00
|
|
|
{
|
|
|
|
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 */
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2018-08-01 15:56:14 +00:00
|
|
|
void
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Clear(PyWideStringList *list)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
assert(_PyWideStringList_CheckConsistency(list));
|
2019-03-15 14:08:05 +00:00
|
|
|
for (Py_ssize_t i=0; i < list->length; i++) {
|
|
|
|
PyMem_RawFree(list->items[i]);
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
2019-03-15 14:08:05 +00:00
|
|
|
PyMem_RawFree(list->items);
|
|
|
|
list->length = 0;
|
|
|
|
list->items = NULL;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-15 14:08:05 +00:00
|
|
|
int
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Copy(PyWideStringList *list, const PyWideStringList *list2)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
assert(_PyWideStringList_CheckConsistency(list));
|
|
|
|
assert(_PyWideStringList_CheckConsistency(list2));
|
2019-03-15 14:08:05 +00:00
|
|
|
|
|
|
|
if (list2->length == 0) {
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Clear(list);
|
2019-03-15 14:08:05 +00:00
|
|
|
return 0;
|
2018-08-24 23:34:56 +00:00
|
|
|
}
|
2019-03-15 14:08:05 +00:00
|
|
|
|
2019-09-29 23:40:17 +00:00
|
|
|
PyWideStringList copy = _PyWideStringList_INIT;
|
2019-03-15 14:08:05 +00:00
|
|
|
|
|
|
|
size_t size = list2->length * sizeof(list2->items[0]);
|
|
|
|
copy.items = PyMem_RawMalloc(size);
|
|
|
|
if (copy.items == NULL) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (Py_ssize_t i=0; i < list2->length; i++) {
|
|
|
|
wchar_t *item = _PyMem_RawWcsdup(list2->items[i]);
|
|
|
|
if (item == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Clear(©);
|
2019-03-15 14:08:05 +00:00
|
|
|
return -1;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
2019-03-15 14:08:05 +00:00
|
|
|
copy.items[i] = item;
|
|
|
|
copy.length = i + 1;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
2019-03-15 14:08:05 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Clear(list);
|
2019-03-15 14:08:05 +00:00
|
|
|
*list = copy;
|
|
|
|
return 0;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
2019-08-23 15:57:54 +00:00
|
|
|
PyWideStringList_Insert(PyWideStringList *list,
|
|
|
|
Py_ssize_t index, const wchar_t *item)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-08-23 15:57:54 +00:00
|
|
|
Py_ssize_t len = list->length;
|
|
|
|
if (len == PY_SSIZE_T_MAX) {
|
2019-07-21 20:12:33 +00:00
|
|
|
/* length+1 would overflow */
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
2019-08-23 15:57:54 +00:00
|
|
|
if (index < 0) {
|
|
|
|
return _PyStatus_ERR("PyWideStringList_Insert index must be >= 0");
|
|
|
|
}
|
|
|
|
if (index > len) {
|
|
|
|
index = len;
|
|
|
|
}
|
2019-03-15 14:08:05 +00:00
|
|
|
|
|
|
|
wchar_t *item2 = _PyMem_RawWcsdup(item);
|
|
|
|
if (item2 == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2019-08-23 15:57:54 +00:00
|
|
|
size_t size = (len + 1) * sizeof(list->items[0]);
|
2019-03-15 14:08:05 +00:00
|
|
|
wchar_t **items2 = (wchar_t **)PyMem_RawRealloc(list->items, size);
|
|
|
|
if (items2 == NULL) {
|
|
|
|
PyMem_RawFree(item2);
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
2019-03-15 14:08:05 +00:00
|
|
|
|
2019-08-23 15:57:54 +00:00
|
|
|
if (index < len) {
|
|
|
|
memmove(&items2[index + 1],
|
|
|
|
&items2[index],
|
|
|
|
(len - index) * sizeof(items2[0]));
|
|
|
|
}
|
|
|
|
|
|
|
|
items2[index] = item2;
|
2019-03-15 14:08:05 +00:00
|
|
|
list->items = items2;
|
|
|
|
list->length++;
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-03-15 14:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-08-23 15:57:54 +00:00
|
|
|
PyStatus
|
|
|
|
PyWideStringList_Append(PyWideStringList *list, const wchar_t *item)
|
|
|
|
{
|
|
|
|
return PyWideStringList_Insert(list, list->length, item);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
|
|
|
_PyWideStringList_Extend(PyWideStringList *list, const PyWideStringList *list2)
|
2019-03-15 14:08:05 +00:00
|
|
|
{
|
|
|
|
for (Py_ssize_t i = 0; i < list2->length; i++) {
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status = PyWideStringList_Append(list, list2->items[i]);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-03-15 14:08:05 +00:00
|
|
|
}
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-26 15:58:50 +00:00
|
|
|
static int
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Find(PyWideStringList *list, const wchar_t *item)
|
2019-03-26 15:58:50 +00:00
|
|
|
{
|
|
|
|
for (Py_ssize_t i = 0; i < list->length; i++) {
|
|
|
|
if (wcscmp(list->items[i], item) == 0) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
PyObject*
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_AsList(const PyWideStringList *list)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
assert(_PyWideStringList_CheckConsistency(list));
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2019-03-15 14:08:05 +00:00
|
|
|
PyObject *pylist = PyList_New(list->length);
|
2019-03-01 15:25:19 +00:00
|
|
|
if (pylist == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-03-15 14:08:05 +00:00
|
|
|
for (Py_ssize_t i = 0; i < list->length; i++) {
|
|
|
|
PyObject *item = PyUnicode_FromWideChar(list->items[i], -1);
|
|
|
|
if (item == NULL) {
|
2019-03-01 15:25:19 +00:00
|
|
|
Py_DECREF(pylist);
|
|
|
|
return NULL;
|
|
|
|
}
|
2019-03-15 14:08:05 +00:00
|
|
|
PyList_SET_ITEM(pylist, i, item);
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
return pylist;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* --- Py_GetArgcArgv() ------------------------------------------- */
|
|
|
|
|
|
|
|
void
|
|
|
|
_Py_ClearArgcArgv(void)
|
|
|
|
{
|
|
|
|
PyMemAllocatorEx old_alloc;
|
|
|
|
_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
|
|
|
|
|
2022-12-07 22:56:31 +00:00
|
|
|
_PyWideStringList_Clear(&_PyRuntime.orig_argv);
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-06 00:44:31 +00:00
|
|
|
static int
|
2019-03-15 14:08:05 +00:00
|
|
|
_Py_SetArgcArgv(Py_ssize_t argc, wchar_t * const *argv)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
const PyWideStringList argv_list = {.length = argc, .items = (wchar_t **)argv};
|
2019-03-01 15:25:19 +00:00
|
|
|
int res;
|
|
|
|
|
|
|
|
PyMemAllocatorEx old_alloc;
|
|
|
|
_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
|
|
|
|
|
2022-12-07 22:56:31 +00:00
|
|
|
// XXX _PyRuntime.orig_argv only gets cleared by Py_Main(),
|
2023-07-01 19:47:14 +00:00
|
|
|
// so it currently leaks for embedders.
|
2022-12-07 22:56:31 +00:00
|
|
|
res = _PyWideStringList_Copy(&_PyRuntime.orig_argv, &argv_list);
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-11-02 15:49:54 +00:00
|
|
|
// _PyConfig_Write() calls _Py_SetArgcArgv() with PyConfig.orig_argv.
|
2019-03-01 15:25:19 +00:00
|
|
|
void
|
|
|
|
Py_GetArgcArgv(int *argc, wchar_t ***argv)
|
|
|
|
{
|
2022-12-07 22:56:31 +00:00
|
|
|
*argc = (int)_PyRuntime.orig_argv.length;
|
|
|
|
*argv = _PyRuntime.orig_argv.items;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
/* --- PyConfig ---------------------------------------------- */
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2020-11-05 17:12:33 +00:00
|
|
|
#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);
|
2021-12-02 10:43:37 +00:00
|
|
|
assert(config->code_debug_ranges >= 0);
|
2020-11-05 17:12:33 +00:00
|
|
|
assert(config->show_ref_count >= 0);
|
|
|
|
assert(config->dump_refs >= 0);
|
|
|
|
assert(config->malloc_stats >= 0);
|
|
|
|
assert(config->site_import >= 0);
|
|
|
|
assert(config->bytes_warning >= 0);
|
2021-03-29 03:28:14 +00:00
|
|
|
assert(config->warn_default_encoding >= 0);
|
2020-11-05 17:12:33 +00:00
|
|
|
assert(config->inspect >= 0);
|
|
|
|
assert(config->interactive >= 0);
|
|
|
|
assert(config->optimization_level >= 0);
|
|
|
|
assert(config->parser_debug >= 0);
|
|
|
|
assert(config->write_bytecode >= 0);
|
|
|
|
assert(config->verbose >= 0);
|
|
|
|
assert(config->quiet >= 0);
|
|
|
|
assert(config->user_site_directory >= 0);
|
|
|
|
assert(config->parse_argv >= 0);
|
|
|
|
assert(config->configure_c_stdio >= 0);
|
|
|
|
assert(config->buffered_stdio >= 0);
|
|
|
|
assert(_PyWideStringList_CheckConsistency(&config->orig_argv));
|
|
|
|
assert(_PyWideStringList_CheckConsistency(&config->argv));
|
|
|
|
/* sys.argv must be non-empty: empty argv is replaced with [''] */
|
|
|
|
assert(config->argv.length >= 1);
|
|
|
|
assert(_PyWideStringList_CheckConsistency(&config->xoptions));
|
|
|
|
assert(_PyWideStringList_CheckConsistency(&config->warnoptions));
|
|
|
|
assert(_PyWideStringList_CheckConsistency(&config->module_search_paths));
|
|
|
|
assert(config->module_search_paths_set >= 0);
|
|
|
|
assert(config->filesystem_encoding != NULL);
|
|
|
|
assert(config->filesystem_errors != NULL);
|
|
|
|
assert(config->stdio_encoding != NULL);
|
|
|
|
assert(config->stdio_errors != NULL);
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
assert(config->legacy_windows_stdio >= 0);
|
|
|
|
#endif
|
|
|
|
/* -c and -m options are exclusive */
|
|
|
|
assert(!(config->run_command != NULL && config->run_module != NULL));
|
|
|
|
assert(config->check_hash_pycs_mode != NULL);
|
|
|
|
assert(config->_install_importlib >= 0);
|
|
|
|
assert(config->pathconfig_warnings >= 0);
|
2022-05-05 23:34:11 +00:00
|
|
|
assert(config->_is_python_build >= 0);
|
|
|
|
assert(config->safe_path >= 0);
|
2022-10-03 20:55:45 +00:00
|
|
|
assert(config->int_max_str_digits >= 0);
|
2023-10-10 10:00:09 +00:00
|
|
|
// cpu_count can be -1 if the user doesn't override it.
|
|
|
|
assert(config->cpu_count != 0);
|
2022-05-05 23:34:11 +00:00
|
|
|
// config->use_frozen_modules is initialized later
|
|
|
|
// by _PyConfig_InitImportConfig().
|
2023-09-06 15:54:59 +00:00
|
|
|
#ifdef Py_STATS
|
|
|
|
assert(config->_pystats >= 0);
|
|
|
|
#endif
|
2020-11-05 17:12:33 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-09-28 02:28:35 +00:00
|
|
|
|
2018-08-01 15:56:14 +00:00
|
|
|
/* Free memory allocated in config, but don't clear all attributes */
|
|
|
|
void
|
2019-05-27 14:39:22 +00:00
|
|
|
PyConfig_Clear(PyConfig *config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
|
|
|
#define CLEAR(ATTR) \
|
|
|
|
do { \
|
|
|
|
PyMem_RawFree(ATTR); \
|
|
|
|
ATTR = NULL; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
CLEAR(config->pycache_prefix);
|
2019-05-27 14:39:22 +00:00
|
|
|
CLEAR(config->pythonpath_env);
|
2018-08-01 15:56:14 +00:00
|
|
|
CLEAR(config->home);
|
|
|
|
CLEAR(config->program_name);
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Clear(&config->argv);
|
|
|
|
_PyWideStringList_Clear(&config->warnoptions);
|
|
|
|
_PyWideStringList_Clear(&config->xoptions);
|
|
|
|
_PyWideStringList_Clear(&config->module_search_paths);
|
|
|
|
config->module_search_paths_set = 0;
|
2021-09-28 18:18:28 +00:00
|
|
|
CLEAR(config->stdlib_dir);
|
2018-08-01 15:56:14 +00:00
|
|
|
|
|
|
|
CLEAR(config->executable);
|
2019-06-29 17:34:11 +00:00
|
|
|
CLEAR(config->base_executable);
|
2018-08-01 15:56:14 +00:00
|
|
|
CLEAR(config->prefix);
|
|
|
|
CLEAR(config->base_prefix);
|
|
|
|
CLEAR(config->exec_prefix);
|
|
|
|
CLEAR(config->base_exec_prefix);
|
2020-06-08 15:28:11 +00:00
|
|
|
CLEAR(config->platlibdir);
|
2023-10-02 19:59:05 +00:00
|
|
|
CLEAR(config->sys_path_0);
|
2018-08-29 09:47:29 +00:00
|
|
|
|
2018-08-29 11:25:36 +00:00
|
|
|
CLEAR(config->filesystem_encoding);
|
|
|
|
CLEAR(config->filesystem_errors);
|
2018-08-29 09:47:29 +00:00
|
|
|
CLEAR(config->stdio_encoding);
|
|
|
|
CLEAR(config->stdio_errors);
|
2019-03-06 00:44:31 +00:00
|
|
|
CLEAR(config->run_command);
|
|
|
|
CLEAR(config->run_module);
|
|
|
|
CLEAR(config->run_filename);
|
2019-05-02 03:51:56 +00:00
|
|
|
CLEAR(config->check_hash_pycs_mode);
|
2023-10-14 21:32:57 +00:00
|
|
|
#ifdef Py_DEBUG
|
|
|
|
CLEAR(config->run_presite);
|
|
|
|
#endif
|
2020-06-15 14:27:47 +00:00
|
|
|
|
2020-06-29 22:49:03 +00:00
|
|
|
_PyWideStringList_Clear(&config->orig_argv);
|
2018-08-01 15:56:14 +00:00
|
|
|
#undef CLEAR
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-10-01 10:06:16 +00:00
|
|
|
void
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyConfig_InitCompatConfig(PyConfig *config)
|
2019-05-17 17:01:14 +00:00
|
|
|
{
|
2019-05-18 01:21:27 +00:00
|
|
|
memset(config, 0, sizeof(*config));
|
|
|
|
|
2019-05-22 21:58:50 +00:00
|
|
|
config->_config_init = (int)_PyConfig_INIT_COMPAT;
|
2019-05-18 01:21:27 +00:00
|
|
|
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;
|
2022-08-30 17:11:18 +00:00
|
|
|
config->perf_profiling = -1;
|
2019-05-27 14:39:22 +00:00
|
|
|
config->module_search_paths_set = 0;
|
2019-05-18 01:21:27 +00:00
|
|
|
config->parse_argv = 0;
|
|
|
|
config->site_import = -1;
|
|
|
|
config->bytes_warning = -1;
|
2021-03-29 03:28:14 +00:00
|
|
|
config->warn_default_encoding = 0;
|
2019-05-18 01:21:27 +00:00
|
|
|
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
|
2022-05-03 22:20:13 +00:00
|
|
|
#ifdef Py_DEBUG
|
|
|
|
config->use_frozen_modules = 0;
|
|
|
|
#else
|
|
|
|
config->use_frozen_modules = 1;
|
|
|
|
#endif
|
2022-05-05 23:34:11 +00:00
|
|
|
config->safe_path = 0;
|
2022-10-03 20:55:45 +00:00
|
|
|
config->int_max_str_digits = -1;
|
2021-12-03 00:08:42 +00:00
|
|
|
config->_is_python_build = 0;
|
2021-12-02 10:43:37 +00:00
|
|
|
config->code_debug_ranges = 1;
|
2023-10-10 10:00:09 +00:00
|
|
|
config->cpu_count = -1;
|
2024-03-11 15:02:58 +00:00
|
|
|
#ifdef Py_GIL_DISABLED
|
|
|
|
config->enable_gil = _PyConfig_GIL_DEFAULT;
|
|
|
|
#endif
|
2019-05-18 01:21:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-10-01 10:06:16 +00:00
|
|
|
static void
|
2019-05-27 14:39:22 +00:00
|
|
|
config_init_defaults(PyConfig *config)
|
2019-05-18 01:21:27 +00:00
|
|
|
{
|
2019-10-01 10:06:16 +00:00
|
|
|
_PyConfig_InitCompatConfig(config);
|
2019-05-18 01:21:27 +00:00
|
|
|
|
|
|
|
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
|
2019-05-17 17:01:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-10-01 10:06:16 +00:00
|
|
|
void
|
2019-05-27 14:39:22 +00:00
|
|
|
PyConfig_InitPythonConfig(PyConfig *config)
|
2019-05-17 17:01:14 +00:00
|
|
|
{
|
2019-10-01 10:06:16 +00:00
|
|
|
config_init_defaults(config);
|
2019-05-17 17:01:14 +00:00
|
|
|
|
2019-05-22 21:58:50 +00:00
|
|
|
config->_config_init = (int)_PyConfig_INIT_PYTHON;
|
2019-05-17 17:01:14 +00:00
|
|
|
config->configure_c_stdio = 1;
|
|
|
|
config->parse_argv = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-10-01 10:06:16 +00:00
|
|
|
void
|
2019-05-27 14:39:22 +00:00
|
|
|
PyConfig_InitIsolatedConfig(PyConfig *config)
|
2019-05-17 17:01:14 +00:00
|
|
|
{
|
2019-10-01 10:06:16 +00:00
|
|
|
config_init_defaults(config);
|
2019-05-17 17:01:14 +00:00
|
|
|
|
2019-05-22 21:58:50 +00:00
|
|
|
config->_config_init = (int)_PyConfig_INIT_ISOLATED;
|
2019-05-17 17:01:14 +00:00
|
|
|
config->isolated = 1;
|
|
|
|
config->use_environment = 0;
|
2019-05-18 01:21:27 +00:00
|
|
|
config->user_site_directory = 0;
|
2019-05-17 17:01:14 +00:00
|
|
|
config->dev_mode = 0;
|
|
|
|
config->install_signal_handlers = 0;
|
|
|
|
config->use_hash_seed = 0;
|
|
|
|
config->faulthandler = 0;
|
|
|
|
config->tracemalloc = 0;
|
2022-08-30 17:11:18 +00:00
|
|
|
config->perf_profiling = 0;
|
2022-10-03 20:55:45 +00:00
|
|
|
config->int_max_str_digits = _PY_LONG_DEFAULT_MAX_STR_DIGITS;
|
2022-05-05 23:34:11 +00:00
|
|
|
config->safe_path = 1;
|
2019-05-17 17:01:14 +00:00
|
|
|
config->pathconfig_warnings = 0;
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
config->legacy_windows_stdio = 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-01 13:22:52 +00:00
|
|
|
/* Copy str into *config_str (duplicate the string) */
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
|
|
|
PyConfig_SetString(PyConfig *config, wchar_t **config_str, const wchar_t *str)
|
2019-05-01 13:22:52 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status = _Py_PreInitializeFromConfig(config, NULL);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-05-20 09:02:00 +00:00
|
|
|
}
|
|
|
|
|
2019-05-01 13:22:52 +00:00
|
|
|
wchar_t *str2;
|
|
|
|
if (str != NULL) {
|
|
|
|
str2 = _PyMem_RawWcsdup(str);
|
|
|
|
if (str2 == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-05-01 13:22:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
str2 = NULL;
|
|
|
|
}
|
|
|
|
PyMem_RawFree(*config_str);
|
|
|
|
*config_str = str2;
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-05-01 13:22:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_set_bytes_string(PyConfig *config, wchar_t **config_str,
|
|
|
|
const char *str, const char *decode_err_msg)
|
2019-05-01 13:22:52 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status = _Py_PreInitializeFromConfig(config, NULL);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-05-02 19:25:34 +00:00
|
|
|
}
|
|
|
|
|
2019-05-01 13:22:52 +00:00
|
|
|
wchar_t *str2;
|
|
|
|
if (str != NULL) {
|
|
|
|
size_t len;
|
|
|
|
str2 = Py_DecodeLocale(str, &len);
|
|
|
|
if (str2 == NULL) {
|
|
|
|
if (len == (size_t)-2) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_ERR(decode_err_msg);
|
2019-05-01 13:22:52 +00:00
|
|
|
}
|
|
|
|
else {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-05-01 13:22:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
str2 = NULL;
|
|
|
|
}
|
|
|
|
PyMem_RawFree(*config_str);
|
|
|
|
*config_str = str2;
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-05-01 13:22:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
#define CONFIG_SET_BYTES_STR(config, config_str, str, NAME) \
|
|
|
|
config_set_bytes_string(config, config_str, str, "cannot decode " NAME)
|
2019-05-02 18:56:30 +00:00
|
|
|
|
|
|
|
|
2019-05-02 19:25:34 +00:00
|
|
|
/* Decode str using Py_DecodeLocale() and set the result into *config_str.
|
|
|
|
Pre-initialize Python if needed to ensure that encodings are properly
|
|
|
|
configured. */
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
|
|
|
PyConfig_SetBytesString(PyConfig *config, wchar_t **config_str,
|
2020-10-31 00:02:09 +00:00
|
|
|
const char *str)
|
2019-05-01 13:22:52 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
return CONFIG_SET_BYTES_STR(config, config_str, str, "string");
|
2019-05-01 13:22:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
|
|
|
_PyConfig_Copy(PyConfig *config, const PyConfig *config2)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyConfig_Clear(config);
|
2018-08-01 15:56:14 +00:00
|
|
|
|
2023-09-30 17:24:06 +00:00
|
|
|
PyStatus status;
|
|
|
|
const PyConfigSpec *spec = PYCONFIG_SPEC;
|
|
|
|
for (; spec->name != NULL; spec++) {
|
|
|
|
char *member = (char *)config + spec->offset;
|
|
|
|
char *member2 = (char *)config2 + spec->offset;
|
|
|
|
switch (spec->type) {
|
|
|
|
case PyConfig_MEMBER_INT:
|
|
|
|
case PyConfig_MEMBER_UINT:
|
2024-03-06 09:29:27 +00:00
|
|
|
case PyConfig_MEMBER_BOOL:
|
2023-09-30 17:24:06 +00:00
|
|
|
{
|
|
|
|
*(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();
|
|
|
|
}
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-11-05 17:12:33 +00:00
|
|
|
PyObject *
|
|
|
|
_PyConfig_AsDict(const PyConfig *config)
|
2019-03-26 15:58:50 +00:00
|
|
|
{
|
2020-07-07 22:20:37 +00:00
|
|
|
PyObject *dict = PyDict_New();
|
2019-03-26 15:58:50 +00:00
|
|
|
if (dict == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2023-09-30 17:24:06 +00:00
|
|
|
const PyConfigSpec *spec = PYCONFIG_SPEC;
|
|
|
|
for (; spec->name != NULL; spec++) {
|
|
|
|
char *member = (char *)config + spec->offset;
|
|
|
|
PyObject *obj;
|
|
|
|
switch (spec->type) {
|
|
|
|
case PyConfig_MEMBER_INT:
|
|
|
|
case PyConfig_MEMBER_UINT:
|
|
|
|
{
|
|
|
|
int value = *(int*)member;
|
|
|
|
obj = PyLong_FromLong(value);
|
|
|
|
break;
|
|
|
|
}
|
2024-03-06 09:29:27 +00:00
|
|
|
case PyConfig_MEMBER_BOOL:
|
|
|
|
{
|
|
|
|
int value = *(int*)member;
|
|
|
|
obj = PyBool_FromLong(value);
|
|
|
|
break;
|
|
|
|
}
|
2023-09-30 17:24:06 +00:00
|
|
|
case PyConfig_MEMBER_ULONG:
|
|
|
|
{
|
|
|
|
unsigned long value = *(unsigned long*)member;
|
|
|
|
obj = PyLong_FromUnsignedLong(value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PyConfig_MEMBER_WSTR:
|
|
|
|
case PyConfig_MEMBER_WSTR_OPT:
|
|
|
|
{
|
|
|
|
const wchar_t *wstr = *(const wchar_t**)member;
|
|
|
|
if (wstr != NULL) {
|
|
|
|
obj = PyUnicode_FromWideChar(wstr, -1);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
obj = Py_NewRef(Py_None);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PyConfig_MEMBER_WSTR_LIST:
|
|
|
|
{
|
|
|
|
const PyWideStringList *list = (const PyWideStringList*)member;
|
|
|
|
obj = _PyWideStringList_AsList(list);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
Py_UNREACHABLE();
|
|
|
|
}
|
2019-03-26 15:58:50 +00:00
|
|
|
|
2023-09-30 17:24:06 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
2019-03-26 15:58:50 +00:00
|
|
|
return dict;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-11-05 17:12:33 +00:00
|
|
|
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;
|
|
|
|
}
|
2023-08-24 23:01:30 +00:00
|
|
|
int value = PyLong_AsInt(item);
|
2023-08-23 21:12:08 +00:00
|
|
|
Py_DECREF(item);
|
2020-11-05 17:12:33 +00:00
|
|
|
if (value == -1 && PyErr_Occurred()) {
|
|
|
|
if (PyErr_ExceptionMatches(PyExc_TypeError)) {
|
|
|
|
config_dict_invalid_type(name);
|
|
|
|
}
|
2020-11-24 12:07:32 +00:00
|
|
|
else if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
|
2020-11-05 17:12:33 +00:00
|
|
|
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);
|
2023-08-23 21:12:08 +00:00
|
|
|
Py_DECREF(item);
|
2020-11-05 17:12:33 +00:00
|
|
|
if (value == (unsigned long)-1 && PyErr_Occurred()) {
|
2020-11-24 12:07:32 +00:00
|
|
|
if (PyErr_ExceptionMatches(PyExc_TypeError)) {
|
|
|
|
config_dict_invalid_type(name);
|
|
|
|
}
|
|
|
|
else if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
|
|
|
|
config_dict_invalid_value(name);
|
|
|
|
}
|
2020-11-05 17:12:33 +00:00
|
|
|
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;
|
|
|
|
}
|
2023-08-23 21:12:08 +00:00
|
|
|
|
2020-11-05 17:12:33 +00:00
|
|
|
PyStatus status;
|
|
|
|
if (item == Py_None) {
|
|
|
|
status = PyConfig_SetString(config, result, NULL);
|
|
|
|
}
|
|
|
|
else if (!PyUnicode_Check(item)) {
|
|
|
|
config_dict_invalid_type(name);
|
2023-08-23 21:12:08 +00:00
|
|
|
goto error;
|
2020-11-05 17:12:33 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
wchar_t *wstr = PyUnicode_AsWideCharString(item, NULL);
|
|
|
|
if (wstr == NULL) {
|
2023-08-23 21:12:08 +00:00
|
|
|
goto error;
|
2020-11-05 17:12:33 +00:00
|
|
|
}
|
|
|
|
status = PyConfig_SetString(config, result, wstr);
|
|
|
|
PyMem_Free(wstr);
|
|
|
|
}
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
PyErr_NoMemory();
|
2023-08-23 21:12:08 +00:00
|
|
|
goto error;
|
2020-11-05 17:12:33 +00:00
|
|
|
}
|
2023-08-23 21:12:08 +00:00
|
|
|
Py_DECREF(item);
|
2020-11-05 17:12:33 +00:00
|
|
|
return 0;
|
2023-08-23 21:12:08 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
Py_DECREF(item);
|
|
|
|
return -1;
|
2020-11-05 17:12:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!PyList_CheckExact(list)) {
|
2023-08-23 21:12:08 +00:00
|
|
|
Py_DECREF(list);
|
2020-11-05 17:12:33 +00:00
|
|
|
config_dict_invalid_type(name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
PyWideStringList wstrlist = _PyWideStringList_INIT;
|
|
|
|
for (Py_ssize_t i=0; i < PyList_GET_SIZE(list); i++) {
|
|
|
|
PyObject *item = PyList_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);
|
2023-08-23 21:12:08 +00:00
|
|
|
Py_DECREF(list);
|
2020-11-05 17:12:33 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
_PyWideStringList_Clear(&wstrlist);
|
2023-08-23 21:12:08 +00:00
|
|
|
Py_DECREF(list);
|
2020-11-05 17:12:33 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
_PyConfig_FromDict(PyConfig *config, PyObject *dict)
|
|
|
|
{
|
|
|
|
if (!PyDict_Check(dict)) {
|
|
|
|
PyErr_SetString(PyExc_TypeError, "dict expected");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2023-09-30 17:24:06 +00:00
|
|
|
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:
|
2024-03-06 09:29:27 +00:00
|
|
|
case PyConfig_MEMBER_BOOL:
|
2023-09-30 17:24:06 +00:00
|
|
|
{
|
|
|
|
int value;
|
|
|
|
if (config_dict_get_int(dict, spec->name, &value) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
2024-03-06 09:29:27 +00:00
|
|
|
if (spec->type == PyConfig_MEMBER_BOOL
|
|
|
|
|| spec->type == PyConfig_MEMBER_UINT)
|
|
|
|
{
|
|
|
|
if (value < 0) {
|
|
|
|
config_dict_invalid_value(spec->name);
|
|
|
|
return -1;
|
|
|
|
}
|
2023-09-30 17:24:06 +00:00
|
|
|
}
|
|
|
|
*(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 (config_dict_get_wstrlist(dict, spec->name, config,
|
|
|
|
(PyWideStringList*)member) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
Py_UNREACHABLE();
|
|
|
|
}
|
2020-11-05 17:12:33 +00:00
|
|
|
}
|
|
|
|
|
2023-09-30 17:24:06 +00:00
|
|
|
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");
|
2020-11-05 17:12:33 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2023-09-30 17:24:06 +00:00
|
|
|
if (config->hash_seed > MAX_HASH_SEED) {
|
|
|
|
config_dict_invalid_value("hash_seed");
|
|
|
|
return -1;
|
|
|
|
}
|
2020-11-05 17:12:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-25 23:03:15 +00:00
|
|
|
static const char*
|
2019-05-27 14:39:22 +00:00
|
|
|
config_get_env(const PyConfig *config, const char *name)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2019-03-26 01:31:11 +00:00
|
|
|
return _Py_GetEnv(config->use_environment, name);
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-26 15:58:50 +00:00
|
|
|
/* 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. */
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_get_env_dup(PyConfig *config,
|
|
|
|
wchar_t **dest,
|
|
|
|
wchar_t *wname, char *name,
|
|
|
|
const char *decode_err_msg)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2019-05-01 13:22:52 +00:00
|
|
|
assert(*dest == NULL);
|
2019-03-26 01:31:11 +00:00
|
|
|
assert(config->use_environment >= 0);
|
2018-08-01 15:56:14 +00:00
|
|
|
|
2019-03-26 01:31:11 +00:00
|
|
|
if (!config->use_environment) {
|
2018-08-01 15:56:14 +00:00
|
|
|
*dest = NULL;
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
const wchar_t *var = _wgetenv(wname);
|
|
|
|
if (!var || var[0] == '\0') {
|
|
|
|
*dest = NULL;
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
return PyConfig_SetString(config, dest, var);
|
2018-08-01 15:56:14 +00:00
|
|
|
#else
|
|
|
|
const char *var = getenv(name);
|
|
|
|
if (!var || var[0] == '\0') {
|
|
|
|
*dest = NULL;
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
return config_set_bytes_string(config, dest, var, decode_err_msg);
|
2018-08-01 15:56:14 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-01 13:22:52 +00:00
|
|
|
#define CONFIG_GET_ENV_DUP(CONFIG, DEST, WNAME, NAME) \
|
2019-05-27 14:39:22 +00:00
|
|
|
config_get_env_dup(CONFIG, DEST, WNAME, NAME, "cannot decode " NAME)
|
2019-05-01 13:22:52 +00:00
|
|
|
|
|
|
|
|
2019-03-26 15:58:50 +00:00
|
|
|
static void
|
2019-05-27 14:39:22 +00:00
|
|
|
config_get_global_vars(PyConfig *config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2022-06-17 14:12:00 +00:00
|
|
|
_Py_COMP_DIAG_PUSH
|
|
|
|
_Py_COMP_DIAG_IGNORE_DEPR_DECLS
|
2019-05-22 21:58:50 +00:00
|
|
|
if (config->_config_init != _PyConfig_INIT_COMPAT) {
|
|
|
|
/* Python and Isolated configuration ignore global variables */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-08-01 15:56:14 +00:00
|
|
|
#define COPY_FLAG(ATTR, VALUE) \
|
|
|
|
if (config->ATTR == -1) { \
|
|
|
|
config->ATTR = VALUE; \
|
|
|
|
}
|
|
|
|
#define COPY_NOT_FLAG(ATTR, VALUE) \
|
|
|
|
if (config->ATTR == -1) { \
|
|
|
|
config->ATTR = !(VALUE); \
|
|
|
|
}
|
|
|
|
|
2019-03-26 01:31:11 +00:00
|
|
|
COPY_FLAG(isolated, Py_IsolatedFlag);
|
|
|
|
COPY_NOT_FLAG(use_environment, Py_IgnoreEnvironmentFlag);
|
2018-08-01 15:56:14 +00:00
|
|
|
COPY_FLAG(bytes_warning, Py_BytesWarningFlag);
|
|
|
|
COPY_FLAG(inspect, Py_InspectFlag);
|
|
|
|
COPY_FLAG(interactive, Py_InteractiveFlag);
|
|
|
|
COPY_FLAG(optimization_level, Py_OptimizeFlag);
|
|
|
|
COPY_FLAG(parser_debug, Py_DebugFlag);
|
|
|
|
COPY_FLAG(verbose, Py_VerboseFlag);
|
|
|
|
COPY_FLAG(quiet, Py_QuietFlag);
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
COPY_FLAG(legacy_windows_stdio, Py_LegacyWindowsStdioFlag);
|
|
|
|
#endif
|
2019-05-16 15:38:16 +00:00
|
|
|
COPY_NOT_FLAG(pathconfig_warnings, Py_FrozenFlag);
|
2018-08-01 15:56:14 +00:00
|
|
|
|
|
|
|
COPY_NOT_FLAG(buffered_stdio, Py_UnbufferedStdioFlag);
|
|
|
|
COPY_NOT_FLAG(site_import, Py_NoSiteFlag);
|
|
|
|
COPY_NOT_FLAG(write_bytecode, Py_DontWriteBytecodeFlag);
|
|
|
|
COPY_NOT_FLAG(user_site_directory, Py_NoUserSiteDirectory);
|
|
|
|
|
|
|
|
#undef COPY_FLAG
|
|
|
|
#undef COPY_NOT_FLAG
|
2022-06-17 14:12:00 +00:00
|
|
|
_Py_COMP_DIAG_POP
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Set Py_xxx global configuration variables from 'config' configuration. */
|
2019-03-26 15:58:50 +00:00
|
|
|
static void
|
2019-05-27 14:39:22 +00:00
|
|
|
config_set_global_vars(const PyConfig *config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2022-06-17 14:12:00 +00:00
|
|
|
_Py_COMP_DIAG_PUSH
|
|
|
|
_Py_COMP_DIAG_IGNORE_DEPR_DECLS
|
2018-08-01 15:56:14 +00:00
|
|
|
#define COPY_FLAG(ATTR, VAR) \
|
|
|
|
if (config->ATTR != -1) { \
|
|
|
|
VAR = config->ATTR; \
|
|
|
|
}
|
|
|
|
#define COPY_NOT_FLAG(ATTR, VAR) \
|
|
|
|
if (config->ATTR != -1) { \
|
|
|
|
VAR = !config->ATTR; \
|
|
|
|
}
|
|
|
|
|
2019-03-26 01:31:11 +00:00
|
|
|
COPY_FLAG(isolated, Py_IsolatedFlag);
|
|
|
|
COPY_NOT_FLAG(use_environment, Py_IgnoreEnvironmentFlag);
|
2018-08-01 15:56:14 +00:00
|
|
|
COPY_FLAG(bytes_warning, Py_BytesWarningFlag);
|
|
|
|
COPY_FLAG(inspect, Py_InspectFlag);
|
|
|
|
COPY_FLAG(interactive, Py_InteractiveFlag);
|
|
|
|
COPY_FLAG(optimization_level, Py_OptimizeFlag);
|
|
|
|
COPY_FLAG(parser_debug, Py_DebugFlag);
|
|
|
|
COPY_FLAG(verbose, Py_VerboseFlag);
|
|
|
|
COPY_FLAG(quiet, Py_QuietFlag);
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
COPY_FLAG(legacy_windows_stdio, Py_LegacyWindowsStdioFlag);
|
|
|
|
#endif
|
2019-05-16 15:38:16 +00:00
|
|
|
COPY_NOT_FLAG(pathconfig_warnings, Py_FrozenFlag);
|
2018-08-01 15:56:14 +00:00
|
|
|
|
|
|
|
COPY_NOT_FLAG(buffered_stdio, Py_UnbufferedStdioFlag);
|
|
|
|
COPY_NOT_FLAG(site_import, Py_NoSiteFlag);
|
|
|
|
COPY_NOT_FLAG(write_bytecode, Py_DontWriteBytecodeFlag);
|
|
|
|
COPY_NOT_FLAG(user_site_directory, Py_NoUserSiteDirectory);
|
|
|
|
|
|
|
|
/* Random or non-zero hash seed */
|
|
|
|
Py_HashRandomizationFlag = (config->use_hash_seed == 0 ||
|
|
|
|
config->hash_seed != 0);
|
|
|
|
|
|
|
|
#undef COPY_FLAG
|
|
|
|
#undef COPY_NOT_FLAG
|
2022-06-17 14:12:00 +00:00
|
|
|
_Py_COMP_DIAG_POP
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static const wchar_t*
|
2019-05-27 14:39:22 +00:00
|
|
|
config_get_xoption(const PyConfig *config, wchar_t *name)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2019-03-15 14:08:05 +00:00
|
|
|
return _Py_get_xoption(&config->xoptions, name);
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
2021-09-14 23:31:45 +00:00
|
|
|
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"";
|
|
|
|
}
|
|
|
|
|
2018-08-01 15:56:14 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_init_hash_seed(PyConfig *config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2022-04-20 17:26:40 +00:00
|
|
|
static_assert(sizeof(_Py_HashSecret_t) == sizeof(_Py_HashSecret.uc),
|
|
|
|
"_Py_HashSecret_t has wrong size");
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
const char *seed_text = config_get_env(config, "PYTHONHASHSEED");
|
2018-08-01 15:56:14 +00:00
|
|
|
|
|
|
|
/* 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'
|
2020-11-05 17:12:33 +00:00
|
|
|
|| seed > MAX_HASH_SEED
|
2018-08-01 15:56:14 +00:00
|
|
|
|| (errno == ERANGE && seed == ULONG_MAX))
|
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_ERR("PYTHONHASHSEED must be \"random\" "
|
2019-05-01 03:35:33 +00:00
|
|
|
"or an integer in range [0; 4294967295]");
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
/* 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;
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2024-03-11 15:02:58 +00:00
|
|
|
static PyStatus
|
|
|
|
config_read_gil(PyConfig *config, size_t len, wchar_t first_char)
|
|
|
|
{
|
|
|
|
#ifdef Py_GIL_DISABLED
|
|
|
|
if (len == 1 && first_char == L'0') {
|
|
|
|
config->enable_gil = _PyConfig_GIL_DISABLE;
|
|
|
|
}
|
|
|
|
else if (len == 1 && first_char == L'1') {
|
|
|
|
config->enable_gil = _PyConfig_GIL_ENABLE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return _PyStatus_ERR("PYTHON_GIL / -X gil must be \"0\" or \"1\"");
|
|
|
|
}
|
|
|
|
return _PyStatus_OK();
|
|
|
|
#else
|
|
|
|
return _PyStatus_ERR("PYTHON_GIL / -X gil are not supported by this build");
|
|
|
|
#endif
|
|
|
|
}
|
2018-08-01 15:56:14 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_read_env_vars(PyConfig *config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2019-03-26 01:31:11 +00:00
|
|
|
int use_env = config->use_environment;
|
2019-03-05 11:32:09 +00:00
|
|
|
|
2018-08-01 15:56:14 +00:00
|
|
|
/* Get environment variables */
|
2019-03-25 23:03:15 +00:00
|
|
|
_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");
|
|
|
|
_Py_get_env_flag(use_env, &config->inspect, "PYTHONINSPECT");
|
2018-08-01 15:56:14 +00:00
|
|
|
|
|
|
|
int dont_write_bytecode = 0;
|
2019-03-25 23:03:15 +00:00
|
|
|
_Py_get_env_flag(use_env, &dont_write_bytecode, "PYTHONDONTWRITEBYTECODE");
|
2018-08-01 15:56:14 +00:00
|
|
|
if (dont_write_bytecode) {
|
|
|
|
config->write_bytecode = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int no_user_site_directory = 0;
|
2019-03-25 23:03:15 +00:00
|
|
|
_Py_get_env_flag(use_env, &no_user_site_directory, "PYTHONNOUSERSITE");
|
2018-08-01 15:56:14 +00:00
|
|
|
if (no_user_site_directory) {
|
|
|
|
config->user_site_directory = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int unbuffered_stdio = 0;
|
2019-03-25 23:03:15 +00:00
|
|
|
_Py_get_env_flag(use_env, &unbuffered_stdio, "PYTHONUNBUFFERED");
|
2018-08-01 15:56:14 +00:00
|
|
|
if (unbuffered_stdio) {
|
|
|
|
config->buffered_stdio = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef MS_WINDOWS
|
2019-03-25 23:03:15 +00:00
|
|
|
_Py_get_env_flag(use_env, &config->legacy_windows_stdio,
|
2020-11-01 22:07:23 +00:00
|
|
|
"PYTHONLEGACYWINDOWSSTDIO");
|
2018-08-01 15:56:14 +00:00
|
|
|
#endif
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
if (config_get_env(config, "PYTHONDUMPREFS")) {
|
2018-08-01 15:56:14 +00:00
|
|
|
config->dump_refs = 1;
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
if (config_get_env(config, "PYTHONMALLOCSTATS")) {
|
2018-08-01 15:56:14 +00:00
|
|
|
config->malloc_stats = 1;
|
|
|
|
}
|
|
|
|
|
2021-08-17 15:52:50 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
if (config->pythonpath_env == NULL) {
|
|
|
|
status = CONFIG_GET_ENV_DUP(config, &config->pythonpath_env,
|
|
|
|
L"PYTHONPATH", "PYTHONPATH");
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-03-20 02:11:38 +00:00
|
|
|
}
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
2020-06-08 15:28:11 +00:00
|
|
|
if(config->platlibdir == NULL) {
|
|
|
|
status = CONFIG_GET_ENV_DUP(config, &config->platlibdir,
|
|
|
|
L"PYTHONPLATLIBDIR", "PYTHONPLATLIBDIR");
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-01 15:56:14 +00:00
|
|
|
if (config->use_hash_seed < 0) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_init_hash_seed(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-05 23:34:11 +00:00
|
|
|
if (config_get_env(config, "PYTHONSAFEPATH")) {
|
|
|
|
config->safe_path = 1;
|
|
|
|
}
|
|
|
|
|
2024-03-11 15:02:58 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
2023-10-10 10:00:09 +00:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
|
2022-08-30 17:11:18 +00:00
|
|
|
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;
|
|
|
|
}
|
2024-05-07 11:47:21 +00:00
|
|
|
env = config_get_env(config, "PYTHON_PERF_JIT_SUPPORT");
|
2024-05-05 01:07:29 +00:00
|
|
|
if (env) {
|
|
|
|
if (_Py_str_to_int(env, &active) != 0) {
|
|
|
|
active = 0;
|
|
|
|
}
|
|
|
|
if (active) {
|
|
|
|
config->perf_profiling = 2;
|
|
|
|
}
|
|
|
|
}
|
2024-05-07 11:47:21 +00:00
|
|
|
xoption = config_get_xoption(config, L"perf_jit");
|
2024-05-05 01:07:29 +00:00
|
|
|
if (xoption) {
|
|
|
|
config->perf_profiling = 2;
|
|
|
|
}
|
|
|
|
|
2022-08-30 17:11:18 +00:00
|
|
|
return _PyStatus_OK();
|
|
|
|
|
|
|
|
}
|
2018-08-01 15:56:14 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_init_tracemalloc(PyConfig *config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
|
|
|
int nframe;
|
|
|
|
int valid;
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
const char *env = config_get_env(config, "PYTHONTRACEMALLOC");
|
2018-08-01 15:56:14 +00:00
|
|
|
if (env) {
|
2019-03-05 11:32:09 +00:00
|
|
|
if (!_Py_str_to_int(env, &nframe)) {
|
2018-08-01 15:56:14 +00:00
|
|
|
valid = (nframe >= 0);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
valid = 0;
|
|
|
|
}
|
|
|
|
if (!valid) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_ERR("PYTHONTRACEMALLOC: invalid number of frames");
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
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) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_ERR("-X tracemalloc=NFRAME: "
|
|
|
|
"invalid number of frames");
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* -X tracemalloc behaves as -X tracemalloc=1 */
|
|
|
|
nframe = 1;
|
|
|
|
}
|
|
|
|
config->tracemalloc = nframe;
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
2022-09-02 16:35:08 +00:00
|
|
|
static PyStatus
|
|
|
|
config_init_int_max_str_digits(PyConfig *config)
|
|
|
|
{
|
|
|
|
int maxdigits;
|
|
|
|
|
|
|
|
const char *env = config_get_env(config, "PYTHONINTMAXSTRDIGITS");
|
|
|
|
if (env) {
|
2022-10-03 20:55:45 +00:00
|
|
|
bool valid = 0;
|
2022-09-02 16:35:08 +00:00
|
|
|
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.");
|
|
|
|
}
|
2022-10-03 20:55:45 +00:00
|
|
|
config->int_max_str_digits = maxdigits;
|
2022-09-02 16:35:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const wchar_t *xoption = config_get_xoption(config, L"int_max_str_digits");
|
|
|
|
if (xoption) {
|
|
|
|
const wchar_t *sep = wcschr(xoption, L'=');
|
2022-10-03 20:55:45 +00:00
|
|
|
bool valid = 0;
|
2022-09-02 16:35:08 +00:00
|
|
|
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
|
|
|
|
}
|
2022-10-03 20:55:45 +00:00
|
|
|
config->int_max_str_digits = maxdigits;
|
|
|
|
}
|
|
|
|
if (config->int_max_str_digits < 0) {
|
|
|
|
config->int_max_str_digits = _PY_LONG_DEFAULT_MAX_STR_DIGITS;
|
2022-09-02 16:35:08 +00:00
|
|
|
}
|
|
|
|
return _PyStatus_OK();
|
|
|
|
}
|
2018-08-01 15:56:14 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_init_pycache_prefix(PyConfig *config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
|
|
|
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) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2019-05-01 13:22:52 +00:00
|
|
|
// PYTHONPYCACHEPREFIX env var ignored
|
|
|
|
// if "-X pycache_prefix=" option is used
|
2018-08-01 15:56:14 +00:00
|
|
|
config->pycache_prefix = NULL;
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
2019-05-01 13:22:52 +00:00
|
|
|
return CONFIG_GET_ENV_DUP(config, &config->pycache_prefix,
|
|
|
|
L"PYTHONPYCACHEPREFIX",
|
|
|
|
"PYTHONPYCACHEPREFIX");
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-10-14 21:32:57 +00:00
|
|
|
#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
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_read_complex_options(PyConfig *config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
|
|
|
/* More complex options configured by env var and -X option */
|
|
|
|
if (config->faulthandler < 0) {
|
2019-05-27 14:39:22 +00:00
|
|
|
if (config_get_env(config, "PYTHONFAULTHANDLER")
|
2018-08-01 15:56:14 +00:00
|
|
|
|| config_get_xoption(config, L"faulthandler")) {
|
|
|
|
config->faulthandler = 1;
|
|
|
|
}
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
if (config_get_env(config, "PYTHONPROFILEIMPORTTIME")
|
2018-08-01 15:56:14 +00:00
|
|
|
|| config_get_xoption(config, L"importtime")) {
|
|
|
|
config->import_time = 1;
|
|
|
|
}
|
|
|
|
|
2021-07-07 19:07:12 +00:00
|
|
|
if (config_get_env(config, "PYTHONNODEBUGRANGES")
|
|
|
|
|| config_get_xoption(config, L"no_debug_ranges")) {
|
2021-12-02 10:43:37 +00:00
|
|
|
config->code_debug_ranges = 0;
|
2021-07-07 19:07:12 +00:00
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2018-08-01 15:56:14 +00:00
|
|
|
if (config->tracemalloc < 0) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_init_tracemalloc(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
}
|
2022-09-02 16:35:08 +00:00
|
|
|
|
2022-08-30 17:11:18 +00:00
|
|
|
if (config->perf_profiling < 0) {
|
|
|
|
status = config_init_perf_profiling(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
}
|
2018-08-01 15:56:14 +00:00
|
|
|
|
2022-10-03 20:55:45 +00:00
|
|
|
if (config->int_max_str_digits < 0) {
|
2022-09-02 16:35:08 +00:00
|
|
|
status = config_init_int_max_str_digits(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-10-10 10:00:09 +00:00
|
|
|
if (config->cpu_count < 0) {
|
|
|
|
status = config_init_cpu_count(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-01 15:56:14 +00:00
|
|
|
if (config->pycache_prefix == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_init_pycache_prefix(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
}
|
2023-10-14 21:32:57 +00:00
|
|
|
|
|
|
|
#ifdef Py_DEBUG
|
|
|
|
if (config->run_presite == NULL) {
|
|
|
|
status = config_init_run_presite(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-02 18:56:30 +00:00
|
|
|
static const wchar_t *
|
2020-10-31 00:02:09 +00:00
|
|
|
config_get_stdio_errors(const PyPreConfig *preconfig)
|
2018-08-29 09:47:29 +00:00
|
|
|
{
|
2020-10-31 00:02:09 +00:00
|
|
|
if (preconfig->utf8_mode) {
|
|
|
|
/* UTF-8 Mode uses UTF-8/surrogateescape */
|
|
|
|
return L"surrogateescape";
|
|
|
|
}
|
|
|
|
|
2018-08-29 09:47:29 +00:00
|
|
|
#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) {
|
2019-05-02 18:56:30 +00:00
|
|
|
return L"surrogateescape";
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef PY_COERCE_C_LOCALE
|
|
|
|
/* surrogateescape is the default in locale coercion target locales */
|
|
|
|
if (_Py_IsLocaleCoercionTarget(loc)) {
|
2019-05-02 18:56:30 +00:00
|
|
|
return L"surrogateescape";
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2019-05-02 18:56:30 +00:00
|
|
|
return L"strict";
|
2018-08-29 09:47:29 +00:00
|
|
|
#else
|
|
|
|
/* On Windows, always use surrogateescape by default */
|
2019-05-02 18:56:30 +00:00
|
|
|
return L"surrogateescape";
|
2018-08-29 09:47:29 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-11-01 19:59:35 +00:00
|
|
|
// See also config_get_fs_encoding()
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
2020-10-31 00:02:09 +00:00
|
|
|
config_get_locale_encoding(PyConfig *config, const PyPreConfig *preconfig,
|
|
|
|
wchar_t **locale_encoding)
|
2018-08-29 09:47:29 +00:00
|
|
|
{
|
2022-04-09 00:54:54 +00:00
|
|
|
wchar_t *encoding;
|
|
|
|
if (preconfig->utf8_mode) {
|
|
|
|
encoding = _PyMem_RawWcsdup(L"utf-8");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
encoding = _Py_GetLocaleEncoding();
|
|
|
|
}
|
2020-11-01 19:59:35 +00:00
|
|
|
if (encoding == NULL) {
|
2020-11-01 22:07:23 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
2020-11-01 19:59:35 +00:00
|
|
|
PyStatus status = PyConfig_SetString(config, locale_encoding, encoding);
|
|
|
|
PyMem_RawFree(encoding);
|
|
|
|
return status;
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_init_stdio_encoding(PyConfig *config,
|
|
|
|
const PyPreConfig *preconfig)
|
2018-08-29 09:47:29 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2019-05-01 13:22:52 +00:00
|
|
|
|
2020-11-04 10:20:10 +00:00
|
|
|
// Exit if encoding and errors are defined
|
2018-08-29 09:47:29 +00:00
|
|
|
if (config->stdio_encoding != NULL && config->stdio_errors != NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* PYTHONIOENCODING environment variable */
|
2019-05-27 14:39:22 +00:00
|
|
|
const char *opt = config_get_env(config, "PYTHONIOENCODING");
|
2018-08-29 09:47:29 +00:00
|
|
|
if (opt) {
|
2019-05-02 18:56:30 +00:00
|
|
|
char *pythonioencoding = _PyMem_RawStrdup(opt);
|
|
|
|
if (pythonioencoding == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
|
2019-05-01 13:22:52 +00:00
|
|
|
char *errors = strchr(pythonioencoding, ':');
|
|
|
|
if (errors) {
|
|
|
|
*errors = '\0';
|
|
|
|
errors++;
|
|
|
|
if (!errors[0]) {
|
|
|
|
errors = NULL;
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Does PYTHONIOENCODING contain an encoding? */
|
|
|
|
if (pythonioencoding[0]) {
|
|
|
|
if (config->stdio_encoding == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = CONFIG_SET_BYTES_STR(config, &config->stdio_encoding,
|
|
|
|
pythonioencoding,
|
|
|
|
"PYTHONIOENCODING environment variable");
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2018-08-29 09:47:29 +00:00
|
|
|
PyMem_RawFree(pythonioencoding);
|
2019-05-27 14:39:22 +00:00
|
|
|
return status;
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the encoding is set but not the error handler,
|
|
|
|
use "strict" error handler by default.
|
|
|
|
PYTHONIOENCODING=latin1 behaves as
|
|
|
|
PYTHONIOENCODING=latin1:strict. */
|
2019-05-01 13:22:52 +00:00
|
|
|
if (!errors) {
|
|
|
|
errors = "strict";
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-01 13:22:52 +00:00
|
|
|
if (config->stdio_errors == NULL && errors != NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = CONFIG_SET_BYTES_STR(config, &config->stdio_errors,
|
|
|
|
errors,
|
|
|
|
"PYTHONIOENCODING environment variable");
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2018-08-29 09:47:29 +00:00
|
|
|
PyMem_RawFree(pythonioencoding);
|
2019-05-27 14:39:22 +00:00
|
|
|
return status;
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PyMem_RawFree(pythonioencoding);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Choose the default error handler based on the current locale. */
|
|
|
|
if (config->stdio_encoding == NULL) {
|
2020-10-31 00:02:09 +00:00
|
|
|
status = config_get_locale_encoding(config, preconfig,
|
|
|
|
&config->stdio_encoding);
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (config->stdio_errors == NULL) {
|
2020-10-31 00:02:09 +00:00
|
|
|
const wchar_t *errors = config_get_stdio_errors(preconfig);
|
2019-05-01 13:22:52 +00:00
|
|
|
assert(errors != NULL);
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = PyConfig_SetString(config, &config->stdio_errors, errors);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-10-31 00:02:09 +00:00
|
|
|
// 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");
|
|
|
|
}
|
2020-11-04 10:20:10 +00:00
|
|
|
|
|
|
|
if (_Py_GetForceASCII()) {
|
2020-10-31 00:02:09 +00:00
|
|
|
return PyConfig_SetString(config, fs_encoding, L"ascii");
|
|
|
|
}
|
2020-11-04 10:20:10 +00:00
|
|
|
|
|
|
|
return config_get_locale_encoding(config, preconfig, fs_encoding);
|
2020-10-31 00:02:09 +00:00
|
|
|
#endif // !MS_WINDOWS
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_init_fs_encoding(PyConfig *config, const PyPreConfig *preconfig)
|
2018-08-29 11:25:36 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2019-05-01 13:22:52 +00:00
|
|
|
|
2018-08-29 11:25:36 +00:00
|
|
|
if (config->filesystem_encoding == NULL) {
|
2020-10-31 00:02:09 +00:00
|
|
|
status = config_get_fs_encoding(config, preconfig,
|
|
|
|
&config->filesystem_encoding);
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-29 11:25:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (config->filesystem_errors == NULL) {
|
2019-05-02 18:56:30 +00:00
|
|
|
const wchar_t *errors;
|
2019-05-02 15:28:57 +00:00
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
if (preconfig->legacy_windows_fs_encoding) {
|
2019-05-02 18:56:30 +00:00
|
|
|
errors = L"replace";
|
2019-05-02 15:28:57 +00:00
|
|
|
}
|
|
|
|
else {
|
2019-05-02 18:56:30 +00:00
|
|
|
errors = L"surrogatepass";
|
2019-05-02 15:28:57 +00:00
|
|
|
}
|
|
|
|
#else
|
2019-05-02 18:56:30 +00:00
|
|
|
errors = L"surrogateescape";
|
2019-05-02 15:28:57 +00:00
|
|
|
#endif
|
2019-05-27 14:39:22 +00:00
|
|
|
status = PyConfig_SetString(config, &config->filesystem_errors, errors);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-29 11:25:36 +00:00
|
|
|
}
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-29 11:25:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-14 23:31:45 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2023-11-01 20:39:31 +00:00
|
|
|
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\")");
|
|
|
|
}
|
|
|
|
|
2021-09-14 23:31:45 +00:00
|
|
|
/* -X frozen_modules=[on|off] */
|
2022-05-03 22:20:13 +00:00
|
|
|
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\")");
|
2021-09-14 23:31:45 +00:00
|
|
|
}
|
|
|
|
|
2022-05-05 23:34:11 +00:00
|
|
|
assert(config->use_frozen_modules >= 0);
|
2021-09-14 23:31:45 +00:00
|
|
|
return _PyStatus_OK();
|
|
|
|
}
|
|
|
|
|
|
|
|
PyStatus
|
|
|
|
_PyConfig_InitImportConfig(PyConfig *config)
|
|
|
|
{
|
|
|
|
return config_init_import(config, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
2020-11-10 12:21:52 +00:00
|
|
|
config_read(PyConfig *config, int compute_path_config)
|
2018-08-01 15:56:14 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
|
|
|
const PyPreConfig *preconfig = &_PyRuntime.preconfig;
|
2019-03-20 01:20:13 +00:00
|
|
|
|
2019-03-26 01:31:11 +00:00
|
|
|
if (config->use_environment) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_read_env_vars(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -X options */
|
|
|
|
if (config_get_xoption(config, L"showrefcount")) {
|
|
|
|
config->show_ref_count = 1;
|
|
|
|
}
|
|
|
|
|
2024-03-11 15:02:58 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-12 14:50:43 +00:00
|
|
|
#ifdef Py_STATS
|
|
|
|
if (config_get_xoption(config, L"pystats")) {
|
2023-09-06 15:54:59 +00:00
|
|
|
config->_pystats = 1;
|
|
|
|
}
|
|
|
|
else if (config_get_env(config, "PYTHONSTATS")) {
|
|
|
|
config->_pystats = 1;
|
|
|
|
}
|
|
|
|
if (config->_pystats < 0) {
|
|
|
|
config->_pystats = 0;
|
2022-12-12 14:50:43 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_read_complex_options(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
|
2020-11-10 20:10:22 +00:00
|
|
|
if (config->_install_importlib) {
|
2021-09-14 23:31:45 +00:00
|
|
|
status = config_init_import(config, compute_path_config);
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* default values */
|
2019-03-26 01:31:11 +00:00
|
|
|
if (config->dev_mode) {
|
2018-08-01 15:56:14 +00:00
|
|
|
if (config->faulthandler < 0) {
|
|
|
|
config->faulthandler = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (config->faulthandler < 0) {
|
|
|
|
config->faulthandler = 0;
|
|
|
|
}
|
|
|
|
if (config->tracemalloc < 0) {
|
|
|
|
config->tracemalloc = 0;
|
|
|
|
}
|
2022-08-30 17:11:18 +00:00
|
|
|
if (config->perf_profiling < 0) {
|
|
|
|
config->perf_profiling = 0;
|
|
|
|
}
|
2019-03-26 15:58:50 +00:00
|
|
|
if (config->use_hash_seed < 0) {
|
|
|
|
config->use_hash_seed = 0;
|
|
|
|
config->hash_seed = 0;
|
|
|
|
}
|
2018-08-01 15:56:14 +00:00
|
|
|
|
2018-08-29 11:45:34 +00:00
|
|
|
if (config->filesystem_encoding == NULL || config->filesystem_errors == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_init_fs_encoding(config, preconfig);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-29 11:25:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_init_stdio_encoding(config, preconfig);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2018-08-29 09:47:29 +00:00
|
|
|
}
|
|
|
|
|
2019-03-15 15:03:23 +00:00
|
|
|
if (config->argv.length < 1) {
|
|
|
|
/* Ensure at least one (empty) argument is seen */
|
2019-05-27 14:39:22 +00:00
|
|
|
status = PyWideStringList_Append(&config->argv, L"");
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-03-15 15:03:23 +00:00
|
|
|
}
|
|
|
|
}
|
2019-05-17 01:15:12 +00:00
|
|
|
|
|
|
|
if (config->check_hash_pycs_mode == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = PyConfig_SetString(config, &config->check_hash_pycs_mode,
|
|
|
|
L"default");
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-05-17 01:15:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (config->configure_c_stdio < 0) {
|
|
|
|
config->configure_c_stdio = 1;
|
|
|
|
}
|
|
|
|
|
2020-11-05 17:58:07 +00:00
|
|
|
// Only parse arguments once.
|
|
|
|
if (config->parse_argv == 1) {
|
|
|
|
config->parse_argv = 2;
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2018-08-01 15:56:14 +00:00
|
|
|
}
|
2018-11-06 14:59:52 +00:00
|
|
|
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
static void
|
2019-05-27 14:39:22 +00:00
|
|
|
config_init_stdio(const PyConfig *config)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
|
|
|
#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) */
|
2020-06-08 16:12:59 +00:00
|
|
|
PyStatus
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyConfig_Write(const PyConfig *config, _PyRuntimeState *runtime)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
config_set_global_vars(config);
|
2019-05-16 16:30:15 +00:00
|
|
|
|
|
|
|
if (config->configure_c_stdio) {
|
|
|
|
config_init_stdio(config);
|
|
|
|
}
|
2018-11-06 14:59:52 +00:00
|
|
|
|
2019-03-26 15:58:50 +00:00
|
|
|
/* Write the new pre-configuration into _PyRuntime */
|
2019-05-27 14:39:22 +00:00
|
|
|
PyPreConfig *preconfig = &runtime->preconfig;
|
2019-03-26 15:58:50 +00:00
|
|
|
preconfig->isolated = config->isolated;
|
|
|
|
preconfig->use_environment = config->use_environment;
|
|
|
|
preconfig->dev_mode = config->dev_mode;
|
2020-06-08 16:12:59 +00:00
|
|
|
|
2020-06-29 22:49:03 +00:00
|
|
|
if (_Py_SetArgcArgv(config->orig_argv.length,
|
|
|
|
config->orig_argv.items) < 0)
|
2020-06-08 16:12:59 +00:00
|
|
|
{
|
|
|
|
return _PyStatus_NO_MEMORY();
|
|
|
|
}
|
2023-09-06 15:54:59 +00:00
|
|
|
|
|
|
|
#ifdef Py_STATS
|
|
|
|
if (config->_pystats) {
|
|
|
|
_Py_StatsOn();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-06-08 16:12:59 +00:00
|
|
|
return _PyStatus_OK();
|
2018-11-06 14:59:52 +00:00
|
|
|
}
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
/* --- PyConfig command line parser -------------------------- */
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
static void
|
2019-03-29 14:13:46 +00:00
|
|
|
config_usage(int error, const wchar_t* program)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-03-29 14:13:46 +00:00
|
|
|
FILE *f = error ? stderr : stdout;
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2019-03-29 14:13:46 +00:00
|
|
|
fprintf(f, usage_line, program);
|
|
|
|
if (error)
|
|
|
|
fprintf(f, "Try `python -h' for more information.\n");
|
|
|
|
else {
|
2022-06-01 09:50:01 +00:00
|
|
|
fputs(usage_help, f);
|
2019-03-29 14:13:46 +00:00
|
|
|
}
|
|
|
|
}
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2022-06-01 09:50:01 +00:00
|
|
|
static void
|
2023-04-05 07:22:33 +00:00
|
|
|
config_envvars_usage(void)
|
2022-06-01 09:50:01 +00:00
|
|
|
{
|
|
|
|
printf(usage_envvars, (wint_t)DELIM, (wint_t)DELIM, PYTHONHOMEHELP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2023-04-05 07:22:33 +00:00
|
|
|
config_xoptions_usage(void)
|
2022-06-01 09:50:01 +00:00
|
|
|
{
|
|
|
|
puts(usage_xoptions);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
config_complete_usage(const wchar_t* program)
|
|
|
|
{
|
|
|
|
config_usage(0, program);
|
2024-02-23 09:27:07 +00:00
|
|
|
putchar('\n');
|
2022-06-01 09:50:01 +00:00
|
|
|
config_envvars_usage();
|
2024-02-23 09:27:07 +00:00
|
|
|
putchar('\n');
|
2022-06-01 09:50:01 +00:00
|
|
|
config_xoptions_usage();
|
|
|
|
}
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
/* Parse the command line arguments */
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_parse_cmdline(PyConfig *config, PyWideStringList *warnoptions,
|
2019-05-17 22:38:16 +00:00
|
|
|
Py_ssize_t *opt_index)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
|
|
|
const PyWideStringList *argv = &config->argv;
|
2019-03-29 14:13:46 +00:00
|
|
|
int print_version = 0;
|
2019-05-17 09:12:09 +00:00
|
|
|
const wchar_t* program = config->program_name;
|
2022-07-19 18:39:11 +00:00
|
|
|
if (!program && argv->length >= 1) {
|
|
|
|
program = argv->items[0];
|
|
|
|
}
|
2019-03-20 03:25:38 +00:00
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
_PyOS_ResetGetOpt();
|
|
|
|
do {
|
|
|
|
int longindex = -1;
|
2019-03-20 03:25:38 +00:00
|
|
|
int c = _PyOS_GetOpt(argv->length, argv->items, &longindex);
|
2019-03-01 15:25:19 +00:00
|
|
|
if (c == EOF) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c == 'c') {
|
2019-03-20 02:11:38 +00:00
|
|
|
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(_PyOS_optarg) + 1 + 1;
|
|
|
|
wchar_t *command = PyMem_RawMalloc(sizeof(wchar_t) * len);
|
|
|
|
if (command == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-03-20 02:11:38 +00:00
|
|
|
}
|
|
|
|
memcpy(command, _PyOS_optarg, (len - 2) * sizeof(wchar_t));
|
|
|
|
command[len - 2] = '\n';
|
|
|
|
command[len - 1] = 0;
|
|
|
|
config->run_command = command;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
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) {
|
2019-03-20 02:11:38 +00:00
|
|
|
config->run_module = _PyMem_RawWcsdup(_PyOS_optarg);
|
|
|
|
if (config->run_module == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-03-20 02:11:38 +00:00
|
|
|
}
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (c) {
|
2022-06-01 09:50:01 +00:00
|
|
|
// Integers represent long options, see Python/getopt.c
|
2019-03-01 15:25:19 +00:00
|
|
|
case 0:
|
2022-06-01 09:50:01 +00:00
|
|
|
// check-hash-based-pycs
|
2019-05-02 03:51:56 +00:00
|
|
|
if (wcscmp(_PyOS_optarg, L"always") == 0
|
|
|
|
|| wcscmp(_PyOS_optarg, L"never") == 0
|
|
|
|
|| wcscmp(_PyOS_optarg, L"default") == 0)
|
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
status = PyConfig_SetString(config, &config->check_hash_pycs_mode,
|
|
|
|
_PyOS_optarg);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-05-02 03:51:56 +00:00
|
|
|
}
|
2019-03-01 15:25:19 +00:00
|
|
|
} else {
|
|
|
|
fprintf(stderr, "--check-hash-based-pycs must be one of "
|
|
|
|
"'default', 'always', or 'never'\n");
|
2019-05-17 09:12:09 +00:00
|
|
|
config_usage(1, program);
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_EXIT(2);
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2022-06-01 09:50:01 +00:00
|
|
|
case 1:
|
|
|
|
// help-all
|
|
|
|
config_complete_usage(program);
|
|
|
|
return _PyStatus_EXIT(0);
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
// help-env
|
|
|
|
config_envvars_usage();
|
|
|
|
return _PyStatus_EXIT(0);
|
|
|
|
|
|
|
|
case 3:
|
|
|
|
// help-xoptions
|
|
|
|
config_xoptions_usage();
|
|
|
|
return _PyStatus_EXIT(0);
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
case 'b':
|
|
|
|
config->bytes_warning++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'd':
|
|
|
|
config->parser_debug++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'i':
|
|
|
|
config->inspect++;
|
|
|
|
config->interactive++;
|
|
|
|
break;
|
|
|
|
|
2019-03-05 01:44:12 +00:00
|
|
|
case 'E':
|
2019-03-01 15:25:19 +00:00
|
|
|
case 'I':
|
2019-03-20 03:25:38 +00:00
|
|
|
case 'X':
|
2019-03-26 15:58:50 +00:00
|
|
|
/* option handled by _PyPreCmdline_Read() */
|
2019-03-01 15:25:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* case 'J': reserved for Jython */
|
|
|
|
|
|
|
|
case 'O':
|
|
|
|
config->optimization_level++;
|
|
|
|
break;
|
|
|
|
|
2022-05-05 23:34:11 +00:00
|
|
|
case 'P':
|
|
|
|
config->safe_path = 1;
|
|
|
|
break;
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
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 '?':
|
2019-05-17 09:12:09 +00:00
|
|
|
config_usage(0, program);
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_EXIT(0);
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
case 'V':
|
2019-03-29 14:13:46 +00:00
|
|
|
print_version++;
|
2019-03-01 15:25:19 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'W':
|
2019-05-27 14:39:22 +00:00
|
|
|
status = PyWideStringList_Append(warnoptions, _PyOS_optarg);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
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 */
|
2019-05-17 09:12:09 +00:00
|
|
|
config_usage(1, program);
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_EXIT(2);
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
} while (1);
|
|
|
|
|
2019-03-29 14:13:46 +00:00
|
|
|
if (print_version) {
|
|
|
|
printf("Python %s\n",
|
|
|
|
(print_version >= 2) ? Py_GetVersion() : PY_VERSION);
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_EXIT(0);
|
2019-03-29 14:13:46 +00:00
|
|
|
}
|
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
if (config->run_command == NULL && config->run_module == NULL
|
2019-03-20 03:25:38 +00:00
|
|
|
&& _PyOS_optind < argv->length
|
|
|
|
&& wcscmp(argv->items[_PyOS_optind], L"-") != 0
|
2019-03-20 02:11:38 +00:00
|
|
|
&& config->run_filename == NULL)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-03-20 03:25:38 +00:00
|
|
|
config->run_filename = _PyMem_RawWcsdup(argv->items[_PyOS_optind]);
|
2019-03-01 15:25:19 +00:00
|
|
|
if (config->run_filename == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (config->run_command != NULL || config->run_module != NULL) {
|
|
|
|
/* Backup _PyOS_optind */
|
|
|
|
_PyOS_optind--;
|
|
|
|
}
|
|
|
|
|
2019-05-16 15:02:56 +00:00
|
|
|
*opt_index = _PyOS_optind;
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef MS_WINDOWS
|
|
|
|
# define WCSTOK wcstok_s
|
|
|
|
#else
|
|
|
|
# define WCSTOK wcstok
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Get warning options from PYTHONWARNINGS environment variable. */
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_init_env_warnoptions(PyConfig *config, PyWideStringList *warnoptions)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2019-05-01 13:22:52 +00:00
|
|
|
/* CONFIG_GET_ENV_DUP requires dest to be initialized to NULL */
|
|
|
|
wchar_t *env = NULL;
|
2019-05-27 14:39:22 +00:00
|
|
|
status = CONFIG_GET_ENV_DUP(config, &env,
|
2019-05-01 13:22:52 +00:00
|
|
|
L"PYTHONWARNINGS", "PYTHONWARNINGS");
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2019-05-01 13:22:52 +00:00
|
|
|
/* env var is not set or is empty */
|
2019-03-01 15:25:19 +00:00
|
|
|
if (env == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wchar_t *warning, *context = NULL;
|
|
|
|
for (warning = WCSTOK(env, L",", &context);
|
|
|
|
warning != NULL;
|
|
|
|
warning = WCSTOK(NULL, L",", &context))
|
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
status = PyWideStringList_Append(warnoptions, warning);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-03-01 15:25:19 +00:00
|
|
|
PyMem_RawFree(env);
|
2019-05-27 14:39:22 +00:00
|
|
|
return status;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
PyMem_RawFree(env);
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
2019-09-29 23:40:17 +00:00
|
|
|
warnoptions_append(PyConfig *config, PyWideStringList *options,
|
|
|
|
const wchar_t *option)
|
2019-03-26 15:58:50 +00:00
|
|
|
{
|
2019-09-29 23:40:17 +00:00
|
|
|
/* config_init_warnoptions() add existing config warnoptions at the end:
|
|
|
|
ensure that the new option is not already present in this list to
|
2021-10-06 22:55:27 +00:00
|
|
|
prevent change the options order when config_init_warnoptions() is
|
2019-09-29 23:40:17 +00:00
|
|
|
called twice. */
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyWideStringList_Find(&config->warnoptions, option)) {
|
2019-03-26 15:58:50 +00:00
|
|
|
/* Already present: do nothing */
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-03-26 15:58:50 +00:00
|
|
|
}
|
2019-09-29 23:40:17 +00:00
|
|
|
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();
|
2019-03-26 15:58:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_init_warnoptions(PyConfig *config,
|
|
|
|
const PyWideStringList *cmdline_warnoptions,
|
2019-09-29 23:40:17 +00:00
|
|
|
const PyWideStringList *env_warnoptions,
|
|
|
|
const PyWideStringList *sys_warnoptions)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2019-09-29 23:40:17 +00:00
|
|
|
PyWideStringList options = _PyWideStringList_INIT;
|
2019-05-27 14:39:22 +00:00
|
|
|
|
2019-09-29 23:40:17 +00:00
|
|
|
/* Priority of warnings options, lowest to highest:
|
2019-03-01 15:25:19 +00:00
|
|
|
*
|
|
|
|
* - any implicit filters added by _warnings.c/warnings.py
|
2019-09-29 23:40:17 +00:00
|
|
|
* - 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
|
2019-03-01 15:25:19 +00:00
|
|
|
*
|
2019-09-29 23:40:17 +00:00
|
|
|
* 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.
|
2019-03-01 15:25:19 +00:00
|
|
|
*/
|
|
|
|
|
2019-03-26 01:31:11 +00:00
|
|
|
if (config->dev_mode) {
|
2019-09-29 23:40:17 +00:00
|
|
|
status = warnoptions_append(config, &options, L"default");
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-09-29 23:40:17 +00:00
|
|
|
goto error;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-29 23:40:17 +00:00
|
|
|
status = warnoptions_extend(config, &options, env_warnoptions);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
goto error;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2019-09-29 23:40:17 +00:00
|
|
|
status = warnoptions_extend(config, &options, cmdline_warnoptions);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
goto error;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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) {
|
2019-03-15 14:08:05 +00:00
|
|
|
const wchar_t *filter;
|
2019-03-01 15:25:19 +00:00
|
|
|
if (config->bytes_warning> 1) {
|
|
|
|
filter = L"error::BytesWarning";
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
filter = L"default::BytesWarning";
|
|
|
|
}
|
2019-09-29 23:40:17 +00:00
|
|
|
status = warnoptions_append(config, &options, filter);
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-09-29 23:40:17 +00:00
|
|
|
goto error;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
}
|
2019-08-23 17:03:08 +00:00
|
|
|
|
2019-09-29 23:40:17 +00:00
|
|
|
status = warnoptions_extend(config, &options, sys_warnoptions);
|
2019-08-23 17:03:08 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-09-29 23:40:17 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Always add all PyConfig.warnoptions options */
|
|
|
|
status = _PyWideStringList_Extend(&options, &config->warnoptions);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
goto error;
|
2019-08-23 17:03:08 +00:00
|
|
|
}
|
|
|
|
|
2019-09-29 23:40:17 +00:00
|
|
|
_PyWideStringList_Clear(&config->warnoptions);
|
|
|
|
config->warnoptions = options;
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-09-29 23:40:17 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
_PyWideStringList_Clear(&options);
|
|
|
|
return status;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_update_argv(PyConfig *config, Py_ssize_t opt_index)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
const PyWideStringList *cmdline_argv = &config->argv;
|
2019-09-29 23:40:17 +00:00
|
|
|
PyWideStringList config_argv = _PyWideStringList_INIT;
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2019-03-15 14:08:05 +00:00
|
|
|
/* Copy argv to be able to modify it (to force -c/-m) */
|
2019-05-16 15:02:56 +00:00
|
|
|
if (cmdline_argv->length <= opt_index) {
|
2019-03-01 15:25:19 +00:00
|
|
|
/* Ensure at least one (empty) argument is seen */
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status = PyWideStringList_Append(&config_argv, L"");
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-03-15 14:08:05 +00:00
|
|
|
}
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
else {
|
2019-05-27 14:39:22 +00:00
|
|
|
PyWideStringList slice;
|
2019-05-16 15:02:56 +00:00
|
|
|
slice.length = cmdline_argv->length - opt_index;
|
|
|
|
slice.items = &cmdline_argv->items[opt_index];
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyWideStringList_Copy(&config_argv, &slice) < 0) {
|
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-03-15 14:08:05 +00:00
|
|
|
}
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
2019-03-20 03:25:38 +00:00
|
|
|
assert(config_argv.length >= 1);
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
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";
|
|
|
|
}
|
2019-06-25 13:02:43 +00:00
|
|
|
|
2019-03-01 15:25:19 +00:00
|
|
|
if (arg0 != NULL) {
|
|
|
|
arg0 = _PyMem_RawWcsdup(arg0);
|
|
|
|
if (arg0 == NULL) {
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Clear(&config_argv);
|
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2019-03-20 03:25:38 +00:00
|
|
|
PyMem_RawFree(config_argv.items[0]);
|
|
|
|
config_argv.items[0] = arg0;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Clear(&config->argv);
|
2019-03-20 03:25:38 +00:00
|
|
|
config->argv = config_argv;
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
core_read_precmdline(PyConfig *config, _PyPreCmdline *precmdline)
|
2019-03-27 12:40:14 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2019-03-27 12:40:14 +00:00
|
|
|
|
2020-11-05 17:58:07 +00:00
|
|
|
if (config->parse_argv == 1) {
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyWideStringList_Copy(&precmdline->argv, &config->argv) < 0) {
|
|
|
|
return _PyStatus_NO_MEMORY();
|
2019-05-17 17:01:14 +00:00
|
|
|
}
|
2019-03-27 12:40:14 +00:00
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyPreConfig preconfig;
|
2019-09-28 02:28:35 +00:00
|
|
|
|
|
|
|
status = _PyPreConfig_InitFromPreConfig(&preconfig, &_PyRuntime.preconfig);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
|
|
|
}
|
2019-03-27 12:40:14 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyPreConfig_GetConfig(&preconfig, config);
|
2019-03-27 12:40:14 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = _PyPreCmdline_Read(precmdline, &preconfig);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-05-17 01:15:12 +00:00
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = _PyPreCmdline_SetConfig(precmdline, config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-05-17 01:15:12 +00:00
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyStatus_OK();
|
2019-03-27 12:40:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-06-25 13:02:43 +00:00
|
|
|
/* 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();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
static PyStatus
|
|
|
|
config_read_cmdline(PyConfig *config)
|
2019-03-01 15:25:19 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2019-09-29 23:40:17 +00:00
|
|
|
PyWideStringList cmdline_warnoptions = _PyWideStringList_INIT;
|
|
|
|
PyWideStringList env_warnoptions = _PyWideStringList_INIT;
|
|
|
|
PyWideStringList sys_warnoptions = _PyWideStringList_INIT;
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2019-05-16 15:02:56 +00:00
|
|
|
if (config->parse_argv < 0) {
|
|
|
|
config->parse_argv = 1;
|
2019-03-26 15:58:50 +00:00
|
|
|
}
|
2019-05-17 01:15:12 +00:00
|
|
|
|
2020-11-05 17:58:07 +00:00
|
|
|
if (config->parse_argv == 1) {
|
2019-05-17 22:38:16 +00:00
|
|
|
Py_ssize_t opt_index;
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_parse_cmdline(config, &cmdline_warnoptions, &opt_index);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-05-16 15:02:56 +00:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2019-06-25 13:02:43 +00:00
|
|
|
status = config_run_filename_abspath(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_update_argv(config, opt_index);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-05-16 15:02:56 +00:00
|
|
|
goto done;
|
|
|
|
}
|
2019-06-25 13:02:43 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
status = config_run_filename_abspath(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
goto done;
|
|
|
|
}
|
2019-03-29 14:13:46 +00:00
|
|
|
}
|
2019-03-20 01:20:13 +00:00
|
|
|
|
2019-03-29 14:13:46 +00:00
|
|
|
if (config->use_environment) {
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_init_env_warnoptions(config, &env_warnoptions);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-03-26 15:58:50 +00:00
|
|
|
goto done;
|
2019-03-20 02:11:38 +00:00
|
|
|
}
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2019-09-29 23:40:17 +00:00
|
|
|
/* Handle early PySys_AddWarnOption() calls */
|
|
|
|
status = _PySys_ReadPreinitWarnOptions(&sys_warnoptions);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_init_warnoptions(config,
|
2019-08-23 17:03:08 +00:00
|
|
|
&cmdline_warnoptions,
|
2019-09-29 23:40:17 +00:00
|
|
|
&env_warnoptions,
|
|
|
|
&sys_warnoptions);
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-03-29 14:13:46 +00:00
|
|
|
goto done;
|
|
|
|
}
|
2019-03-20 03:25:38 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = _PyStatus_OK();
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2019-03-29 14:13:46 +00:00
|
|
|
done:
|
2019-05-27 14:39:22 +00:00
|
|
|
_PyWideStringList_Clear(&cmdline_warnoptions);
|
|
|
|
_PyWideStringList_Clear(&env_warnoptions);
|
2019-09-29 23:40:17 +00:00
|
|
|
_PyWideStringList_Clear(&sys_warnoptions);
|
2019-05-27 14:39:22 +00:00
|
|
|
return status;
|
2019-03-29 14:13:46 +00:00
|
|
|
}
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
|
|
|
_PyConfig_SetPyArgv(PyConfig *config, const _PyArgv *args)
|
2019-05-01 00:30:12 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status = _Py_PreInitializeFromConfig(config, args);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-05-02 19:25:34 +00:00
|
|
|
}
|
2019-05-20 09:02:00 +00:00
|
|
|
|
2019-05-01 00:30:12 +00:00
|
|
|
return _PyArgv_AsWstrList(args, &config->argv);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-02 19:25:34 +00:00
|
|
|
/* Set config.argv: decode argv using Py_DecodeLocale(). Pre-initialize Python
|
|
|
|
if needed to ensure that encodings are properly configured. */
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
|
|
|
PyConfig_SetBytesArgv(PyConfig *config, Py_ssize_t argc, char * const *argv)
|
2019-05-01 00:30:12 +00:00
|
|
|
{
|
|
|
|
_PyArgv args = {
|
|
|
|
.argc = argc,
|
|
|
|
.use_bytes_argv = 1,
|
|
|
|
.bytes_argv = argv,
|
|
|
|
.wchar_argv = NULL};
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyConfig_SetPyArgv(config, &args);
|
2019-05-01 00:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
|
|
|
PyConfig_SetArgv(PyConfig *config, Py_ssize_t argc, wchar_t * const *argv)
|
2019-05-01 00:30:12 +00:00
|
|
|
{
|
|
|
|
_PyArgv args = {
|
|
|
|
.argc = argc,
|
|
|
|
.use_bytes_argv = 0,
|
|
|
|
.bytes_argv = NULL,
|
|
|
|
.wchar_argv = argv};
|
2019-05-27 14:39:22 +00:00
|
|
|
return _PyConfig_SetPyArgv(config, &args);
|
2019-05-01 00:30:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-07-01 17:13:50 +00:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
/* Read the configuration into PyConfig from:
|
2019-03-29 14:13:46 +00:00
|
|
|
|
|
|
|
* Command line arguments
|
|
|
|
* Environment variables
|
2019-05-16 16:30:15 +00:00
|
|
|
* Py_xxx global configuration variables
|
|
|
|
|
|
|
|
The only side effects are to modify config and to call _Py_SetArgcArgv(). */
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus
|
2020-11-10 12:21:52 +00:00
|
|
|
_PyConfig_Read(PyConfig *config, int compute_path_config)
|
2019-03-29 14:13:46 +00:00
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyStatus status;
|
2019-03-01 15:25:19 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = _Py_PreInitializeFromConfig(config, NULL);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
return status;
|
2019-03-29 14:13:46 +00:00
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
config_get_global_vars(config);
|
2019-03-29 14:13:46 +00:00
|
|
|
|
2020-06-29 22:49:03 +00:00
|
|
|
if (config->orig_argv.length == 0
|
2020-06-08 16:12:59 +00:00
|
|
|
&& !(config->argv.length == 1
|
|
|
|
&& wcscmp(config->argv.items[0], L"") == 0))
|
|
|
|
{
|
2020-06-29 22:49:03 +00:00
|
|
|
if (_PyWideStringList_Copy(&config->orig_argv, &config->argv) < 0) {
|
2020-06-08 16:12:59 +00:00
|
|
|
return _PyStatus_NO_MEMORY();
|
|
|
|
}
|
2019-05-17 17:01:14 +00:00
|
|
|
}
|
|
|
|
|
2019-03-29 14:13:46 +00:00
|
|
|
_PyPreCmdline precmdline = _PyPreCmdline_INIT;
|
2019-05-27 14:39:22 +00:00
|
|
|
status = core_read_precmdline(config, &precmdline);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-03-26 15:58:50 +00:00
|
|
|
goto done;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2019-05-17 01:15:12 +00:00
|
|
|
assert(config->isolated >= 0);
|
|
|
|
if (config->isolated) {
|
2022-05-05 23:34:11 +00:00
|
|
|
config->safe_path = 1;
|
2019-05-17 01:15:12 +00:00
|
|
|
config->use_environment = 0;
|
|
|
|
config->user_site_directory = 0;
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = config_read_cmdline(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-05-17 01:15:12 +00:00
|
|
|
goto done;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2019-08-23 17:03:08 +00:00
|
|
|
/* Handle early PySys_AddXOption() calls */
|
|
|
|
status = _PySys_ReadPreinitXOptions(config);
|
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2020-11-10 12:21:52 +00:00
|
|
|
status = config_read(config, compute_path_config);
|
2019-05-27 14:39:22 +00:00
|
|
|
if (_PyStatus_EXCEPTION(status)) {
|
2019-03-26 15:58:50 +00:00
|
|
|
goto done;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
|
|
|
|
2020-11-05 17:12:33 +00:00
|
|
|
assert(config_check_consistency(config));
|
2019-03-26 15:58:50 +00:00
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
status = _PyStatus_OK();
|
2019-03-01 15:25:19 +00:00
|
|
|
|
|
|
|
done:
|
2019-03-26 15:58:50 +00:00
|
|
|
_PyPreCmdline_Clear(&precmdline);
|
2019-05-27 14:39:22 +00:00
|
|
|
return status;
|
2019-03-01 15:25:19 +00:00
|
|
|
}
|
2019-03-25 22:19:57 +00:00
|
|
|
|
|
|
|
|
2020-11-10 12:21:52 +00:00
|
|
|
PyStatus
|
|
|
|
PyConfig_Read(PyConfig *config)
|
|
|
|
{
|
2021-12-03 00:08:42 +00:00
|
|
|
return _PyConfig_Read(config, 0);
|
2020-11-10 12:21:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-03-25 22:19:57 +00:00
|
|
|
PyObject*
|
|
|
|
_Py_GetConfigsAsDict(void)
|
|
|
|
{
|
2019-05-27 14:39:22 +00:00
|
|
|
PyObject *result = NULL;
|
2019-03-25 22:19:57 +00:00
|
|
|
PyObject *dict = NULL;
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
result = PyDict_New();
|
|
|
|
if (result == NULL) {
|
2019-03-25 22:19:57 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
/* global result */
|
2019-03-25 22:19:57 +00:00
|
|
|
dict = _Py_GetGlobalVariablesAsDict();
|
|
|
|
if (dict == NULL) {
|
|
|
|
goto error;
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
if (PyDict_SetItemString(result, "global_config", dict) < 0) {
|
2019-03-25 22:19:57 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
Py_CLEAR(dict);
|
|
|
|
|
|
|
|
/* pre config */
|
2021-02-19 14:10:45 +00:00
|
|
|
PyInterpreterState *interp = _PyInterpreterState_GET();
|
|
|
|
const PyPreConfig *pre_config = &interp->runtime->preconfig;
|
2019-03-25 22:19:57 +00:00
|
|
|
dict = _PyPreConfig_AsDict(pre_config);
|
|
|
|
if (dict == NULL) {
|
|
|
|
goto error;
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
if (PyDict_SetItemString(result, "pre_config", dict) < 0) {
|
2019-03-25 22:19:57 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
Py_CLEAR(dict);
|
|
|
|
|
|
|
|
/* core config */
|
2021-02-19 14:10:45 +00:00
|
|
|
const PyConfig *config = _PyInterpreterState_GetConfig(interp);
|
2020-11-05 17:12:33 +00:00
|
|
|
dict = _PyConfig_AsDict(config);
|
2019-03-25 22:19:57 +00:00
|
|
|
if (dict == NULL) {
|
|
|
|
goto error;
|
|
|
|
}
|
2019-05-27 14:39:22 +00:00
|
|
|
if (PyDict_SetItemString(result, "config", dict) < 0) {
|
2019-03-25 22:19:57 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
Py_CLEAR(dict);
|
|
|
|
|
2019-05-27 14:39:22 +00:00
|
|
|
return result;
|
2019-03-25 22:19:57 +00:00
|
|
|
|
|
|
|
error:
|
2019-05-27 14:39:22 +00:00
|
|
|
Py_XDECREF(result);
|
2019-03-25 22:19:57 +00:00
|
|
|
Py_XDECREF(dict);
|
|
|
|
return NULL;
|
|
|
|
}
|
2019-09-23 12:45:47 +00:00
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
init_dump_ascii_wstr(const wchar_t *str)
|
|
|
|
{
|
|
|
|
if (str == NULL) {
|
|
|
|
PySys_WriteStderr("(not set)");
|
2019-09-23 13:35:46 +00:00
|
|
|
return;
|
2019-09-23 12:45:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PySys_WriteStderr("'");
|
|
|
|
for (; *str != L'\0'; str++) {
|
2020-09-09 10:07:17 +00:00
|
|
|
unsigned int ch = (unsigned int)*str;
|
2019-09-23 12:45:47 +00:00
|
|
|
if (ch == L'\'') {
|
|
|
|
PySys_WriteStderr("\\'");
|
|
|
|
} else if (0x20 <= ch && ch < 0x7f) {
|
2020-09-21 08:35:17 +00:00
|
|
|
PySys_WriteStderr("%c", ch);
|
2019-09-23 12:45:47 +00:00
|
|
|
}
|
|
|
|
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)
|
|
|
|
{
|
2023-02-08 09:31:12 +00:00
|
|
|
PyObject *exc = _PyErr_GetRaisedException(tstate);
|
2019-09-23 12:45:47 +00:00
|
|
|
|
|
|
|
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)
|
|
|
|
|
2020-04-13 01:04:28 +00:00
|
|
|
const PyConfig *config = _PyInterpreterState_GetConfig(tstate->interp);
|
2019-09-23 12:45:47 +00:00
|
|
|
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);
|
2022-05-05 23:34:11 +00:00
|
|
|
PySys_WriteStderr(" safe_path = %i\n", config->safe_path);
|
2019-09-23 12:45:47 +00:00
|
|
|
PySys_WriteStderr(" import site = %i\n", config->site_import);
|
2021-12-03 00:08:42 +00:00
|
|
|
PySys_WriteStderr(" is in build tree = %i\n", config->_is_python_build);
|
2021-09-28 18:18:28 +00:00
|
|
|
DUMP_CONFIG("stdlib dir", stdlib_dir);
|
2023-10-02 19:59:05 +00:00
|
|
|
DUMP_CONFIG("sys.path[0]", sys_path_0);
|
2019-09-23 12:45:47 +00:00
|
|
|
#undef DUMP_CONFIG
|
|
|
|
|
|
|
|
#define DUMP_SYS(NAME) \
|
|
|
|
do { \
|
|
|
|
obj = PySys_GetObject(#NAME); \
|
|
|
|
PySys_FormatStderr(" sys.%s = ", #NAME); \
|
|
|
|
if (obj != NULL) { \
|
|
|
|
PySys_FormatStderr("%A", 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);
|
2020-06-08 15:28:11 +00:00
|
|
|
DUMP_SYS(platlibdir);
|
2019-09-23 12:45:47 +00:00
|
|
|
DUMP_SYS(executable);
|
|
|
|
DUMP_SYS(prefix);
|
|
|
|
DUMP_SYS(exec_prefix);
|
|
|
|
#undef DUMP_SYS
|
|
|
|
|
|
|
|
PyObject *sys_path = PySys_GetObject("path"); /* borrowed reference */
|
|
|
|
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");
|
|
|
|
}
|
|
|
|
|
2023-02-08 09:31:12 +00:00
|
|
|
_PyErr_SetRaisedException(tstate, exc);
|
2019-09-23 12:45:47 +00:00
|
|
|
}
|