Mirrors
/
cpython
mirror of https://github.com/python/cpython
3
0
Fork 0
Code Releases Activity
Browse Source

bpo-36763: Add _PyCoreConfig_SetString() (GH-13035) 

Add 3 new config methods:

* _PyCoreConfig_SetString()
* _PyCoreConfig_SetWideString()
* _PyCoreConfig_SetWideStringFromString()

Changes:

* _PyCoreConfig_Copy() returns _PyInitError.
* Add CONFIG_GET_ENV_DUP().
pull/13038/head
Victor Stinner 7 years ago
committed by GitHub
parent
2fc936ed24
commit
1a9f0d8efd
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 251 additions and 168 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      Include/internal/pycore_coreconfig.h
  2. 384
      Python/coreconfig.c
  3. 23
      Python/pylifecycle.c

12
Include/internal/pycore_coreconfig.h
View File

@ -102,16 +102,24 @@ PyAPI_FUNC(_PyInitError) _PyPreConfig_Write(_PyPreConfig *config);
/* --- _PyCoreConfig ---------------------------------------------- */
PyAPI_FUNC(void) _PyCoreConfig_Clear(_PyCoreConfig *);
PyAPI_FUNC(int) _PyCoreConfig_Copy(
PyAPI_FUNC(_PyInitError) _PyCoreConfig_Copy(
_PyCoreConfig *config,
const _PyCoreConfig *config2);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_SetString(
char **config_str,
const char *str);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_SetWideString(
wchar_t **config_str,
const wchar_t *str);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_SetWideStringFromString(
wchar_t **config_str,
const char *str);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_InitPathConfig(_PyCoreConfig *config);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_SetPathConfig(
const _PyCoreConfig *config);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_Read(_PyCoreConfig *config);
PyAPI_FUNC(void) _PyCoreConfig_Write(const _PyCoreConfig *config,
_PyRuntimeState *runtime);
PyAPI_FUNC(_PyInitError) _PyCoreConfig_SetPyArgv(
_PyCoreConfig *config,
const _PyArgv *args);

384
Python/coreconfig.c
View File

@ -520,34 +520,111 @@ _PyCoreConfig_Clear(_PyCoreConfig *config)
}
int
/* Copy str into *config_str (duplicate the string) */
_PyInitError
_PyCoreConfig_SetString(char **config_str, const char *str)
{
char *str2;
if (str != NULL) {
str2 = _PyMem_RawStrdup(str);
if (str2 == NULL) {
return _Py_INIT_NO_MEMORY();
}
}
else {
str2 = NULL;
}
PyMem_RawFree(*config_str);
*config_str = str2;
return _Py_INIT_OK();
}
/* Copy str into *config_str (duplicate the string) */
_PyInitError
_PyCoreConfig_SetWideString(wchar_t **config_str, const wchar_t *str)
{
wchar_t *str2;
if (str != NULL) {
str2 = _PyMem_RawWcsdup(str);
if (str2 == NULL) {
return _Py_INIT_NO_MEMORY();
}
}
else {
str2 = NULL;
}
PyMem_RawFree(*config_str);
*config_str = str2;
return _Py_INIT_OK();
}
/* Decode str using Py_DecodeLocale() and set the result into *config_str */
static _PyInitError
_PyCoreConfig_SetWideStringFromStringErr(wchar_t **config_str, const char *str,
const char *decode_err_msg)
{
wchar_t *str2;
if (str != NULL) {
size_t len;
str2 = Py_DecodeLocale(str, &len);
if (str2 == NULL) {
if (len == (size_t)-2) {
return _Py_INIT_ERR(decode_err_msg);
}
else {
return _Py_INIT_NO_MEMORY();
}
}
}
else {
str2 = NULL;
}
PyMem_RawFree(*config_str);
*config_str = str2;
return _Py_INIT_OK();
}
_PyInitError
_PyCoreConfig_SetWideStringFromString(wchar_t **config_str, const char *str)
{
return _PyCoreConfig_SetWideStringFromStringErr(
config_str, str, "cannot decode string");
}
#define CONFIG_DECODE_LOCALE(config_str, str, NAME) \
_PyCoreConfig_SetWideStringFromStringErr(config_str, str, \
"cannot decode " NAME)
_PyInitError
_PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
{
_PyInitError err;
_PyCoreConfig_Clear(config);
#define COPY_ATTR(ATTR) config->ATTR = config2->ATTR
#define COPY_STR_ATTR(ATTR) \
do { \
if (config2->ATTR != NULL) { \
config->ATTR = _PyMem_RawStrdup(config2->ATTR); \
if (config->ATTR == NULL) { \
return -1; \
} \
err = _PyCoreConfig_SetString(&config->ATTR, config2->ATTR); \
if (_Py_INIT_FAILED(err)) { \
return err; \
} \
} while (0)
#define COPY_WSTR_ATTR(ATTR) \
do { \
if (config2->ATTR != NULL) { \
config->ATTR = _PyMem_RawWcsdup(config2->ATTR); \
if (config->ATTR == NULL) { \
return -1; \
} \
err = _PyCoreConfig_SetWideString(&config->ATTR, config2->ATTR); \
if (_Py_INIT_FAILED(err)) { \
return err; \
} \
} while (0)
#define COPY_WSTRLIST(LIST) \
do { \
if (_PyWstrList_Copy(&config->LIST, &config2->LIST) < 0 ) { \
return -1; \
return _Py_INIT_NO_MEMORY(); \
} \
} while (0)
@ -617,7 +694,7 @@ _PyCoreConfig_Copy(_PyCoreConfig *config, const _PyCoreConfig *config2)
#undef COPY_STR_ATTR
#undef COPY_WSTR_ATTR
#undef COPY_WSTRLIST
return 0;
return _Py_INIT_OK();
}
@ -746,54 +823,44 @@ _PyCoreConfig_GetEnv(const _PyCoreConfig *config, const char *name)
/* Get a copy of the environment variable as wchar_t*.
Return 0 on success, but *dest can be NULL.
Return -1 on memory allocation failure. Return -2 on decoding error. */
static int
static _PyInitError
_PyCoreConfig_GetEnvDup(const _PyCoreConfig *config,
wchar_t **dest,
wchar_t *wname, char *name)
wchar_t *wname, char *name,
const char *decode_err_msg)
{
assert(*dest == NULL);
assert(config->use_environment >= 0);
if (!config->use_environment) {
*dest = NULL;
return 0;
return _Py_INIT_OK();
}
#ifdef MS_WINDOWS
const wchar_t *var = _wgetenv(wname);
if (!var || var[0] == '\0') {
*dest = NULL;
return 0;
}
wchar_t *copy = _PyMem_RawWcsdup(var);
if (copy == NULL) {
return -1;
return _Py_INIT_OK();
}
*dest = copy;
return _PyCoreConfig_SetWideString(dest, var);
#else
const char *var = getenv(name);
if (!var || var[0] == '\0') {
*dest = NULL;
return 0;
return _Py_INIT_OK();
}
size_t len;
wchar_t *wvar = Py_DecodeLocale(var, &len);
if (!wvar) {
if (len == (size_t)-2) {
return -2;
}
else {
return -1;
}
}
*dest = wvar;
return _PyCoreConfig_SetWideStringFromStringErr(dest, var, decode_err_msg);
#endif
return 0;
}
#define CONFIG_GET_ENV_DUP(CONFIG, DEST, WNAME, NAME) \
_PyCoreConfig_GetEnvDup(CONFIG, DEST, WNAME, NAME, "cannot decode " NAME)
static void
_PyCoreConfig_GetGlobalConfig(_PyCoreConfig *config)
{
@ -876,6 +943,7 @@ _PyCoreConfig_SetGlobalConfig(const _PyCoreConfig *config)
static _PyInitError
config_init_program_name(_PyCoreConfig *config)
{
_PyInitError err;
assert(config->program_name == NULL);
/* If Py_SetProgramName() was called, use its value */
@ -900,13 +968,11 @@ config_init_program_name(_PyCoreConfig *config)
script. */
const char *p = _PyCoreConfig_GetEnv(config, "PYTHONEXECUTABLE");
if (p != NULL) {
size_t len;
wchar_t* program_name = Py_DecodeLocale(p, &len);
if (program_name == NULL) {
return DECODE_LOCALE_ERR("PYTHONEXECUTABLE environment "
"variable", (Py_ssize_t)len);
err = CONFIG_DECODE_LOCALE(&config->program_name, p,
"PYTHONEXECUTABLE environment variable");
if (_Py_INIT_FAILED(err)) {
return err;
}
config->program_name = program_name;
return _Py_INIT_OK();
}
#ifdef WITH_NEXT_FRAMEWORK
@ -916,13 +982,11 @@ config_init_program_name(_PyCoreConfig *config)
/* Used by Mac/Tools/pythonw.c to forward
* the argv0 of the stub executable
*/
size_t len;
wchar_t* program_name = Py_DecodeLocale(pyvenv_launcher, &len);
if (program_name == NULL) {
return DECODE_LOCALE_ERR("__PYVENV_LAUNCHER__ environment "
"variable", (Py_ssize_t)len);
err = CONFIG_DECODE_LOCALE(&config->program_name, pyvenv_launcher,
"__PYVENV_LAUNCHER__ environment variable");
if (_Py_INIT_FAILED(err)) {
return err;
}
config->program_name = program_name;
return _Py_INIT_OK();
}
}
@ -931,9 +995,10 @@ config_init_program_name(_PyCoreConfig *config)
/* Use argv[0] by default, if available */
if (config->program != NULL) {
config->program_name = _PyMem_RawWcsdup(config->program);
if (config->program_name == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetWideString(&config->program_name,
config->program);
if (_Py_INIT_FAILED(err)) {
return err;
}
return _Py_INIT_OK();
}
@ -944,9 +1009,9 @@ config_init_program_name(_PyCoreConfig *config)
#else
const wchar_t *default_program_name = L"python3";
#endif
config->program_name = _PyMem_RawWcsdup(default_program_name);
if (config->program_name == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetWideString(&config->program_name, default_program_name);
if (_Py_INIT_FAILED(err)) {
return err;
}
return _Py_INIT_OK();
}
@ -959,13 +1024,13 @@ config_init_executable(_PyCoreConfig *config)
/* If Py_SetProgramFullPath() was called, use its value */
const wchar_t *program_full_path = _Py_path_config.program_full_path;
if (program_full_path != NULL) {
config->executable = _PyMem_RawWcsdup(program_full_path);
if (config->executable == NULL) {
return _Py_INIT_NO_MEMORY();
_PyInitError err = _PyCoreConfig_SetWideString(&config->executable,
program_full_path);
if (_Py_INIT_FAILED(err)) {
return err;
}
return _Py_INIT_OK();
}
return _Py_INIT_OK();
}
@ -985,20 +1050,15 @@ config_init_home(_PyCoreConfig *config)
/* If Py_SetPythonHome() was called, use its value */
wchar_t *home = _Py_path_config.home;
if (home) {
config->home = _PyMem_RawWcsdup(home);
if (config->home == NULL) {
return _Py_INIT_NO_MEMORY();
_PyInitError err = _PyCoreConfig_SetWideString(&config->home, home);
if (_Py_INIT_FAILED(err)) {
return err;
}
return _Py_INIT_OK();
}
int res = _PyCoreConfig_GetEnvDup(config, &home,
L"PYTHONHOME", "PYTHONHOME");
if (res < 0) {
return DECODE_LOCALE_ERR("PYTHONHOME", res);
}
config->home = home;
return _Py_INIT_OK();
return CONFIG_GET_ENV_DUP(config, &config->home,
L"PYTHONHOME", "PYTHONHOME");
}
@ -1055,6 +1115,7 @@ config_wstr_to_int(const wchar_t *wstr, int *result)
static _PyInitError
config_read_env_vars(_PyCoreConfig *config)
{
_PyInitError err;
int use_env = config->use_environment;
/* Get environment variables */
@ -1094,17 +1155,15 @@ config_read_env_vars(_PyCoreConfig *config)
}
if (config->module_search_path_env == NULL) {
wchar_t *path;
int res = _PyCoreConfig_GetEnvDup(config, &path,
L"PYTHONPATH", "PYTHONPATH");
if (res < 0) {
return DECODE_LOCALE_ERR("PYTHONPATH", res);
err = CONFIG_GET_ENV_DUP(config, &config->module_search_path_env,
L"PYTHONPATH", "PYTHONPATH");
if (_Py_INIT_FAILED(err)) {
return err;
}
config->module_search_path_env = path;
}
if (config->use_hash_seed < 0) {
_PyInitError err = config_init_hash_seed(config);
err = config_init_hash_seed(config);
if (_Py_INIT_FAILED(err)) {
return err;
}
@ -1174,24 +1233,16 @@ config_init_pycache_prefix(_PyCoreConfig *config)
}
}
else {
// -X pycache_prefix= can cancel the env var
// PYTHONPYCACHEPREFIX env var ignored
// if "-X pycache_prefix=" option is used
config->pycache_prefix = NULL;
}
return _Py_INIT_OK();
}
else {
wchar_t *env;
int res = _PyCoreConfig_GetEnvDup(config, &env,
L"PYTHONPYCACHEPREFIX",
"PYTHONPYCACHEPREFIX");
if (res < 0) {
return DECODE_LOCALE_ERR("PYTHONPYCACHEPREFIX", res);
}
if (env) {
config->pycache_prefix = env;
}
}
return _Py_INIT_OK();
return CONFIG_GET_ENV_DUP(config, &config->pycache_prefix,
L"PYTHONPYCACHEPREFIX",
"PYTHONPYCACHEPREFIX");
}
@ -1270,11 +1321,9 @@ config_get_locale_encoding(char **locale_encoding)
"nl_langinfo(CODESET) failed");
}
#endif
*locale_encoding = _PyMem_RawStrdup(encoding);
if (*locale_encoding == NULL) {
return _Py_INIT_NO_MEMORY();
}
return _Py_INIT_OK();
assert(*locale_encoding == NULL);
return _PyCoreConfig_SetString(locale_encoding, encoding);
}
@ -1282,19 +1331,23 @@ static _PyInitError
config_init_stdio_encoding(_PyCoreConfig *config,
const _PyPreConfig *preconfig)
{
_PyInitError err;
/* If Py_SetStandardStreamEncoding() have been called, use these
parameters. */
if (config->stdio_encoding == NULL && _Py_StandardStreamEncoding != NULL) {
config->stdio_encoding = _PyMem_RawStrdup(_Py_StandardStreamEncoding);
if (config->stdio_encoding == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->stdio_encoding,
_Py_StandardStreamEncoding);
if (_Py_INIT_FAILED(err)) {
return err;
}
}
if (config->stdio_errors == NULL && _Py_StandardStreamErrors != NULL) {
config->stdio_errors = _PyMem_RawStrdup(_Py_StandardStreamErrors);
if (config->stdio_errors == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->stdio_errors,
_Py_StandardStreamErrors);
if (_Py_INIT_FAILED(err)) {
return err;
}
}
@ -1305,27 +1358,30 @@ config_init_stdio_encoding(_PyCoreConfig *config,
/* PYTHONIOENCODING environment variable */
const char *opt = _PyCoreConfig_GetEnv(config, "PYTHONIOENCODING");
if (opt) {
char *pythonioencoding = _PyMem_RawStrdup(opt);
if (pythonioencoding == NULL) {
return _Py_INIT_NO_MEMORY();
/* _PyCoreConfig_SetString() requires dest to be initialized to NULL */
char *pythonioencoding = NULL;
err = _PyCoreConfig_SetString(&pythonioencoding, opt);
if (_Py_INIT_FAILED(err)) {
return err;
}
char *err = strchr(pythonioencoding, ':');
if (err) {
*err = '\0';
err++;
if (!err[0]) {
err = NULL;
char *errors = strchr(pythonioencoding, ':');
if (errors) {
*errors = '\0';
errors++;
if (!errors[0]) {
errors = NULL;
}
}
/* Does PYTHONIOENCODING contain an encoding? */
if (pythonioencoding[0]) {
if (config->stdio_encoding == NULL) {
config->stdio_encoding = _PyMem_RawStrdup(pythonioencoding);
if (config->stdio_encoding == NULL) {
err = _PyCoreConfig_SetString(&config->stdio_encoding,
pythonioencoding);
if (_Py_INIT_FAILED(err)) {
PyMem_RawFree(pythonioencoding);
return _Py_INIT_NO_MEMORY();
return err;
}
}
@ -1333,16 +1389,16 @@ config_init_stdio_encoding(_PyCoreConfig *config,
use "strict" error handler by default.
PYTHONIOENCODING=latin1 behaves as
PYTHONIOENCODING=latin1:strict. */
if (!err) {
err = "strict";
if (!errors) {
errors = "strict";
}
}
if (config->stdio_errors == NULL && err != NULL) {
config->stdio_errors = _PyMem_RawStrdup(err);
if (config->stdio_errors == NULL) {
if (config->stdio_errors == NULL && errors != NULL) {
err = _PyCoreConfig_SetString(&config->stdio_errors, errors);
if (_Py_INIT_FAILED(err)) {
PyMem_RawFree(pythonioencoding);
return _Py_INIT_NO_MEMORY();
return err;
}
}
@ -1352,31 +1408,35 @@ config_init_stdio_encoding(_PyCoreConfig *config,
/* UTF-8 Mode uses UTF-8/surrogateescape */
if (preconfig->utf8_mode) {
if (config->stdio_encoding == NULL) {
config->stdio_encoding = _PyMem_RawStrdup("utf-8");
if (config->stdio_encoding == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->stdio_encoding,
"utf-8");
if (_Py_INIT_FAILED(err)) {
return err;
}
}
if (config->stdio_errors == NULL) {
config->stdio_errors = _PyMem_RawStrdup("surrogateescape");
if (config->stdio_errors == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->stdio_errors,
"surrogateescape");
if (_Py_INIT_FAILED(err)) {
return err;
}
}
}
/* Choose the default error handler based on the current locale. */
if (config->stdio_encoding == NULL) {
_PyInitError err = config_get_locale_encoding(&config->stdio_encoding);
err = config_get_locale_encoding(&config->stdio_encoding);
if (_Py_INIT_FAILED(err)) {
return err;
}
}
if (config->stdio_errors == NULL) {
const char *errors = config_get_stdio_errors(config);
config->stdio_errors = _PyMem_RawStrdup(errors);
if (config->stdio_errors == NULL) {
return _Py_INIT_NO_MEMORY();
assert(errors != NULL);
err = _PyCoreConfig_SetString(&config->stdio_errors, errors);
if (_Py_INIT_FAILED(err)) {
return err;
}
}
@ -1387,19 +1447,23 @@ config_init_stdio_encoding(_PyCoreConfig *config,
static _PyInitError
config_init_fs_encoding(_PyCoreConfig *config, const _PyPreConfig *preconfig)
{
_PyInitError err;
#ifdef MS_WINDOWS
if (preconfig->legacy_windows_fs_encoding) {
/* Legacy Windows filesystem encoding: mbcs/replace */
if (config->filesystem_encoding == NULL) {
config->filesystem_encoding = _PyMem_RawStrdup("mbcs");
if (config->filesystem_encoding == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->filesystem_encoding,
"mbcs");
if (_Py_INIT_FAILED(err)) {
return err;
}
}
if (config->filesystem_errors == NULL) {
config->filesystem_errors = _PyMem_RawStrdup("replace");
if (config->filesystem_errors == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->filesystem_errors,
"replace");
if (_Py_INIT_FAILED(err)) {
return err;
}
}
}
@ -1409,51 +1473,54 @@ config_init_fs_encoding(_PyCoreConfig *config, const _PyPreConfig *preconfig)
Note: UTF-8 Mode takes the same code path and the Legacy Windows FS
encoding has the priortiy over UTF-8 Mode. */
if (config->filesystem_encoding == NULL) {
config->filesystem_encoding = _PyMem_RawStrdup("utf-8");
if (config->filesystem_encoding == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->filesystem_encoding,
"utf-8");
if (_Py_INIT_FAILED(err)) {
return err;
}
}
if (config->filesystem_errors == NULL) {
config->filesystem_errors = _PyMem_RawStrdup("surrogatepass");
if (config->filesystem_errors == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->filesystem_errors,
"surrogatepass");
if (_Py_INIT_FAILED(err)) {
return err;
}
}
#else
if (config->filesystem_encoding == NULL) {
if (preconfig->utf8_mode) {
/* UTF-8 Mode use: utf-8/surrogateescape */
config->filesystem_encoding = _PyMem_RawStrdup("utf-8");
err = _PyCoreConfig_SetString(&config->filesystem_encoding,
"utf-8");
/* errors defaults to surrogateescape above */
}
else if (_Py_GetForceASCII()) {
config->filesystem_encoding = _PyMem_RawStrdup("ascii");
err = _PyCoreConfig_SetString(&config->filesystem_encoding,
"ascii");
}
else {
/* macOS and Android use UTF-8,
other platforms use the locale encoding. */
#if defined(__APPLE__) || defined(__ANDROID__)
config->filesystem_encoding = _PyMem_RawStrdup("utf-8");
err = _PyCoreConfig_SetString(&config->filesystem_encoding,
"utf-8");
#else
_PyInitError err = config_get_locale_encoding(&config->filesystem_encoding);
if (_Py_INIT_FAILED(err)) {
return err;
}
err = config_get_locale_encoding(&config->filesystem_encoding);
#endif
}
if (config->filesystem_encoding == NULL) {
return _Py_INIT_NO_MEMORY();
if (_Py_INIT_FAILED(err)) {
return err;
}
}
if (config->filesystem_errors == NULL) {
/* by default, use the "surrogateescape" error handler */
config->filesystem_errors = _PyMem_RawStrdup("surrogateescape");
if (config->filesystem_errors == NULL) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_SetString(&config->filesystem_errors,
"surrogateescape");
if (_Py_INIT_FAILED(err)) {
return err;
}
}
#endif
@ -1828,13 +1895,16 @@ config_parse_cmdline(_PyCoreConfig *config, _PyPreCmdline *precmdline,
static _PyInitError
config_init_env_warnoptions(const _PyCoreConfig *config, _PyWstrList *warnoptions)
{
wchar_t *env;
int res = _PyCoreConfig_GetEnvDup(config, &env,
L"PYTHONWARNINGS", "PYTHONWARNINGS");
if (res < 0) {
return DECODE_LOCALE_ERR("PYTHONWARNINGS", res);
_PyInitError err;
/* CONFIG_GET_ENV_DUP requires dest to be initialized to NULL */
wchar_t *env = NULL;
err = CONFIG_GET_ENV_DUP(config, &env,
L"PYTHONWARNINGS", "PYTHONWARNINGS");
if (_Py_INIT_FAILED(err)) {
return err;
}
/* env var is not set or is empty */
if (env == NULL) {
return _Py_INIT_OK();
}

23
Python/pylifecycle.c
View File

@ -472,6 +472,7 @@ _Py_Initialize_ReconfigureCore(_PyRuntimeState *runtime,
PyInterpreterState **interp_p,
const _PyCoreConfig *core_config)
{
_PyInitError err;
PyThreadState *tstate = _PyThreadState_GET();
if (!tstate) {
return _Py_INIT_ERR("failed to read thread state");
@ -485,13 +486,14 @@ _Py_Initialize_ReconfigureCore(_PyRuntimeState *runtime,
_PyCoreConfig_Write(core_config, runtime);
if (_PyCoreConfig_Copy(&interp->core_config, core_config) < 0) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_Copy(&interp->core_config, core_config);
if (_Py_INIT_FAILED(err)) {
return err;
}
core_config = &interp->core_config;
if (core_config->_install_importlib) {
_PyInitError err = _PyCoreConfig_SetPathConfig(core_config);
err = _PyCoreConfig_SetPathConfig(core_config);
if (_Py_INIT_FAILED(err)) {
return err;
}
@ -545,8 +547,9 @@ pycore_create_interpreter(_PyRuntimeState *runtime,
}
*interp_p = interp;
if (_PyCoreConfig_Copy(&interp->core_config, core_config) < 0) {
return _Py_INIT_NO_MEMORY();
_PyInitError err = _PyCoreConfig_Copy(&interp->core_config, core_config);
if (_Py_INIT_FAILED(err)) {
return err;
}
core_config = &interp->core_config;
@ -804,8 +807,9 @@ pyinit_coreconfig(_PyRuntimeState *runtime,
_PyInitError err;
if (src_config) {
if (_PyCoreConfig_Copy(config, src_config) < 0) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_Copy(config, src_config);
if (_Py_INIT_FAILED(err)) {
return err;
}
}
@ -1433,8 +1437,9 @@ new_interpreter(PyThreadState **tstate_p)
core_config = &main_interp->core_config;
}
if (_PyCoreConfig_Copy(&interp->core_config, core_config) < 0) {
return _Py_INIT_NO_MEMORY();
err = _PyCoreConfig_Copy(&interp->core_config, core_config);
if (_Py_INIT_FAILED(err)) {
return err;
}
core_config = &interp->core_config;

Write Preview
Loading…
Cancel
Save