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

#include "Python.h"

#include "Python-ast.h"

#undef Yield /* undefine macro conflicting with <winbase.h> */

#include "pycore_coreconfig.h"

#include "pycore_context.h"

#include "pycore_fileutils.h"

#include "pycore_hamt.h"

#include "pycore_pathconfig.h"

#include "pycore_pylifecycle.h"

#include "pycore_pymem.h"

#include "pycore_pystate.h"

#include "grammar.h"

#include "node.h"

#include "token.h"

#include "parsetok.h"

#include "errcode.h"

#include "code.h"

#include "symtable.h"

#include "ast.h"

#include "marshal.h"

#include "osdefs.h"

#include <locale.h>

#ifdef HAVE_SIGNAL_H

#include <signal.h>

#endif

#ifdef MS_WINDOWS

#include "malloc.h" /* for alloca */

#endif

#ifdef HAVE_LANGINFO_H

#include <langinfo.h>

#endif

#ifdef MS_WINDOWS

#undef BYTE

#include "windows.h"

extern PyTypeObject PyWindowsConsoleIO_Type;

#define PyWindowsConsoleIO_Check(op) (PyObject_TypeCheck((op), &PyWindowsConsoleIO_Type))

#endif

_Py_IDENTIFIER(flush);

_Py_IDENTIFIER(name);

_Py_IDENTIFIER(stdin);

_Py_IDENTIFIER(stdout);

_Py_IDENTIFIER(stderr);

_Py_IDENTIFIER(threading);

#ifdef __cplusplus

extern "C" {

#endif

extern grammar _PyParser_Grammar; /* From graminit.c */

/* Forward */

static _PyInitError add_main_module(PyInterpreterState *interp);

static _PyInitError initfsencoding(PyInterpreterState *interp);

static _PyInitError initsite(void);

static _PyInitError init_sys_streams(PyInterpreterState *interp);

static _PyInitError initsigs(void);

static void call_py_exitfuncs(PyInterpreterState *);

static void wait_for_thread_shutdown(void);

static void call_ll_exitfuncs(void);

int _Py_UnhandledKeyboardInterrupt = 0;

_PyRuntimeState _PyRuntime = _PyRuntimeState_INIT;

_PyInitError

_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. */

static int initialized = 0;

if (initialized) {

return _Py_INIT_OK();

}

initialized = 1;

return _PyRuntimeState_Init(&_PyRuntime);

}

void

_PyRuntime_Finalize(void)

{

_PyRuntimeState_Fini(&_PyRuntime);

}

int

_Py_IsFinalizing(void)

{

return _PyRuntime.finalizing != NULL;

}

/* Hack to force loading of object files */

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

PyOS_mystrnicmp; /* Python/pystrcmp.o */

/* PyModule_GetWarningsModule is no longer necessary as of 2.6

since _warnings is builtin. This API should not be used. */

PyObject *

PyModule_GetWarningsModule(void)

{

return PyImport_ImportModule("warnings");

}

/* 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 char*

get_codec_name(const char *encoding)

{

const char *name_utf8;

char *name_str;

PyObject *codec, *name = NULL;

codec = _PyCodec_Lookup(encoding);

if (!codec)

goto error;

name = _PyObject_GetAttrId(codec, &PyId_name);

Py_CLEAR(codec);

if (!name)

goto error;

name_utf8 = PyUnicode_AsUTF8(name);

if (name_utf8 == NULL)

goto error;

name_str = _PyMem_RawStrdup(name_utf8);

Py_DECREF(name);

if (name_str == NULL) {

PyErr_NoMemory();

return NULL;

}

return name_str;

error:

Py_XDECREF(codec);

Py_XDECREF(name);

return NULL;

}

static _PyInitError

initimport(PyInterpreterState *interp, PyObject *sysmod)

{

PyObject *importlib;

PyObject *impmod;

PyObject *value;

/* Import _importlib through its frozen version, _frozen_importlib. */

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

return _Py_INIT_ERR("can't import _frozen_importlib");

}

else if (Py_VerboseFlag) {

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

}

importlib = PyImport_AddModule("_frozen_importlib");

if (importlib == NULL) {

return _Py_INIT_ERR("couldn't get _frozen_importlib from sys.modules");

}

interp->importlib = importlib;

Py_INCREF(interp->importlib);

interp->import_func = PyDict_GetItemString(interp->builtins, "__import__");

if (interp->import_func == NULL)

return _Py_INIT_ERR("__import__ not found");

Py_INCREF(interp->import_func);

/* Import the _imp module */

impmod = PyInit__imp();

if (impmod == NULL) {

return _Py_INIT_ERR("can't import _imp");

}

else if (Py_VerboseFlag) {

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

}

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

return _Py_INIT_ERR("can't save _imp to sys.modules");

}

/* Install importlib as the implementation of import */

value = PyObject_CallMethod(importlib, "_install", "OO", sysmod, impmod);

if (value == NULL) {

PyErr_Print();

return _Py_INIT_ERR("importlib install failed");

}

Py_DECREF(value);

Py_DECREF(impmod);

return _Py_INIT_OK();

}

static _PyInitError

initexternalimport(PyInterpreterState *interp)

{

PyObject *value;

value = PyObject_CallMethod(interp->importlib,

"_install_external_importers", "");

if (value == NULL) {

PyErr_Print();

return _Py_INIT_ERR("external importer setup failed");

}

Py_DECREF(value);

return _PyImportZip_Init();

}

/* 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(void)

{

#ifndef MS_WINDOWS

/* 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

}

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(const _PyCoreConfig *core_config)

{

if (core_config->preconfig.coerce_c_locale_warn && _Py_LegacyLocaleDetected()) {

PySys_FormatStderr("%s", _C_LOCALE_WARNING);

}

}

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 void

_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;

}

if (warn) {

fprintf(stderr, C_LOCALE_COERCION_WARNING, newloc);

}

/* Reconfigure with the overridden environment variables */

_Py_SetLocaleFromEnv(LC_ALL);

}

#endif

void

_Py_CoerceLegacyLocale(int warn)

{

#ifdef PY_COERCE_C_LOCALE

char *oldloc = NULL;

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

if (oldloc == NULL) {

return;

}

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(__APPLE__) && !defined(__ANDROID__) && \

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 */

_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

}

/* _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;

}

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

call this twice without an intervening Py_Finalize() call.

Every call to _Py_InitializeCore, 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 _PyInitError

_Py_Initialize_ReconfigureCore(PyInterpreterState **interp_p,

const _PyCoreConfig *core_config)

{

PyThreadState *tstate = _PyThreadState_GET();

if (!tstate) {

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

}

PyInterpreterState *interp = tstate->interp;

if (interp == NULL) {

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

}

*interp_p = interp;

_PyCoreConfig_SetGlobalConfig(core_config);

if (_PyCoreConfig_Copy(&interp->core_config, core_config) < 0) {

return _Py_INIT_ERR("failed to copy core config");

}

core_config = &interp->core_config;

if (core_config->_install_importlib) {

_PyInitError err = _PyCoreConfig_SetPathConfig(core_config);

if (_Py_INIT_FAILED(err)) {

return err;

}

}

return _Py_INIT_OK();

}

static _PyInitError

pycore_init_runtime(const _PyCoreConfig *core_config)

{

if (_PyRuntime.initialized) {

return _Py_INIT_ERR("main interpreter already initialized");

}

_PyCoreConfig_SetGlobalConfig(core_config);

_PyInitError err = _PyRuntime_Initialize();

if (_Py_INIT_FAILED(err)) {

return err;

}

/* 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 :(

*/

_PyRuntime.finalizing = NULL;

err = _Py_HashRandomization_Init(core_config);

if (_Py_INIT_FAILED(err)) {

return err;

}

err = _PyInterpreterState_Enable(&_PyRuntime);

if (_Py_INIT_FAILED(err)) {

return err;

}

return _Py_INIT_OK();

}

static _PyInitError

pycore_create_interpreter(const _PyCoreConfig *core_config,

PyInterpreterState **interp_p)

{

PyInterpreterState *interp = PyInterpreterState_New();

if (interp == NULL) {

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

}

*interp_p = interp;

if (_PyCoreConfig_Copy(&interp->core_config, core_config) < 0) {

return _Py_INIT_ERR("failed to copy core config");

}

core_config = &interp->core_config;

PyThreadState *tstate = PyThreadState_New(interp);

if (tstate == NULL)

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

(void) PyThreadState_Swap(tstate);

/* We can't call _PyEval_FiniThreads() in Py_FinalizeEx because

destroying the GIL might fail when it is being referenced from

another running thread (see issue #9901).

Instead we destroy the previously created GIL here, which ensures

that we can call Py_Initialize / Py_FinalizeEx multiple times. */

_PyEval_FiniThreads();

/* Auto-thread-state API */

_PyGILState_Init(interp, tstate);

/* Create the GIL */

PyEval_InitThreads();

return _Py_INIT_OK();

}

static _PyInitError

pycore_init_types(void)

{

_PyInitError err = _PyTypes_Init();

if (_Py_INIT_FAILED(err)) {

return err;

}

err = _PyUnicode_Init();

if (_Py_INIT_FAILED(err)) {

return err;

}

if (_PyStructSequence_Init() < 0) {

return _Py_INIT_ERR("can't initialize structseq");

}

if (!_PyLong_Init()) {

return _Py_INIT_ERR("can't init longs");

}

err = _PyExc_Init();

if (_Py_INIT_FAILED(err)) {

return err;

}

if (!_PyFloat_Init()) {

return _Py_INIT_ERR("can't init float");

}

if (!_PyContext_Init()) {

return _Py_INIT_ERR("can't init context");

}

return _Py_INIT_OK();

}

static _PyInitError

pycore_init_builtins(PyInterpreterState *interp)

{

PyObject *bimod = _PyBuiltin_Init();

if (bimod == NULL) {

return _Py_INIT_ERR("can't initialize builtins modules");

}

_PyImport_FixupBuiltin(bimod, "builtins", interp->modules);

interp->builtins = PyModule_GetDict(bimod);

if (interp->builtins == NULL) {

return _Py_INIT_ERR("can't initialize builtins dict");

}

Py_INCREF(interp->builtins);

_PyInitError err = _PyBuiltins_AddExceptions(bimod);

if (_Py_INIT_FAILED(err)) {

return err;

}

return _Py_INIT_OK();

}

static _PyInitError

pycore_init_import_warnings(PyInterpreterState *interp, PyObject *sysmod)

{

_PyInitError err = _PyImport_Init(interp);

if (_Py_INIT_FAILED(err)) {

return err;

}

err = _PyImportHooks_Init();

if (_Py_INIT_FAILED(err)) {

return err;

}

/* Initialize _warnings. */

if (_PyWarnings_Init() == NULL) {

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

}

if (interp->core_config._install_importlib) {

err = _PyCoreConfig_SetPathConfig(&interp->core_config);

if (_Py_INIT_FAILED(err)) {

return err;

}

}

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

if (interp->core_config._install_importlib) {

err = initimport(interp, sysmod);

if (_Py_INIT_FAILED(err)) {

return err;

}

}

return _Py_INIT_OK();

}

static _PyInitError

_Py_InitializeCore_impl(PyInterpreterState **interp_p,

const _PyCoreConfig *core_config)

{

PyInterpreterState *interp;

_PyInitError err = pycore_init_runtime(core_config);

if (_Py_INIT_FAILED(err)) {

return err;

}

err = pycore_create_interpreter(core_config, &interp);

if (_Py_INIT_FAILED(err)) {

return err;

}

core_config = &interp->core_config;

*interp_p = interp;

err = pycore_init_types();

if (_Py_INIT_FAILED(err)) {

return err;

}

PyObject *sysmod;

err = _PySys_Create(interp, &sysmod);

if (_Py_INIT_FAILED(err)) {

return err;

}

err = pycore_init_builtins(interp);

if (_Py_INIT_FAILED(err)) {

return err;

}

err = pycore_init_import_warnings(interp, sysmod);

if (_Py_INIT_FAILED(err)) {

return err;

}

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

_PyRuntime.core_initialized = 1;

return _Py_INIT_OK();

}

static _PyInitError

pyinit_preconfig(_PyPreConfig *preconfig, const _PyPreConfig *src_preconfig)

{

if (_PyPreConfig_Copy(preconfig, src_preconfig) < 0) {

return _Py_INIT_ERR("failed to copy pre config");

}

_PyInitError err = _PyPreConfig_Read(preconfig);

if (_Py_INIT_FAILED(err)) {

return err;

}

return _PyPreConfig_Write(preconfig);

}

static _PyInitError

pyinit_coreconfig(_PyCoreConfig *config, const _PyCoreConfig *src_config,

PyInterpreterState **interp_p)

{

if (_PyCoreConfig_Copy(config, src_config) < 0) {

return _Py_INIT_ERR("failed to copy core config");

}

_PyInitError err = _PyCoreConfig_Read(config, NULL);

if (_Py_INIT_FAILED(err)) {

return err;

}

if (!_PyRuntime.core_initialized) {

return _Py_InitializeCore_impl(interp_p, config);

}

else {

return _Py_Initialize_ReconfigureCore(interp_p, config);

}

}

/* Begin interpreter initialization

*

* On return, the first thread and interpreter state have been created,

* but the compiler, signal handling, multithreading and

* multiple interpreter support, and codec infrastructure are not yet

* available.

*

* The import system will support builtin and frozen modules only.

* The only supported io is writing to sys.stderr

*

* If any operation invoked by this function fails, a fatal error is

* issued and the function does not return.

*

* Any code invoked from this function should *not* assume it has access

* to the Python C API (unless the API is explicitly listed as being

* safe to call without calling Py_Initialize first)

*/

_PyInitError

_Py_InitializeCore(PyInterpreterState **interp_p,

const _PyCoreConfig *src_config)

{

_PyInitError err;

assert(src_config != NULL);

_PyCoreConfig local_config = _PyCoreConfig_INIT;

err = pyinit_preconfig(&local_config.preconfig, &src_config->preconfig);

if (_Py_INIT_FAILED(err)) {

goto done;

}

err = pyinit_coreconfig(&local_config, src_config, interp_p);

done:

_PyCoreConfig_Clear(&local_config);

return err;

}

/* Py_Initialize() has already been called: update the main interpreter

configuration. Example of bpo-34008: Py_Main() called after

Py_Initialize(). */

static _PyInitError

_Py_ReconfigureMainInterpreter(PyInterpreterState *interp,

const _PyMainInterpreterConfig *config)

{

if (config->argv != NULL) {

int res = PyDict_SetItemString(interp->sysdict, "argv", config->argv);

if (res < 0) {

return _Py_INIT_ERR("fail to set sys.argv");

}

}

return _Py_INIT_OK();

}

/* Update interpreter state based on supplied configuration settings

*

* After calling this function, most of the restrictions on the interpreter

* are lifted. The only remaining incomplete settings are those related

* to the main module (sys.argv[0], __main__ metadata)

*

* Calling this when the interpreter is not initializing, is already

* initialized or without a valid current thread state is a fatal error.

* Other errors should be reported as normal Python exceptions with a

* non-zero return code.

*/

_PyInitError

_Py_InitializeMainInterpreter(PyInterpreterState *interp,

const _PyMainInterpreterConfig *config)

{

if (!_PyRuntime.core_initialized) {

return _Py_INIT_ERR("runtime core not initialized");

}

/* Configure the main interpreter */

if (_PyMainInterpreterConfig_Copy(&interp->config, config) < 0) {

return _Py_INIT_ERR("failed to copy main interpreter config");

}

config = &interp->config;

_PyCoreConfig *core_config = &interp->core_config;

if (_PyRuntime.initialized) {

return _Py_ReconfigureMainInterpreter(interp, config);

}

if (!core_config->_install_importlib) {

/* Special mode for freeze_importlib: run with no import system

*

* This means anything which needs support from extension modules

* or pure Python code in the standard library won't work.

*/

_PyRuntime.initialized = 1;

return _Py_INIT_OK();

}

if (_PyTime_Init() < 0) {

return _Py_INIT_ERR("can't initialize time");

}

if (_PySys_InitMain(interp) < 0) {

return _Py_INIT_ERR("can't finish initializing sys");

}

_PyInitError err = initexternalimport(interp);

if (_Py_INIT_FAILED(err)) {

return err;

}

/* initialize the faulthandler module */

err = _PyFaulthandler_Init(core_config->faulthandler);

if (_Py_INIT_FAILED(err)) {

return err;

}

err = initfsencoding(interp);

if (_Py_INIT_FAILED(err)) {

return err;

}

if (interp->config.install_signal_handlers) {

err = initsigs(); /* Signal handling stuff, including initintr() */

if (_Py_INIT_FAILED(err)) {

return err;

}

}

if (_PyTraceMalloc_Init(core_config->tracemalloc) < 0) {

return _Py_INIT_ERR("can't initialize tracemalloc");

}

err = add_main_module(interp);

if (_Py_INIT_FAILED(err)) {

return err;

}

err = init_sys_streams(interp);

if (_Py_INIT_FAILED(err)) {

return err;

}

/* Initialize warnings. */

PyObject *warnoptions = PySys_GetObject("warnoptions");

if (warnoptions != NULL && PyList_Size(warnoptions) > 0)

{

PyObject *warnings_module = PyImport_ImportModule("warnings");

if (warnings_module == NULL) {

fprintf(stderr, "'import warnings' failed; traceback:\n");

PyErr_Print();

}

Py_XDECREF(warnings_module);

}

_PyRuntime.initialized = 1;

if (core_config->site_import) {

err = initsite(); /* Module site */

if (_Py_INIT_FAILED(err)) {

return err;

}

}

#ifndef MS_WINDOWS

_emit_stderr_warning_for_legacy_locale(core_config);

#endif

return _Py_INIT_OK();

}

#undef _INIT_DEBUG_PRINT

_PyInitError

_Py_InitializeFromConfig(const _PyCoreConfig *config)

{

PyInterpreterState *interp = NULL;

_PyInitError err;

err = _Py_InitializeCore(&interp, config);

if (_Py_INIT_FAILED(err)) {

return err;

}

config = &interp->core_config;

_PyMainInterpreterConfig main_config = _PyMainInterpreterConfig_INIT;

err = _PyMainInterpreterConfig_Read(&main_config, config);

if (!_Py_INIT_FAILED(err)) {

err = _Py_InitializeMainInterpreter(interp, &main_config);

}

_PyMainInterpreterConfig_Clear(&main_config);

if (_Py_INIT_FAILED(err)) {

return err;

}

return _Py_INIT_OK();

}

void

Py_InitializeEx(int install_sigs)

{

if (_PyRuntime.initialized) {

/* bpo-33932: Calling Py_Initialize() twice does nothing. */

return;

}

_PyInitError err;

_PyCoreConfig config = _PyCoreConfig_INIT;

config.install_signal_handlers = install_sigs;

err = _Py_InitializeFromConfig(&config);

_PyCoreConfig_Clear(&config);

if (_Py_INIT_FAILED(err)) {

_Py_ExitInitError(err);

}

}

void

Py_Initialize(void)

{

Py_InitializeEx(1);

}

#ifdef COUNT_ALLOCS

extern void _Py_dump_counts(FILE*);

#endif

/* Flush stdout and stderr */

static int

file_is_closed(PyObject *fobj)

{

int r;

PyObject *tmp = PyObject_GetAttrString(fobj, "closed");

if (tmp == NULL) {

PyErr_Clear();

return 0;

}

r = PyObject_IsTrue(tmp);

Py_DECREF(tmp);

if (r < 0)

PyErr_Clear();

return r > 0;

}

static int

flush_std_files(void)

{

PyObject *fout = _PySys_GetObjectId(&PyId_stdout);