mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-07-22 18:55:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 15

bpo-36301: Remove _PyCoreConfig.preconfig (GH-12546)

Browse source 
* Replace _PyCoreConfig.preconfig with 3 new fields in _PyCoreConfig:
  isolated, use_environment, dev_mode.
* Add _PyPreCmdline.dev_mode.
* Add _Py_PreInitializeFromPreConfigInPlace().
This commit is contained in:
Victor Stinner 2019-03-26 02:31:11 +01:00 • committed by GitHub
parent f78a5e9ce8
commit 20004959d2
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 179 additions and 145 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Include/cpython/coreconfig.h
View file

@ -123,7 +123,9 @@ typedef struct {
/* --- _PyCoreConfig ---------------------------------------------- */ /* --- _PyCoreConfig ---------------------------------------------- */
typedef struct { typedef struct {
_PyPreConfig preconfig; int isolated;
int use_environment;
int dev_mode;
/* Install signal handlers? Yes by default. */ /* Install signal handlers? Yes by default. */
int install_signal_handlers; int install_signal_handlers;
@ -375,7 +377,9 @@ typedef struct {
#define _PyCoreConfig_INIT \ #define _PyCoreConfig_INIT \
(_PyCoreConfig){ \ (_PyCoreConfig){ \
_PyCoreConfig_WINDOWS_INIT \ _PyCoreConfig_WINDOWS_INIT \
.preconfig = _PyPreConfig_INIT, \ .isolated = -1, \
.use_environment = -1, \
.dev_mode = -1, \
.install_signal_handlers = 1, \ .install_signal_handlers = 1, \
.use_hash_seed = -1, \ .use_hash_seed = -1, \
.faulthandler = -1, \ .faulthandler = -1, \

2
Include/cpython/pylifecycle.h
View file

@ -16,7 +16,7 @@ PyAPI_FUNC(int) Py_SetStandardStreamEncoding(const char *encoding,
PyAPI_FUNC(_PyInitError) _Py_PreInitialize(void); PyAPI_FUNC(_PyInitError) _Py_PreInitialize(void);
PyAPI_FUNC(_PyInitError) _Py_PreInitializeFromPreConfig( PyAPI_FUNC(_PyInitError) _Py_PreInitializeFromPreConfig(
_PyPreConfig *preconfig); const _PyPreConfig *preconfig);
PyAPI_FUNC(_PyInitError) _Py_PreInitializeFromConfig( PyAPI_FUNC(_PyInitError) _Py_PreInitializeFromConfig(
const _PyCoreConfig *coreconfig); const _PyCoreConfig *coreconfig);

6
Include/internal/pycore_coreconfig.h
View file

@ -16,12 +16,14 @@ typedef struct {
_PyWstrList xoptions; /* "-X value" option */ _PyWstrList xoptions; /* "-X value" option */
int use_environment; /* -E option */ int use_environment; /* -E option */
int isolated; /* -I option */ int isolated; /* -I option */
int dev_mode; /* -X dev and PYTHONDEVMODE */
} _PyPreCmdline; } _PyPreCmdline;
#define _PyPreCmdline_INIT \ #define _PyPreCmdline_INIT \
(_PyPreCmdline){ \ (_PyPreCmdline){ \
.use_environment = -1, \ .use_environment = -1, \
.isolated = -1} .isolated = -1, \
.dev_mode = -1}
/* Note: _PyPreCmdline_INIT sets other fields to 0/NULL */ /* Note: _PyPreCmdline_INIT sets other fields to 0/NULL */
PyAPI_FUNC(void) _PyPreCmdline_Clear(_PyPreCmdline *cmdline); PyAPI_FUNC(void) _PyPreCmdline_Clear(_PyPreCmdline *cmdline);
@ -112,7 +114,7 @@ PyAPI_FUNC(void) _PyCoreConfig_SetGlobalConfig(const _PyCoreConfig *config);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_Read(_PyCoreConfig *config); PyAPI_FUNC(_PyInitError) _PyCoreConfig_Read(_PyCoreConfig *config);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_ReadFromArgv(_PyCoreConfig *config, PyAPI_FUNC(_PyInitError) _PyCoreConfig_ReadFromArgv(_PyCoreConfig *config,
const _PyArgv *args); const _PyArgv *args);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_Write(const _PyCoreConfig *config); PyAPI_FUNC(void) _PyCoreConfig_Write(const _PyCoreConfig *config);
/* --- _PyMainInterpreterConfig ----------------------------------- */ /* --- _PyMainInterpreterConfig ----------------------------------- */

3
Include/internal/pycore_pylifecycle.h
View file

@ -77,6 +77,9 @@ extern void _PyGILState_Fini(void);
PyAPI_FUNC(void) _PyGC_DumpShutdownStats(void); PyAPI_FUNC(void) _PyGC_DumpShutdownStats(void);
PyAPI_FUNC(_PyInitError) _Py_PreInitializeInPlace(
_PyPreConfig *config);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

43
Lib/test/test_embed.py
View file

@ -272,12 +272,19 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase):
'allocator': None, 'allocator': None,
'coerce_c_locale': 0, 'coerce_c_locale': 0,
'coerce_c_locale_warn': 0, 'coerce_c_locale_warn': 0,
'dev_mode': 0,
'isolated': 0,
'use_environment': 1,
'utf8_mode': 0, 'utf8_mode': 0,
} }
COPY_PRE_CONFIG = [
'dev_mode',
'isolated',
'use_environment',
]
DEFAULT_CORE_CONFIG = { DEFAULT_CORE_CONFIG = {
'isolated': 0,
'use_environment': 1,
'dev_mode': 0,
'install_signal_handlers': 1, 'install_signal_handlers': 1,
'use_hash_seed': 0, 'use_hash_seed': 0,
'hash_seed': 0, 'hash_seed': 0,
@ -363,8 +370,6 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase):
'_Py_HasFileSystemDefaultEncodeErrors': 0, '_Py_HasFileSystemDefaultEncodeErrors': 0,
} }
COPY_GLOBAL_PRE_CONFIG = [ COPY_GLOBAL_PRE_CONFIG = [
('Py_IgnoreEnvironmentFlag', 'use_environment', True),
('Py_IsolatedFlag', 'isolated'),
('Py_UTF8Mode', 'utf8_mode'), ('Py_UTF8Mode', 'utf8_mode'),
] ]
COPY_GLOBAL_CONFIG = [ COPY_GLOBAL_CONFIG = [
@ -376,8 +381,10 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase):
('Py_FileSystemDefaultEncodeErrors', 'filesystem_errors'), ('Py_FileSystemDefaultEncodeErrors', 'filesystem_errors'),
('Py_FileSystemDefaultEncoding', 'filesystem_encoding'), ('Py_FileSystemDefaultEncoding', 'filesystem_encoding'),
('Py_FrozenFlag', '_frozen'), ('Py_FrozenFlag', '_frozen'),
('Py_IgnoreEnvironmentFlag', 'use_environment', True),
('Py_InspectFlag', 'inspect'), ('Py_InspectFlag', 'inspect'),
('Py_InteractiveFlag', 'interactive'), ('Py_InteractiveFlag', 'interactive'),
('Py_IsolatedFlag', 'isolated'),
('Py_NoSiteFlag', 'site_import', True), ('Py_NoSiteFlag', 'site_import', True),
('Py_NoUserSiteDirectory', 'user_site_directory', True), ('Py_NoUserSiteDirectory', 'user_site_directory', True),
('Py_OptimizeFlag', 'optimization_level'), ('Py_OptimizeFlag', 'optimization_level'),
@ -415,7 +422,7 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase):
expected['xoptions'] = self.main_xoptions(core_config['xoptions']) expected['xoptions'] = self.main_xoptions(core_config['xoptions'])
self.assertEqual(main_config, expected) self.assertEqual(main_config, expected)
def get_expected_config(self, expected, expected_preconfig, env): def get_expected_config(self, expected, env):
expected = dict(self.DEFAULT_CORE_CONFIG, **expected) expected = dict(self.DEFAULT_CORE_CONFIG, **expected)
code = textwrap.dedent(''' code = textwrap.dedent('''
@ -443,7 +450,7 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase):
# when test_embed is run from a venv (bpo-35313) # when test_embed is run from a venv (bpo-35313)
args = (sys.executable, '-S', '-c', code) args = (sys.executable, '-S', '-c', code)
env = dict(env) env = dict(env)
if not expected_preconfig['isolated']: if not expected['isolated']:
env['PYTHONCOERCECLOCALE'] = '0' env['PYTHONCOERCECLOCALE'] = '0'
env['PYTHONUTF8'] = '0' env['PYTHONUTF8'] = '0'
proc = subprocess.run(args, env=env, proc = subprocess.run(args, env=env,
@ -509,7 +516,10 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase):
config = json.loads(out) config = json.loads(out)
expected_preconfig = dict(self.DEFAULT_PRE_CONFIG, **expected_preconfig) expected_preconfig = dict(self.DEFAULT_PRE_CONFIG, **expected_preconfig)
expected_config = self.get_expected_config(expected_config, expected_preconfig, env) expected_config = self.get_expected_config(expected_config, env)
for key in self.COPY_PRE_CONFIG:
if key not in expected_preconfig:
expected_preconfig[key] = expected_config[key]
self.check_core_config(config, expected_config) self.check_core_config(config, expected_config)
self.check_pre_config(config, expected_preconfig) self.check_pre_config(config, expected_preconfig)
@ -617,35 +627,36 @@ class InitConfigTests(EmbeddingTestsMixin, unittest.TestCase):
def test_init_env_dev_mode(self): def test_init_env_dev_mode(self):
preconfig = dict(self.INIT_ENV_PRECONFIG, preconfig = dict(self.INIT_ENV_PRECONFIG,
allocator='debug', allocator='debug')
dev_mode=1)
config = dict(self.INIT_ENV_CONFIG, config = dict(self.INIT_ENV_CONFIG,
dev_mode=1) dev_mode=1)
self.check_config("init_env_dev_mode", config, preconfig) self.check_config("init_env_dev_mode", config, preconfig)
def test_init_env_dev_mode(self): def test_init_env_dev_mode_alloc(self):
preconfig = dict(self.INIT_ENV_PRECONFIG, preconfig = dict(self.INIT_ENV_PRECONFIG,
allocator='malloc', allocator='malloc')
config = dict(self.INIT_ENV_CONFIG,
dev_mode=1) dev_mode=1)
config = dict(self.INIT_ENV_CONFIG)
self.check_config("init_env_dev_mode_alloc", config, preconfig) self.check_config("init_env_dev_mode_alloc", config, preconfig)
def test_init_dev_mode(self): def test_init_dev_mode(self):
preconfig = { preconfig = {
'allocator': 'debug', 'allocator': 'debug',
'dev_mode': 1,
} }
config = { config = {
'faulthandler': 1, 'faulthandler': 1,
'dev_mode': 1,
} }
self.check_config("init_dev_mode", config, preconfig) self.check_config("init_dev_mode", config, preconfig)
def test_init_isolated(self): def test_init_isolated(self):
preconfig = { preconfig = {
'isolated': 1, 'isolated': 0,
'use_environment': 0, 'use_environment': 1,
} }
config = { config = {
'isolated': 1,
'use_environment': 0,
'user_site_directory': 0, 'user_site_directory': 0,
} }
self.check_config("init_isolated", config, preconfig) self.check_config("init_isolated", config, preconfig)

15
Modules/main.c
View file

@ -294,7 +294,7 @@ pymain_init_preconfig(const _PyArgv *args)
goto done; goto done;
} }
err = _Py_PreInitializeFromPreConfig(&config); err = _Py_PreInitializeInPlace(&config);
done: done:
_PyPreConfig_Clear(&config); _PyPreConfig_Clear(&config);
@ -311,11 +311,6 @@ pymain_init_coreconfig(_PyCoreConfig *config, const _PyArgv *args,
return err; return err;
} }
err = _PyCoreConfig_Write(config);
if (_Py_INIT_FAILED(err)) {
return err;
}
return _Py_InitializeCore(interp_p, config); return _Py_InitializeCore(interp_p, config);
} }
@ -483,7 +478,7 @@ pymain_header(const _PyCoreConfig *config)
static void static void
pymain_import_readline(const _PyCoreConfig *config) pymain_import_readline(const _PyCoreConfig *config)
{ {
if (config->preconfig.isolated) { if (config->isolated) {
return; return;
} }
if (!config->inspect && RUN_CODE(config)) { if (!config->inspect && RUN_CODE(config)) {
@ -655,7 +650,7 @@ pymain_run_file(_PyCoreConfig *config, PyCompilerFlags *cf)
static void static void
pymain_run_startup(_PyCoreConfig *config, PyCompilerFlags *cf) pymain_run_startup(_PyCoreConfig *config, PyCompilerFlags *cf)
{ {
const char *startup = _Py_GetEnv(config->preconfig.use_environment, "PYTHONSTARTUP"); const char *startup = _Py_GetEnv(config->use_environment, "PYTHONSTARTUP");
if (startup == NULL) { if (startup == NULL) {
return; return;
} }
@ -735,7 +730,7 @@ pymain_repl(_PyCoreConfig *config, PyCompilerFlags *cf, int *exitcode)
{ {
/* Check this environment variable at the end, to give programs the /* Check this environment variable at the end, to give programs the
opportunity to set it from Python. */ opportunity to set it from Python. */
if (!Py_InspectFlag && _Py_GetEnv(config->preconfig.use_environment, "PYTHONINSPECT")) { if (!Py_InspectFlag && _Py_GetEnv(config->use_environment, "PYTHONINSPECT")) {
Py_InspectFlag = 1; Py_InspectFlag = 1;
config->inspect = 1; config->inspect = 1;
} }
@ -775,7 +770,7 @@ pymain_run_python(PyInterpreterState *interp, int *exitcode)
goto done; goto done;
} }
} }
else if (!config->preconfig.isolated) { else if (!config->isolated) {
PyObject *path0 = NULL; PyObject *path0 = NULL;
if (_PyPathConfig_ComputeSysPath0(&config->argv, &path0)) { if (_PyPathConfig_ComputeSysPath0(&config->argv, &path0)) {
if (path0 == NULL) { if (path0 == NULL) {

2
Programs/_freeze_importlib.c
View file

@ -77,7 +77,7 @@ main(int argc, char *argv[])
text[text_size] = '\0'; text[text_size] = '\0';
_PyCoreConfig config = _PyCoreConfig_INIT; _PyCoreConfig config = _PyCoreConfig_INIT;
config.preconfig.use_environment = 0; config.use_environment = 0;
config.user_site_directory = 0; config.user_site_directory = 0;
config.site_import = 0; config.site_import = 0;
config.program_name = L"./_freeze_importlib"; config.program_name = L"./_freeze_importlib";

47
Programs/_testembed.c
View file

@ -397,6 +397,22 @@ static int test_init_global_config(void)
static int test_init_from_config(void) static int test_init_from_config(void)
{ {
_PyInitError err;
_PyPreConfig preconfig = _PyPreConfig_INIT;
putenv("PYTHONMALLOC=malloc_debug");
preconfig.allocator = "malloc";
putenv("PYTHONUTF8=0");
Py_UTF8Mode = 0;
preconfig.utf8_mode = 1;
err = _Py_PreInitializeFromPreConfig(&preconfig);
if (_Py_INIT_FAILED(err)) {
_Py_ExitInitError(err);
}
/* Test _Py_InitializeFromConfig() */ /* Test _Py_InitializeFromConfig() */
_PyCoreConfig config = _PyCoreConfig_INIT; _PyCoreConfig config = _PyCoreConfig_INIT;
config.install_signal_handlers = 0; config.install_signal_handlers = 0;
@ -407,9 +423,6 @@ static int test_init_from_config(void)
config.use_hash_seed = 1; config.use_hash_seed = 1;
config.hash_seed = 123; config.hash_seed = 123;
putenv("PYTHONMALLOC=malloc_debug");
config.preconfig.allocator = "malloc";
/* dev_mode=1 is tested in test_init_dev_mode() */ /* dev_mode=1 is tested in test_init_dev_mode() */
putenv("PYTHONFAULTHANDLER="); putenv("PYTHONFAULTHANDLER=");
@ -430,10 +443,6 @@ static int test_init_from_config(void)
/* FIXME: test coerce_c_locale and coerce_c_locale_warn */ /* FIXME: test coerce_c_locale and coerce_c_locale_warn */
putenv("PYTHONUTF8=0");
Py_UTF8Mode = 0;
config.preconfig.utf8_mode = 1;
putenv("PYTHONPYCACHEPREFIX=env_pycache_prefix"); putenv("PYTHONPYCACHEPREFIX=env_pycache_prefix");
config.pycache_prefix = L"conf_pycache_prefix"; config.pycache_prefix = L"conf_pycache_prefix";
@ -521,7 +530,7 @@ static int test_init_from_config(void)
Py_FrozenFlag = 0; Py_FrozenFlag = 0;
config._frozen = 1; config._frozen = 1;
_PyInitError err = _Py_InitializeFromConfig(&config); err = _Py_InitializeFromConfig(&config);
/* Don't call _PyCoreConfig_Clear() since all strings are static */ /* Don't call _PyCoreConfig_Clear() since all strings are static */
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
_Py_ExitInitError(err); _Py_ExitInitError(err);
@ -607,20 +616,30 @@ static int test_init_env_dev_mode_alloc(void)
static int test_init_isolated(void) static int test_init_isolated(void)
{ {
_PyInitError err;
_PyPreConfig preconfig = _PyPreConfig_INIT;
/* Set coerce_c_locale and utf8_mode to not depend on the locale */
preconfig.coerce_c_locale = 0;
preconfig.utf8_mode = 0;
err = _Py_PreInitializeFromPreConfig(&preconfig);
if (_Py_INIT_FAILED(err)) {
_Py_ExitInitError(err);
}
/* Test _PyCoreConfig.isolated=1 */ /* Test _PyCoreConfig.isolated=1 */
_PyCoreConfig config = _PyCoreConfig_INIT; _PyCoreConfig config = _PyCoreConfig_INIT;
Py_IsolatedFlag = 0; Py_IsolatedFlag = 0;
config.preconfig.isolated = 1; config.isolated = 1;
/* Set coerce_c_locale and utf8_mode to not depend on the locale */
config.preconfig.coerce_c_locale = 0;
config.preconfig.utf8_mode = 0;
/* Use path starting with "./" avoids a search along the PATH */ /* Use path starting with "./" avoids a search along the PATH */
config.program_name = L"./_testembed"; config.program_name = L"./_testembed";
test_init_env_dev_mode_putenvs(); test_init_env_dev_mode_putenvs();
_PyInitError err = _Py_InitializeFromConfig(&config); err = _Py_InitializeFromConfig(&config);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
_Py_ExitInitError(err); _Py_ExitInitError(err);
} }
@ -635,7 +654,7 @@ static int test_init_dev_mode(void)
_PyCoreConfig config = _PyCoreConfig_INIT; _PyCoreConfig config = _PyCoreConfig_INIT;
putenv("PYTHONFAULTHANDLER="); putenv("PYTHONFAULTHANDLER=");
putenv("PYTHONMALLOC="); putenv("PYTHONMALLOC=");
config.preconfig.dev_mode = 1; config.dev_mode = 1;
config.program_name = L"./_testembed"; config.program_name = L"./_testembed";
_PyInitError err = _Py_InitializeFromConfig(&config); _PyInitError err = _Py_InitializeFromConfig(&config);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {

85
Python/coreconfig.c
View file

@ -469,8 +469,6 @@ Py_GetArgcArgv(int *argc, wchar_t ***argv)
void void
_PyCoreConfig_Clear(_PyCoreConfig *config) _PyCoreConfig_Clear(_PyCoreConfig *config)
{ {
_PyPreConfig_Clear(&config->preconfig);
#define CLEAR(ATTR) \ #define CLEAR(ATTR) \
do { \ do { \
PyMem_RawFree(ATTR); \ PyMem_RawFree(ATTR); \
@ -514,10 +512,6 @@ _PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
{ {
_PyCoreConfig_Clear(config); _PyCoreConfig_Clear(config);
if (_PyPreConfig_Copy(&config->preconfig, &config2->preconfig) < 0) {
return -1;
}
#define COPY_ATTR(ATTR) config->ATTR = config2->ATTR #define COPY_ATTR(ATTR) config->ATTR = config2->ATTR
#define COPY_STR_ATTR(ATTR) \ #define COPY_STR_ATTR(ATTR) \
do { \ do { \
@ -544,6 +538,9 @@ _PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
} \ } \
} while (0) } while (0)
COPY_ATTR(isolated);
COPY_ATTR(use_environment);
COPY_ATTR(dev_mode);
COPY_ATTR(install_signal_handlers); COPY_ATTR(install_signal_handlers);
COPY_ATTR(use_hash_seed); COPY_ATTR(use_hash_seed);
COPY_ATTR(hash_seed); COPY_ATTR(hash_seed);
@ -613,7 +610,7 @@ _PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
static const char* static const char*
_PyCoreConfig_GetEnv(const _PyCoreConfig *config, const char *name) _PyCoreConfig_GetEnv(const _PyCoreConfig *config, const char *name)
{ {
return _Py_GetEnv(config->preconfig.use_environment, name); return _Py_GetEnv(config->use_environment, name);
} }
@ -622,9 +619,9 @@ _PyCoreConfig_GetEnvDup(const _PyCoreConfig *config,
wchar_t **dest, wchar_t **dest,
wchar_t *wname, char *name) wchar_t *wname, char *name)
{ {
assert(config->preconfig.use_environment >= 0); assert(config->use_environment >= 0);
if (!config->preconfig.use_environment) { if (!config->use_environment) {
*dest = NULL; *dest = NULL;
return 0; return 0;
} }
@ -668,8 +665,6 @@ _PyCoreConfig_GetEnvDup(const _PyCoreConfig *config,
void void
_PyCoreConfig_GetGlobalConfig(_PyCoreConfig *config) _PyCoreConfig_GetGlobalConfig(_PyCoreConfig *config)
{ {
_PyPreConfig_GetGlobalConfig(&config->preconfig);
#define COPY_FLAG(ATTR, VALUE) \ #define COPY_FLAG(ATTR, VALUE) \
if (config->ATTR == -1) { \ if (config->ATTR == -1) { \
config->ATTR = VALUE; \ config->ATTR = VALUE; \
@ -679,6 +674,8 @@ _PyCoreConfig_GetGlobalConfig(_PyCoreConfig *config)
config->ATTR = !(VALUE); \ config->ATTR = !(VALUE); \
} }
COPY_FLAG(isolated, Py_IsolatedFlag);
COPY_NOT_FLAG(use_environment, Py_IgnoreEnvironmentFlag);
COPY_FLAG(bytes_warning, Py_BytesWarningFlag); COPY_FLAG(bytes_warning, Py_BytesWarningFlag);
COPY_FLAG(inspect, Py_InspectFlag); COPY_FLAG(inspect, Py_InspectFlag);
COPY_FLAG(interactive, Py_InteractiveFlag); COPY_FLAG(interactive, Py_InteractiveFlag);
@ -714,6 +711,8 @@ _PyCoreConfig_SetGlobalConfig(const _PyCoreConfig *config)
VAR = !config->ATTR; \ VAR = !config->ATTR; \
} }
COPY_FLAG(isolated, Py_IsolatedFlag);
COPY_NOT_FLAG(use_environment, Py_IgnoreEnvironmentFlag);
COPY_FLAG(bytes_warning, Py_BytesWarningFlag); COPY_FLAG(bytes_warning, Py_BytesWarningFlag);
COPY_FLAG(inspect, Py_InspectFlag); COPY_FLAG(inspect, Py_InspectFlag);
COPY_FLAG(interactive, Py_InteractiveFlag); COPY_FLAG(interactive, Py_InteractiveFlag);
@ -924,7 +923,7 @@ config_wstr_to_int(const wchar_t *wstr, int *result)
static _PyInitError static _PyInitError
config_read_env_vars(_PyCoreConfig *config) config_read_env_vars(_PyCoreConfig *config)
{ {
int use_env = config->preconfig.use_environment; int use_env = config->use_environment;
/* Get environment variables */ /* Get environment variables */
_Py_get_env_flag(use_env, &config->parser_debug, "PYTHONDEBUG"); _Py_get_env_flag(use_env, &config->parser_debug, "PYTHONDEBUG");
@ -1149,7 +1148,8 @@ get_locale_encoding(char **locale_encoding)
static _PyInitError static _PyInitError
config_init_stdio_encoding(_PyCoreConfig *config) config_init_stdio_encoding(_PyCoreConfig *config,
const _PyPreConfig *preconfig)
{ {
/* If Py_SetStandardStreamEncoding() have been called, use these /* If Py_SetStandardStreamEncoding() have been called, use these
parameters. */ parameters. */
@ -1219,7 +1219,7 @@ config_init_stdio_encoding(_PyCoreConfig *config)
} }
/* UTF-8 Mode uses UTF-8/surrogateescape */ /* UTF-8 Mode uses UTF-8/surrogateescape */
if (config->preconfig.utf8_mode) { if (preconfig->utf8_mode) {
if (config->stdio_encoding == NULL) { if (config->stdio_encoding == NULL) {
config->stdio_encoding = _PyMem_RawStrdup("utf-8"); config->stdio_encoding = _PyMem_RawStrdup("utf-8");
if (config->stdio_encoding == NULL) { if (config->stdio_encoding == NULL) {
@ -1254,10 +1254,10 @@ config_init_stdio_encoding(_PyCoreConfig *config)
static _PyInitError static _PyInitError
config_init_fs_encoding(_PyCoreConfig *config) config_init_fs_encoding(_PyCoreConfig *config, const _PyPreConfig *preconfig)
{ {
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
if (config->preconfig.legacy_windows_fs_encoding) { if (preconfig->legacy_windows_fs_encoding) {
/* Legacy Windows filesystem encoding: mbcs/replace */ /* Legacy Windows filesystem encoding: mbcs/replace */
if (config->filesystem_encoding == NULL) { if (config->filesystem_encoding == NULL) {
config->filesystem_encoding = _PyMem_RawStrdup("mbcs"); config->filesystem_encoding = _PyMem_RawStrdup("mbcs");
@ -1292,7 +1292,7 @@ config_init_fs_encoding(_PyCoreConfig *config)
} }
#else #else
if (config->filesystem_encoding == NULL) { if (config->filesystem_encoding == NULL) {
if (config->preconfig.utf8_mode) { if (preconfig->utf8_mode) {
/* UTF-8 Mode use: utf-8/surrogateescape */ /* UTF-8 Mode use: utf-8/surrogateescape */
config->filesystem_encoding = _PyMem_RawStrdup("utf-8"); config->filesystem_encoding = _PyMem_RawStrdup("utf-8");
/* errors defaults to surrogateescape above */ /* errors defaults to surrogateescape above */
@ -1341,12 +1341,8 @@ config_read_impl(_PyCoreConfig *config, _PyPreCmdline *cmdline)
{ {
_PyInitError err; _PyInitError err;
err = _Py_PreInitializeFromConfig(config); const _PyPreConfig *preconfig = &_PyRuntime.preconfig;
if (_Py_INIT_FAILED(err)) { _PyPreCmdline_GetPreConfig(cmdline, preconfig);
return err;
}
_PyPreCmdline_GetPreConfig(cmdline, &_PyRuntime.preconfig);
_PyPreCmdline_GetCoreConfig(cmdline, config); _PyPreCmdline_GetCoreConfig(cmdline, config);
err = _PyPreCmdline_Read(cmdline); err = _PyPreCmdline_Read(cmdline);
@ -1360,19 +1356,16 @@ config_read_impl(_PyCoreConfig *config, _PyPreCmdline *cmdline)
return _Py_INIT_NO_MEMORY(); return _Py_INIT_NO_MEMORY();
} }
if (_PyPreConfig_Copy(&config->preconfig, &_PyRuntime.preconfig) < 0) {
return _Py_INIT_NO_MEMORY();
}
_PyCoreConfig_GetGlobalConfig(config); _PyCoreConfig_GetGlobalConfig(config);
assert(config->preconfig.use_environment >= 0); assert(config->use_environment >= 0);
if (config->preconfig.isolated > 0) { if (config->isolated > 0) {
config->use_environment = 0;
config->user_site_directory = 0; config->user_site_directory = 0;
} }
if (config->preconfig.use_environment) { if (config->use_environment) {
err = config_read_env_vars(config); err = config_read_env_vars(config);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
return err; return err;
@ -1421,7 +1414,7 @@ config_read_impl(_PyCoreConfig *config, _PyPreCmdline *cmdline)
} }
/* default values */ /* default values */
if (config->preconfig.dev_mode) { if (config->dev_mode) {
if (config->faulthandler < 0) { if (config->faulthandler < 0) {
config->faulthandler = 1; config->faulthandler = 1;
} }
@ -1438,13 +1431,13 @@ config_read_impl(_PyCoreConfig *config, _PyPreCmdline *cmdline)
} }
if (config->filesystem_encoding == NULL || config->filesystem_errors == NULL) { if (config->filesystem_encoding == NULL || config->filesystem_errors == NULL) {
err = config_init_fs_encoding(config); err = config_init_fs_encoding(config, preconfig);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
return err; return err;
} }
} }
err = config_init_stdio_encoding(config); err = config_init_stdio_encoding(config, preconfig);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
return err; return err;
} }
@ -1456,7 +1449,7 @@ config_read_impl(_PyCoreConfig *config, _PyPreCmdline *cmdline)
} }
} }
assert(config->preconfig.use_environment >= 0); assert(config->use_environment >= 0);
assert(config->filesystem_encoding != NULL); assert(config->filesystem_encoding != NULL);
assert(config->filesystem_errors != NULL); assert(config->filesystem_errors != NULL);
assert(config->stdio_encoding != NULL); assert(config->stdio_encoding != NULL);
@ -1544,22 +1537,11 @@ config_init_stdio(const _PyCoreConfig *config)
- set Py_xxx global configuration variables - set Py_xxx global configuration variables
- initialize C standard streams (stdin, stdout, stderr) */ - initialize C standard streams (stdin, stdout, stderr) */
_PyInitError void
_PyCoreConfig_Write(const _PyCoreConfig *config) _PyCoreConfig_Write(const _PyCoreConfig *config)
{ {
_PyCoreConfig_SetGlobalConfig(config); _PyCoreConfig_SetGlobalConfig(config);
config_init_stdio(config); config_init_stdio(config);
/* Write the new pre-configuration into _PyRuntime */
PyMemAllocatorEx old_alloc;
_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
int res = _PyPreConfig_Copy(&_PyRuntime.preconfig, &config->preconfig);
PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
if (res < 0) {
return _Py_INIT_NO_MEMORY();
}
return _Py_INIT_OK();
} }
@ -1604,6 +1586,9 @@ _PyCoreConfig_AsDict(const _PyCoreConfig *config)
#define SET_ITEM_WSTRLIST(LIST) \ #define SET_ITEM_WSTRLIST(LIST) \
SET_ITEM(#LIST, _PyWstrList_AsList(&config->LIST)) SET_ITEM(#LIST, _PyWstrList_AsList(&config->LIST))
SET_ITEM_INT(isolated);
SET_ITEM_INT(use_environment);
SET_ITEM_INT(dev_mode);
SET_ITEM_INT(install_signal_handlers); SET_ITEM_INT(install_signal_handlers);
SET_ITEM_INT(use_hash_seed); SET_ITEM_INT(use_hash_seed);
SET_ITEM_UINT(hash_seed); SET_ITEM_UINT(hash_seed);
@ -1945,7 +1930,7 @@ config_init_warnoptions(_PyCoreConfig *config, const _PyCmdline *cmdline)
* the lowest precedence entries first so that later entries override them. * the lowest precedence entries first so that later entries override them.
*/ */
if (config->preconfig.dev_mode) { if (config->dev_mode) {
if (_PyWstrList_Append(&config->warnoptions, L"default")) { if (_PyWstrList_Append(&config->warnoptions, L"default")) {
return _Py_INIT_NO_MEMORY(); return _Py_INIT_NO_MEMORY();
} }
@ -2101,7 +2086,7 @@ config_from_cmdline(_PyCoreConfig *config, _PyCmdline *cmdline)
return err; return err;
} }
if (config->preconfig.use_environment) { if (config->use_environment) {
err = cmdline_init_env_warnoptions(cmdline, config); err = cmdline_init_env_warnoptions(cmdline, config);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
return err; return err;
@ -2178,8 +2163,7 @@ _Py_GetConfigsAsDict(void)
/* pre config */ /* pre config */
PyInterpreterState *interp = _PyInterpreterState_Get(); PyInterpreterState *interp = _PyInterpreterState_Get();
const _PyCoreConfig *core_config = _PyInterpreterState_GetCoreConfig(interp); const _PyPreConfig *pre_config = &_PyRuntime.preconfig;
const _PyPreConfig *pre_config = &core_config->preconfig;
dict = _PyPreConfig_AsDict(pre_config); dict = _PyPreConfig_AsDict(pre_config);
if (dict == NULL) { if (dict == NULL) {
goto error; goto error;
@ -2190,6 +2174,7 @@ _Py_GetConfigsAsDict(void)
Py_CLEAR(dict); Py_CLEAR(dict);
/* core config */ /* core config */
const _PyCoreConfig *core_config = _PyInterpreterState_GetCoreConfig(interp);
dict = _PyCoreConfig_AsDict(core_config); dict = _PyCoreConfig_AsDict(core_config);
if (dict == NULL) { if (dict == NULL) {
goto error; goto error;

2
Python/pathconfig.c
View file

@ -331,7 +331,7 @@ _PyCoreConfig_CalculatePathConfig(_PyCoreConfig *config)
#endif #endif
if (path_config.isolated != -1) { if (path_config.isolated != -1) {
config->preconfig.isolated = path_config.isolated; config->isolated = path_config.isolated;
} }
if (path_config.site_import != -1) { if (path_config.site_import != -1) {
config->site_import = path_config.site_import; config->site_import = path_config.site_import;

46
Python/preconfig.c
View file

@ -143,6 +143,23 @@ _PyPreCmdline_GetPreConfig(_PyPreCmdline *cmdline, const _PyPreConfig *config)
COPY_ATTR(use_environment); COPY_ATTR(use_environment);
COPY_ATTR(isolated); COPY_ATTR(isolated);
COPY_ATTR(dev_mode);
#undef COPY_ATTR
}
void
_PyPreCmdline_SetPreConfig(const _PyPreCmdline *cmdline, _PyPreConfig *config)
{
#define COPY_ATTR(ATTR) \
if (cmdline->ATTR != -1) { \
config->ATTR = cmdline->ATTR; \
}
COPY_ATTR(use_environment);
COPY_ATTR(isolated);
COPY_ATTR(dev_mode);
#undef COPY_ATTR #undef COPY_ATTR
} }
@ -152,12 +169,13 @@ void
_PyPreCmdline_GetCoreConfig(_PyPreCmdline *cmdline, const _PyCoreConfig *config) _PyPreCmdline_GetCoreConfig(_PyPreCmdline *cmdline, const _PyCoreConfig *config)
{ {
#define COPY_ATTR(ATTR) \ #define COPY_ATTR(ATTR) \
if (config->preconfig.ATTR != -1) { \ if (config->ATTR != -1) { \
cmdline->ATTR = config->preconfig.ATTR; \ cmdline->ATTR = config->ATTR; \
} }
COPY_ATTR(use_environment); COPY_ATTR(use_environment);
COPY_ATTR(isolated); COPY_ATTR(isolated);
COPY_ATTR(dev_mode);
#undef COPY_ATTR #undef COPY_ATTR
} }
@ -167,12 +185,13 @@ void
_PyPreCmdline_SetCoreConfig(const _PyPreCmdline *cmdline, _PyCoreConfig *config) _PyPreCmdline_SetCoreConfig(const _PyPreCmdline *cmdline, _PyCoreConfig *config)
{ {
#define COPY_ATTR(ATTR) \ #define COPY_ATTR(ATTR) \
if (config->preconfig.ATTR == -1 && cmdline->ATTR != -1) { \ if (config->ATTR == -1 && cmdline->ATTR != -1) { \
config->preconfig.ATTR = cmdline->ATTR; \ config->ATTR = cmdline->ATTR; \
} }
COPY_ATTR(use_environment); COPY_ATTR(use_environment);
COPY_ATTR(isolated); COPY_ATTR(isolated);
COPY_ATTR(dev_mode);
#undef COPY_ATTR #undef COPY_ATTR
} }
@ -206,13 +225,13 @@ _PyPreConfig_Copy(_PyPreConfig *config, const _PyPreConfig *config2)
COPY_ATTR(isolated); COPY_ATTR(isolated);
COPY_ATTR(use_environment); COPY_ATTR(use_environment);
COPY_ATTR(dev_mode);
COPY_ATTR(coerce_c_locale); COPY_ATTR(coerce_c_locale);
COPY_ATTR(coerce_c_locale_warn); COPY_ATTR(coerce_c_locale_warn);
#ifdef MS_WINDOWS #ifdef MS_WINDOWS
COPY_ATTR(legacy_windows_fs_encoding); COPY_ATTR(legacy_windows_fs_encoding);
#endif #endif
COPY_ATTR(utf8_mode); COPY_ATTR(utf8_mode);
COPY_ATTR(dev_mode);
COPY_STR_ATTR(allocator); COPY_STR_ATTR(allocator);
#undef COPY_ATTR #undef COPY_ATTR
@ -567,21 +586,6 @@ get_ctype_locale(char **locale_p)
} }
void
_PyPreCmdline_SetPreConfig(const _PyPreCmdline *cmdline, _PyPreConfig *config)
{
#define COPY_ATTR(ATTR) \
if (cmdline->ATTR != -1) { \
config->ATTR = cmdline->ATTR; \
}
COPY_ATTR(use_environment);
COPY_ATTR(isolated);
#undef COPY_ATTR
}
PyObject* PyObject*
_PyPreConfig_AsDict(const _PyPreConfig *config) _PyPreConfig_AsDict(const _PyPreConfig *config)
{ {
@ -712,7 +716,7 @@ _PyPreConfig_Read(_PyPreConfig *config, const _PyArgv *args,
if (coreconfig) { if (coreconfig) {
_PyPreCmdline_GetCoreConfig(&cmdline, coreconfig); _PyPreCmdline_GetCoreConfig(&cmdline, coreconfig);
if (config->dev_mode == -1) { if (config->dev_mode == -1) {
config->dev_mode = coreconfig->preconfig.dev_mode; config->dev_mode = coreconfig->dev_mode;
} }
} }

54
Python/pylifecycle.c
View file

@ -286,9 +286,10 @@ static const char *_C_LOCALE_WARNING =
"locales is recommended.\n"; "locales is recommended.\n";
static void static void
_emit_stderr_warning_for_legacy_locale(const _PyCoreConfig *core_config) _emit_stderr_warning_for_legacy_locale(void)
{ {
if (core_config->preconfig.coerce_c_locale_warn && _Py_LegacyLocaleDetected()) { const _PyPreConfig *preconfig = &_PyRuntime.preconfig;
if (preconfig->coerce_c_locale_warn && _Py_LegacyLocaleDetected()) {
PySys_FormatStderr("%s", _C_LOCALE_WARNING); PySys_FormatStderr("%s", _C_LOCALE_WARNING);
} }
} }
@ -675,6 +676,8 @@ _Py_InitializeCore_impl(PyInterpreterState **interp_p,
{ {
PyInterpreterState *interp; PyInterpreterState *interp;
_PyCoreConfig_Write(core_config);
_PyInitError err = pycore_init_runtime(core_config); _PyInitError err = pycore_init_runtime(core_config);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
return err; return err;
@ -720,54 +723,64 @@ pyinit_preinit(_PyPreConfig *config,
const _PyCoreConfig *coreconfig) const _PyCoreConfig *coreconfig)
{ {
_PyInitError err; _PyInitError err;
_PyPreConfig local_config = _PyPreConfig_INIT;
if (!config) {
config = &local_config;
}
err = _PyRuntime_Initialize(); err = _PyRuntime_Initialize();
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
return err; goto done;
} }
if (_PyRuntime.pre_initialized) { if (_PyRuntime.pre_initialized) {
/* If it's already configured: ignored the new configuration */ /* If it's already configured: ignored the new configuration */
return _Py_INIT_OK(); err = _Py_INIT_OK();
} goto done;
if (!src_config && coreconfig) {
src_config = &coreconfig->preconfig;
} }
if (src_config) { if (src_config) {
if (_PyPreConfig_Copy(config, src_config) < 0) { if (_PyPreConfig_Copy(config, src_config) < 0) {
return _Py_INIT_ERR("failed to copy pre config"); err = _Py_INIT_ERR("failed to copy pre config");
goto done;
} }
} }
err = _PyPreConfig_Read(config, NULL, coreconfig); err = _PyPreConfig_Read(config, NULL, coreconfig);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
return err; goto done;
} }
err = _PyPreConfig_Write(config); err = _PyPreConfig_Write(config);
if (_Py_INIT_FAILED(err)) { if (_Py_INIT_FAILED(err)) {
return err; goto done;
} }
_PyRuntime.pre_initialized = 1; _PyRuntime.pre_initialized = 1;
return _Py_INIT_OK(); err = _Py_INIT_OK();
done:
_PyPreConfig_Clear(&local_config);
return err;
} }
_PyInitError _PyInitError
_Py_PreInitialize(void) _Py_PreInitialize(void)
{ {
_PyPreConfig config = _PyPreConfig_INIT; return pyinit_preinit(NULL, NULL, NULL);
_PyInitError err = pyinit_preinit(&config, NULL, NULL);
_PyPreConfig_Clear(&config);
return err;
} }
_PyInitError _PyInitError
_Py_PreInitializeFromPreConfig(_PyPreConfig *config) _Py_PreInitializeFromPreConfig(const _PyPreConfig *src_config)
{
return pyinit_preinit(NULL, src_config, NULL);
}
_PyInitError
_Py_PreInitializeInPlace(_PyPreConfig *config)
{ {
return pyinit_preinit(config, NULL, NULL); return pyinit_preinit(config, NULL, NULL);
} }
@ -776,10 +789,7 @@ _Py_PreInitializeFromPreConfig(_PyPreConfig *config)
_PyInitError _PyInitError
_Py_PreInitializeFromConfig(const _PyCoreConfig *coreconfig) _Py_PreInitializeFromConfig(const _PyCoreConfig *coreconfig)
{ {
_PyPreConfig config = _PyPreConfig_INIT; return pyinit_preinit(NULL, NULL, coreconfig);
_PyInitError err = pyinit_preinit(&config, NULL, coreconfig);
_PyPreConfig_Clear(&config);
return err;
} }
@ -964,7 +974,7 @@ _Py_InitializeMainInterpreter(PyInterpreterState *interp,
} }
#ifndef MS_WINDOWS #ifndef MS_WINDOWS
_emit_stderr_warning_for_legacy_locale(core_config); _emit_stderr_warning_for_legacy_locale();
#endif #endif
return _Py_INIT_OK(); return _Py_INIT_OK();

9
Python/sysmodule.c
View file

@ -2158,6 +2158,7 @@ make_flags(void)
{ {
int pos = 0; int pos = 0;
PyObject *seq; PyObject *seq;
const _PyPreConfig *preconfig = &_PyRuntime.preconfig;
const _PyCoreConfig *config = &_PyInterpreterState_GET_UNSAFE()->core_config; const _PyCoreConfig *config = &_PyInterpreterState_GET_UNSAFE()->core_config;
seq = PyStructSequence_New(&FlagsType); seq = PyStructSequence_New(&FlagsType);
@ -2174,16 +2175,16 @@ make_flags(void)
SetFlag(!config->write_bytecode); SetFlag(!config->write_bytecode);
SetFlag(!config->user_site_directory); SetFlag(!config->user_site_directory);
SetFlag(!config->site_import); SetFlag(!config->site_import);
SetFlag(!config->preconfig.use_environment); SetFlag(!config->use_environment);
SetFlag(config->verbose); SetFlag(config->verbose);
/* SetFlag(saw_unbuffered_flag); */ /* SetFlag(saw_unbuffered_flag); */
/* SetFlag(skipfirstline); */ /* SetFlag(skipfirstline); */
SetFlag(config->bytes_warning); SetFlag(config->bytes_warning);
SetFlag(config->quiet); SetFlag(config->quiet);
SetFlag(config->use_hash_seed == 0 || config->hash_seed != 0); SetFlag(config->use_hash_seed == 0 || config->hash_seed != 0);
SetFlag(config->preconfig.isolated); SetFlag(config->isolated);
PyStructSequence_SET_ITEM(seq, pos++, PyBool_FromLong(config->preconfig.dev_mode)); PyStructSequence_SET_ITEM(seq, pos++, PyBool_FromLong(config->dev_mode));
SetFlag(config->preconfig.utf8_mode); SetFlag(preconfig->utf8_mode);
#undef SetFlag #undef SetFlag
if (PyErr_Occurred()) { if (PyErr_Occurred()) {