/* Python interpreter top-level routines, including init/exit */

#include "Python.h"

#include "pycore_bytesobject.h" // _PyBytes_InitTypes()

#include "pycore_ceval.h" // _PyEval_FiniGIL()

#include "pycore_context.h" // _PyContext_Init()

#include "pycore_exceptions.h" // _PyExc_InitTypes()

#include "pycore_dict.h" // _PyDict_Fini()

#include "pycore_fileutils.h" // _Py_ResetForceASCII()

#include "pycore_floatobject.h" // _PyFloat_InitTypes()

#include "pycore_frame.h" // _PyFrame_Fini()

#include "pycore_genobject.h" // _PyAsyncGen_Fini()

#include "pycore_import.h" // _PyImport_BootstrapImp()

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_list.h" // _PyList_Fini()

#include "pycore_long.h" // _PyLong_InitTypes()

#include "pycore_object.h" // _PyDebug_PrintTotalRefs()

#include "pycore_pathconfig.h" // _PyConfig_WritePathConfig()

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

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

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

#include "pycore_sliceobject.h" // _PySlice_Fini()

#include "pycore_structseq.h" // _PyStructSequence_InitState()

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

#include "pycore_traceback.h" // _Py_DumpTracebackThreads()

#include "pycore_tuple.h" // _PyTuple_InitTypes()

#include "pycore_typeobject.h" // _PyTypes_InitTypes()

#include "pycore_unicodeobject.h" // _PyUnicode_InitTypes()

#include <locale.h> // setlocale()

#include <stdlib.h> // getenv()

#if defined(__APPLE__)

#include <mach-o/loader.h>

#endif

#ifdef HAVE_SIGNAL_H

# include <signal.h> // SIG_IGN

#endif

#ifdef HAVE_LANGINFO_H

# include <langinfo.h> // nl_langinfo(CODESET)

#endif

#ifdef HAVE_FCNTL_H

# include <fcntl.h> // F_GETFD

#endif

#ifdef MS_WINDOWS

# undef BYTE

# include "windows.h"

extern PyTypeObject PyWindowsConsoleIO_Type;

# define PyWindowsConsoleIO_Check(op) \

(PyObject_TypeCheck((op), &PyWindowsConsoleIO_Type))

#endif

#define PUTS(fd, str) _Py_write_noraise(fd, str, (int)strlen(str))

_Py_IDENTIFIER(flush);

_Py_IDENTIFIER(name);

_Py_IDENTIFIER(stdin);

_Py_IDENTIFIER(stdout);

_Py_IDENTIFIER(stderr);

_Py_IDENTIFIER(threading);

#ifdef __cplusplus

extern "C" {

#endif

/* Forward declarations */

static PyStatus add_main_module(PyInterpreterState *interp);

static PyStatus init_import_site(void);

static PyStatus init_set_builtins_open(void);

static PyStatus init_sys_streams(PyThreadState *tstate);

static void wait_for_thread_shutdown(PyThreadState *tstate);

static void call_ll_exitfuncs(_PyRuntimeState *runtime);

int _Py_UnhandledKeyboardInterrupt = 0;

/* The following places the `_PyRuntime` structure in a location that can be

* found without any external information. This is meant to ease access to the

* interpreter state for various runtime debugging tools, but is *not* an

* officially supported feature */

#if defined(MS_WINDOWS)

#pragma section("PyRuntime", read, write)

__declspec(allocate("PyRuntime"))

#elif defined(__APPLE__)

__attribute__((

section(SEG_DATA ",PyRuntime")

))

#endif

_PyRuntimeState _PyRuntime

#if defined(__linux__) && (defined(__GNUC__) || defined(__clang__))

__attribute__ ((section (".PyRuntime")))

#endif

= _PyRuntimeState_INIT;

static int runtime_initialized = 0;

PyStatus

_PyRuntime_Initialize(void)

{

/* XXX We only initialize once in the process, which aligns with

the static initialization of the former globals now found in

_PyRuntime. However, _PyRuntime *should* be initialized with

every Py_Initialize() call, but doing so breaks the runtime.

This is because the runtime state is not properly finalized

currently. */

if (runtime_initialized) {

return _PyStatus_OK();

}

runtime_initialized = 1;

return _PyRuntimeState_Init(&_PyRuntime);

}

void

_PyRuntime_Finalize(void)

{

_PyRuntimeState_Fini(&_PyRuntime);

runtime_initialized = 0;

}

int

_Py_IsFinalizing(void)

{

return _PyRuntimeState_GetFinalizing(&_PyRuntime) != NULL;

}

/* Hack to force loading of object files */

int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t) = \

PyOS_mystrnicmp; /* Python/pystrcmp.o */

/* APIs to access the initialization flags

*

* Can be called prior to Py_Initialize.

*/

int

_Py_IsCoreInitialized(void)

{

return _PyRuntime.core_initialized;

}

int

Py_IsInitialized(void)

{

return _PyRuntime.initialized;

}

/* Global initializations. Can be undone by Py_FinalizeEx(). Don't

call this twice without an intervening Py_FinalizeEx() call. When

initializations fail, a fatal error is issued and the function does

not return. On return, the first thread and interpreter state have

been created.

Locking: you must hold the interpreter lock while calling this.

(If the lock has not yet been initialized, that's equivalent to

having the lock, but you cannot use multiple threads.)

*/

static int

init_importlib(PyThreadState *tstate, PyObject *sysmod)

{

assert(!_PyErr_Occurred(tstate));

PyInterpreterState *interp = tstate->interp;

int verbose = _PyInterpreterState_GetConfig(interp)->verbose;

// Import _importlib through its frozen version, _frozen_importlib.

if (verbose) {

PySys_FormatStderr("import _frozen_importlib # frozen\n");

}

if (PyImport_ImportFrozenModule("_frozen_importlib") <= 0) {

return -1;

}

PyObject *importlib = PyImport_AddModule("_frozen_importlib"); // borrowed

if (importlib == NULL) {

return -1;

}

interp->importlib = Py_NewRef(importlib);

// Import the _imp module

if (verbose) {

PySys_FormatStderr("import _imp # builtin\n");

}

PyObject *imp_mod = _PyImport_BootstrapImp(tstate);

if (imp_mod == NULL) {

return -1;

}

if (_PyImport_SetModuleString("_imp", imp_mod) < 0) {

Py_DECREF(imp_mod);

return -1;

}

// Install importlib as the implementation of import

PyObject *value = PyObject_CallMethod(importlib, "_install",

"OO", sysmod, imp_mod);

Py_DECREF(imp_mod);

if (value == NULL) {

return -1;

}

Py_DECREF(value);

assert(!_PyErr_Occurred(tstate));

return 0;

}

static PyStatus

init_importlib_external(PyThreadState *tstate)

{

PyObject *value;

value = PyObject_CallMethod(tstate->interp->importlib,

"_install_external_importers", "");

if (value == NULL) {

_PyErr_Print(tstate);

return _PyStatus_ERR("external importer setup failed");

}

Py_DECREF(value);

return _PyImportZip_Init(tstate);

}

/* Helper functions to better handle the legacy C locale

*

* The legacy C locale assumes ASCII as the default text encoding, which

* causes problems not only for the CPython runtime, but also other

* components like GNU readline.

*

* Accordingly, when the CLI detects it, it attempts to coerce it to a

* more capable UTF-8 based alternative as follows:

*

* if (_Py_LegacyLocaleDetected()) {

* _Py_CoerceLegacyLocale();

* }

*

* See the documentation of the PYTHONCOERCECLOCALE setting for more details.

*

* Locale coercion also impacts the default error handler for the standard

* streams: while the usual default is "strict", the default for the legacy

* C locale and for any of the coercion target locales is "surrogateescape".

*/

int

_Py_LegacyLocaleDetected(int warn)

{

#ifndef MS_WINDOWS

if (!warn) {

const char *locale_override = getenv("LC_ALL");

if (locale_override != NULL && *locale_override != '\0') {

/* Don't coerce C locale if the LC_ALL environment variable

is set */

return 0;

}

}

/* On non-Windows systems, the C locale is considered a legacy locale */

/* XXX (ncoghlan): some platforms (notably Mac OS X) don't appear to treat

* the POSIX locale as a simple alias for the C locale, so

* we may also want to check for that explicitly.

*/

const char *ctype_loc = setlocale(LC_CTYPE, NULL);

return ctype_loc != NULL && strcmp(ctype_loc, "C") == 0;

#else

/* Windows uses code pages instead of locales, so no locale is legacy */

return 0;

#endif

}

#ifndef MS_WINDOWS

static const char *_C_LOCALE_WARNING =

"Python runtime initialized with LC_CTYPE=C (a locale with default ASCII "

"encoding), which may cause Unicode compatibility problems. Using C.UTF-8, "

"C.utf8, or UTF-8 (if available) as alternative Unicode-compatible "

"locales is recommended.\n";

static void

emit_stderr_warning_for_legacy_locale(_PyRuntimeState *runtime)

{

const PyPreConfig *preconfig = &runtime->preconfig;

if (preconfig->coerce_c_locale_warn && _Py_LegacyLocaleDetected(1)) {

PySys_FormatStderr("%s", _C_LOCALE_WARNING);

}

}

#endif /* !defined(MS_WINDOWS) */

typedef struct _CandidateLocale {

const char *locale_name; /* The locale to try as a coercion target */

} _LocaleCoercionTarget;

static _LocaleCoercionTarget _TARGET_LOCALES[] = {

{"C.UTF-8"},

{"C.utf8"},

{"UTF-8"},

{NULL}

};

int

_Py_IsLocaleCoercionTarget(const char *ctype_loc)

{

const _LocaleCoercionTarget *target = NULL;

for (target = _TARGET_LOCALES; target->locale_name; target++) {

if (strcmp(ctype_loc, target->locale_name) == 0) {

return 1;

}

}

return 0;

}

#ifdef PY_COERCE_C_LOCALE

static const char C_LOCALE_COERCION_WARNING[] =

"Python detected LC_CTYPE=C: LC_CTYPE coerced to %.20s (set another locale "

"or PYTHONCOERCECLOCALE=0 to disable this locale coercion behavior).\n";

static int

_coerce_default_locale_settings(int warn, const _LocaleCoercionTarget *target)

{

const char *newloc = target->locale_name;

/* Reset locale back to currently configured defaults */

_Py_SetLocaleFromEnv(LC_ALL);

/* Set the relevant locale environment variable */

if (setenv("LC_CTYPE", newloc, 1)) {

fprintf(stderr,

"Error setting LC_CTYPE, skipping C locale coercion\n");

return 0;

}

if (warn) {

fprintf(stderr, C_LOCALE_COERCION_WARNING, newloc);

}

/* Reconfigure with the overridden environment variables */

_Py_SetLocaleFromEnv(LC_ALL);

return 1;

}

#endif

int

_Py_CoerceLegacyLocale(int warn)

{

int coerced = 0;

#ifdef PY_COERCE_C_LOCALE

char *oldloc = NULL;

oldloc = _PyMem_RawStrdup(setlocale(LC_CTYPE, NULL));

if (oldloc == NULL) {

return coerced;

}

const char *locale_override = getenv("LC_ALL");

if (locale_override == NULL || *locale_override == '\0') {

/* LC_ALL is also not set (or is set to an empty string) */

const _LocaleCoercionTarget *target = NULL;

for (target = _TARGET_LOCALES; target->locale_name; target++) {

const char *new_locale = setlocale(LC_CTYPE,

target->locale_name);

if (new_locale != NULL) {

#if !defined(_Py_FORCE_UTF8_LOCALE) && defined(HAVE_LANGINFO_H) && defined(CODESET)

/* Also ensure that nl_langinfo works in this locale */

char *codeset = nl_langinfo(CODESET);

if (!codeset || *codeset == '\0') {

/* CODESET is not set or empty, so skip coercion */

new_locale = NULL;

_Py_SetLocaleFromEnv(LC_CTYPE);

continue;

}

#endif

/* Successfully configured locale, so make it the default */

coerced = _coerce_default_locale_settings(warn, target);

goto done;

}

}

}

/* No C locale warning here, as Py_Initialize will emit one later */

setlocale(LC_CTYPE, oldloc);

done:

PyMem_RawFree(oldloc);

#endif

return coerced;

}

/* _Py_SetLocaleFromEnv() is a wrapper around setlocale(category, "") to

* isolate the idiosyncrasies of different libc implementations. It reads the

* appropriate environment variable and uses its value to select the locale for

* 'category'. */

char *

_Py_SetLocaleFromEnv(int category)

{

char *res;

#ifdef __ANDROID__

const char *locale;

const char **pvar;

#ifdef PY_COERCE_C_LOCALE

const char *coerce_c_locale;

#endif

const char *utf8_locale = "C.UTF-8";

const char *env_var_set[] = {

"LC_ALL",

"LC_CTYPE",

"LANG",

NULL,

};

/* Android setlocale(category, "") doesn't check the environment variables

* and incorrectly sets the "C" locale at API 24 and older APIs. We only

* check the environment variables listed in env_var_set. */

for (pvar=env_var_set; *pvar; pvar++) {

locale = getenv(*pvar);

if (locale != NULL && *locale != '\0') {

if (strcmp(locale, utf8_locale) == 0 ||

strcmp(locale, "en_US.UTF-8") == 0) {

return setlocale(category, utf8_locale);

}

return setlocale(category, "C");

}

}

/* Android uses UTF-8, so explicitly set the locale to C.UTF-8 if none of

* LC_ALL, LC_CTYPE, or LANG is set to a non-empty string.

* Quote from POSIX section "8.2 Internationalization Variables":

* "4. If the LANG environment variable is not set or is set to the empty

* string, the implementation-defined default locale shall be used." */

#ifdef PY_COERCE_C_LOCALE

coerce_c_locale = getenv("PYTHONCOERCECLOCALE");

if (coerce_c_locale == NULL || strcmp(coerce_c_locale, "0") != 0) {

/* Some other ported code may check the environment variables (e.g. in

* extension modules), so we make sure that they match the locale

* configuration */

if (setenv("LC_CTYPE", utf8_locale, 1)) {

fprintf(stderr, "Warning: failed setting the LC_CTYPE "

"environment variable to %s\n", utf8_locale);

}

}

#endif

res = setlocale(category, utf8_locale);

#else /* !defined(__ANDROID__) */

res = setlocale(category, "");

#endif

_Py_ResetForceASCII();

return res;

}

static int

interpreter_update_config(PyThreadState *tstate, int only_update_path_config)

{

const PyConfig *config = &tstate->interp->config;

if (!only_update_path_config) {

PyStatus status = _PyConfig_Write(config, tstate->interp->runtime);

if (_PyStatus_EXCEPTION(status)) {

_PyErr_SetFromPyStatus(status);

return -1;

}

}

if (_Py_IsMainInterpreter(tstate->interp)) {

PyStatus status = _PyPathConfig_UpdateGlobal(config);

if (_PyStatus_EXCEPTION(status)) {

_PyErr_SetFromPyStatus(status);

return -1;

}

}

// Update the sys module for the new configuration

if (_PySys_UpdateConfig(tstate) < 0) {

return -1;

}

return 0;

}

int

_PyInterpreterState_SetConfig(const PyConfig *src_config)

{

PyThreadState *tstate = _PyThreadState_GET();

int res = -1;

PyConfig config;

PyConfig_InitPythonConfig(&config);

PyStatus status = _PyConfig_Copy(&config, src_config);

if (_PyStatus_EXCEPTION(status)) {

_PyErr_SetFromPyStatus(status);

goto done;

}

status = _PyConfig_Read(&config, 1);

if (_PyStatus_EXCEPTION(status)) {

_PyErr_SetFromPyStatus(status);

goto done;

}

status = _PyConfig_Copy(&tstate->interp->config, &config);

if (_PyStatus_EXCEPTION(status)) {

_PyErr_SetFromPyStatus(status);

goto done;

}

res = interpreter_update_config(tstate, 0);

done:

PyConfig_Clear(&config);

return res;

}

/* Global initializations. Can be undone by Py_Finalize(). Don't

call this twice without an intervening Py_Finalize() call.

Every call to Py_InitializeFromConfig, Py_Initialize or Py_InitializeEx

must have a corresponding call to Py_Finalize.

Locking: you must hold the interpreter lock while calling these APIs.

(If the lock has not yet been initialized, that's equivalent to

having the lock, but you cannot use multiple threads.)

*/

static PyStatus

pyinit_core_reconfigure(_PyRuntimeState *runtime,

PyThreadState **tstate_p,

const PyConfig *config)

{

PyStatus status;

PyThreadState *tstate = _PyThreadState_GET();

if (!tstate) {

return _PyStatus_ERR("failed to read thread state");

}

*tstate_p = tstate;

PyInterpreterState *interp = tstate->interp;

if (interp == NULL) {

return _PyStatus_ERR("can't make main interpreter");

}

status = _PyConfig_Write(config, runtime);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyConfig_Copy(&interp->config, config);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

config = _PyInterpreterState_GetConfig(interp);

if (config->_install_importlib) {

status = _PyPathConfig_UpdateGlobal(config);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

}

return _PyStatus_OK();

}

static PyStatus

pycore_init_runtime(_PyRuntimeState *runtime,

const PyConfig *config)

{

if (runtime->initialized) {

return _PyStatus_ERR("main interpreter already initialized");

}

PyStatus status = _PyConfig_Write(config, runtime);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

/* Py_Finalize leaves _Py_Finalizing set in order to help daemon

* threads behave a little more gracefully at interpreter shutdown.

* We clobber it here so the new interpreter can start with a clean

* slate.

*

* However, this may still lead to misbehaviour if there are daemon

* threads still hanging around from a previous Py_Initialize/Finalize

* pair :(

*/

_PyRuntimeState_SetFinalizing(runtime, NULL);

status = _Py_HashRandomization_Init(config);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyInterpreterState_Enable(runtime);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

return _PyStatus_OK();

}

static PyStatus

init_interp_create_gil(PyThreadState *tstate)

{

PyStatus status;

/* finalize_interp_delete() comment explains why _PyEval_FiniGIL() is

only called here. */

_PyEval_FiniGIL(tstate->interp);

/* Auto-thread-state API */

status = _PyGILState_SetTstate(tstate);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

/* Create the GIL and take it */

status = _PyEval_InitGIL(tstate);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

return _PyStatus_OK();

}

static PyStatus

pycore_create_interpreter(_PyRuntimeState *runtime,

const PyConfig *config,

PyThreadState **tstate_p)

{

/* Auto-thread-state API */

PyStatus status = _PyGILState_Init(runtime);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

PyInterpreterState *interp = PyInterpreterState_New();

if (interp == NULL) {

return _PyStatus_ERR("can't make main interpreter");

}

assert(_Py_IsMainInterpreter(interp));

status = _PyConfig_Copy(&interp->config, config);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

PyThreadState *tstate = PyThreadState_New(interp);

if (tstate == NULL) {

return _PyStatus_ERR("can't make first thread");

}

(void) PyThreadState_Swap(tstate);

status = init_interp_create_gil(tstate);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

*tstate_p = tstate;

return _PyStatus_OK();

}

static PyStatus

pycore_init_global_objects(PyInterpreterState *interp)

{

PyStatus status;

_PyLong_InitGlobalObjects(interp);

_PyFloat_InitState(interp);

status = _PyBytes_InitGlobalObjects(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyUnicode_InitGlobalObjects(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

_PyUnicode_InitState(interp);

status = _PyTuple_InitGlobalObjects(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

return _PyStatus_OK();

}

static PyStatus

pycore_init_types(PyInterpreterState *interp)

{

PyStatus status;

status = _PyStructSequence_InitState(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyTypes_InitState(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyTypes_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyBytes_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyLong_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyUnicode_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyFloat_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyTuple_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyExc_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyExc_InitGlobalObjects(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyExc_InitState(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyErr_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyContext_InitTypes(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

return _PyStatus_OK();

}

static PyStatus

pycore_init_builtins(PyThreadState *tstate)

{

PyInterpreterState *interp = tstate->interp;

PyObject *bimod = _PyBuiltin_Init(interp);

if (bimod == NULL) {

goto error;

}

if (_PyImport_FixupBuiltin(bimod, "builtins", interp->modules) < 0) {

goto error;

}

PyObject *builtins_dict = PyModule_GetDict(bimod);

if (builtins_dict == NULL) {

goto error;

}

Py_INCREF(builtins_dict);

interp->builtins = builtins_dict;

PyStatus status = _PyBuiltins_AddExceptions(bimod);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

interp->builtins_copy = PyDict_Copy(interp->builtins);

if (interp->builtins_copy == NULL) {

goto error;

}

Py_DECREF(bimod);

// Get the __import__ function

PyObject *import_func = _PyDict_GetItemStringWithError(interp->builtins,

"__import__");

if (import_func == NULL) {

goto error;

}

interp->import_func = Py_NewRef(import_func);

assert(!_PyErr_Occurred(tstate));

return _PyStatus_OK();

error:

Py_XDECREF(bimod);

return _PyStatus_ERR("can't initialize builtins module");

}

static PyStatus

pycore_interp_init(PyThreadState *tstate)

{

PyInterpreterState *interp = tstate->interp;

PyStatus status;

PyObject *sysmod = NULL;

// Create singletons before the first PyType_Ready() call, since

// PyType_Ready() uses singletons like the Unicode empty string (tp_doc)

// and the empty tuple singletons (tp_bases).

status = pycore_init_global_objects(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

// The GC must be initialized before the first GC collection.

status = _PyGC_Init(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = pycore_init_types(interp);

if (_PyStatus_EXCEPTION(status)) {

goto done;

}

if (_PyWarnings_InitState(interp) < 0) {

return _PyStatus_ERR("can't initialize warnings");

}

status = _PyAtExit_Init(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PySys_Create(tstate, &sysmod);

if (_PyStatus_EXCEPTION(status)) {

goto done;

}

status = pycore_init_builtins(tstate);

if (_PyStatus_EXCEPTION(status)) {

goto done;

}

const PyConfig *config = _PyInterpreterState_GetConfig(interp);

if (config->_install_importlib) {

/* This call sets up builtin and frozen import support */

if (init_importlib(tstate, sysmod) < 0) {

return _PyStatus_ERR("failed to initialize importlib");

}

}

done:

/* sys.modules['sys'] contains a strong reference to the module */

Py_XDECREF(sysmod);

return status;

}

static PyStatus

pyinit_config(_PyRuntimeState *runtime,

PyThreadState **tstate_p,

const PyConfig *config)

{

PyStatus status = pycore_init_runtime(runtime, config);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

PyThreadState *tstate;

status = pycore_create_interpreter(runtime, config, &tstate);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

*tstate_p = tstate;

status = pycore_interp_init(tstate);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

/* Only when we get here is the runtime core fully initialized */

runtime->core_initialized = 1;

return _PyStatus_OK();

}

PyStatus

_Py_PreInitializeFromPyArgv(const PyPreConfig *src_config, const _PyArgv *args)

{

PyStatus status;

if (src_config == NULL) {

return _PyStatus_ERR("preinitialization config is NULL");

}

status = _PyRuntime_Initialize();

if (_PyStatus_EXCEPTION(status)) {

return status;

}

_PyRuntimeState *runtime = &_PyRuntime;

if (runtime->preinitialized) {

/* If it's already configured: ignored the new configuration */

return _PyStatus_OK();

}

/* Note: preinitialized remains 1 on error, it is only set to 0

at exit on success. */

runtime->preinitializing = 1;

PyPreConfig config;

status = _PyPreConfig_InitFromPreConfig(&config, src_config);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyPreConfig_Read(&config, args);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

status = _PyPreConfig_Write(&config);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

runtime->preinitializing = 0;

runtime->preinitialized = 1;

return _PyStatus_OK();

}

PyStatus

Py_PreInitializeFromBytesArgs(const PyPreConfig *src_config, Py_ssize_t argc, char **argv)

{

_PyArgv args = {.use_bytes_argv = 1, .argc = argc, .bytes_argv = argv};

return _Py_PreInitializeFromPyArgv(src_config, &args);

}

PyStatus

Py_PreInitializeFromArgs(const PyPreConfig *src_config, Py_ssize_t argc, wchar_t **argv)

{

_PyArgv args = {.use_bytes_argv = 0, .argc = argc, .wchar_argv = argv};

return _Py_PreInitializeFromPyArgv(src_config, &args);

}

PyStatus

Py_PreInitialize(const PyPreConfig *src_config)

{

return _Py_PreInitializeFromPyArgv(src_config, NULL);

}

PyStatus

_Py_PreInitializeFromConfig(const PyConfig *config,

const _PyArgv *args)

{

assert(config != NULL);

PyStatus status = _PyRuntime_Initialize();

if (_PyStatus_EXCEPTION(status)) {

return status;

}

_PyRuntimeState *runtime = &_PyRuntime;

if (runtime->preinitialized) {

/* Already initialized: do nothing */

return _PyStatus_OK();

}