/* Module definition and import implementation */

#include "Python.h"

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

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

#include "pycore_interp.h" // _PyInterpreterState_ClearModules()

#include "pycore_namespace.h" // _PyNamespace_Type

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

#include "pycore_pyhash.h" // _Py_KeyedHash()

#include "pycore_pylifecycle.h"

#include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()

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

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

#include "marshal.h" // PyMarshal_ReadObjectFromString()

#include "importdl.h" // _PyImport_DynLoadFiletab

#include "pydtrace.h" // PyDTrace_IMPORT_FIND_LOAD_START_ENABLED()

#include <stdbool.h> // bool

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#ifdef __cplusplus

extern "C" {

#endif

/* Forward references */

static PyObject *import_add_module(PyThreadState *tstate, PyObject *name);

/* This table is defined in config.c: */

extern struct _inittab _PyImport_Inittab[];

// This is not used after Py_Initialize() is called.

// (See _PyRuntimeState.imports.inittab.)

struct _inittab *PyImport_Inittab = _PyImport_Inittab;

// When we dynamically allocate a larger table for PyImport_ExtendInittab(),

// we track the pointer here so we can deallocate it during finalization.

static struct _inittab *inittab_copy = NULL;

/*[clinic input]

module _imp

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=9c332475d8686284]*/

#include "clinic/import.c.h"

/* Initialize things */

PyStatus

_PyImportZip_Init(PyThreadState *tstate)

{

PyObject *path_hooks;

int err = 0;

path_hooks = PySys_GetObject("path_hooks");

if (path_hooks == NULL) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"unable to get sys.path_hooks");

goto error;

}

int verbose = _PyInterpreterState_GetConfig(tstate->interp)->verbose;

if (verbose) {

PySys_WriteStderr("# installing zipimport hook\n");

}

PyObject *zipimporter = _PyImport_GetModuleAttrString("zipimport", "zipimporter");

if (zipimporter == NULL) {

_PyErr_Clear(tstate); /* No zipimporter object -- okay */

if (verbose) {

PySys_WriteStderr("# can't import zipimport.zipimporter\n");

}

}

else {

/* sys.path_hooks.insert(0, zipimporter) */

err = PyList_Insert(path_hooks, 0, zipimporter);

Py_DECREF(zipimporter);

if (err < 0) {

goto error;

}

if (verbose) {

PySys_WriteStderr("# installed zipimport hook\n");

}

}

return _PyStatus_OK();

error:

PyErr_Print();

return _PyStatus_ERR("initializing zipimport failed");

}

/* Locking primitives to prevent parallel imports of the same module

in different threads to return with a partially loaded module.

These calls are serialized by the global interpreter lock. */

#define import_lock _PyRuntime.imports.lock.mutex

#define import_lock_thread _PyRuntime.imports.lock.thread

#define import_lock_level _PyRuntime.imports.lock.level

void

_PyImport_AcquireLock(void)

{

unsigned long me = PyThread_get_thread_ident();

if (me == PYTHREAD_INVALID_THREAD_ID)

return; /* Too bad */

if (import_lock == NULL) {

import_lock = PyThread_allocate_lock();

if (import_lock == NULL)

return; /* Nothing much we can do. */

}

if (import_lock_thread == me) {

import_lock_level++;

return;

}

if (import_lock_thread != PYTHREAD_INVALID_THREAD_ID ||

!PyThread_acquire_lock(import_lock, 0))

{

PyThreadState *tstate = PyEval_SaveThread();

PyThread_acquire_lock(import_lock, WAIT_LOCK);

PyEval_RestoreThread(tstate);

}

assert(import_lock_level == 0);

import_lock_thread = me;

import_lock_level = 1;

}

int

_PyImport_ReleaseLock(void)

{

unsigned long me = PyThread_get_thread_ident();

if (me == PYTHREAD_INVALID_THREAD_ID || import_lock == NULL)

return 0; /* Too bad */

if (import_lock_thread != me)

return -1;

import_lock_level--;

assert(import_lock_level >= 0);

if (import_lock_level == 0) {

import_lock_thread = PYTHREAD_INVALID_THREAD_ID;

PyThread_release_lock(import_lock);

}

return 1;

}

#ifdef HAVE_FORK

/* This function is called from PyOS_AfterFork_Child() to ensure that newly

created child processes do not share locks with the parent.

We now acquire the import lock around fork() calls but on some platforms

(Solaris 9 and earlier? see isue7242) that still left us with problems. */

PyStatus

_PyImport_ReInitLock(void)

{

if (import_lock != NULL) {

if (_PyThread_at_fork_reinit(&import_lock) < 0) {

return _PyStatus_ERR("failed to create a new lock");

}

}

if (import_lock_level > 1) {

/* Forked as a side effect of import */

unsigned long me = PyThread_get_thread_ident();

PyThread_acquire_lock(import_lock, WAIT_LOCK);

import_lock_thread = me;

import_lock_level--;

} else {

import_lock_thread = PYTHREAD_INVALID_THREAD_ID;

import_lock_level = 0;

}

return _PyStatus_OK();

}

#endif

/*[clinic input]

_imp.lock_held

Return True if the import lock is currently held, else False.

On platforms without threads, return False.

[clinic start generated code]*/

static PyObject *

_imp_lock_held_impl(PyObject *module)

/*[clinic end generated code: output=8b89384b5e1963fc input=9b088f9b217d9bdf]*/

{

return PyBool_FromLong(import_lock_thread != PYTHREAD_INVALID_THREAD_ID);

}

/*[clinic input]

_imp.acquire_lock

Acquires the interpreter's import lock for the current thread.

This lock should be used by import hooks to ensure thread-safety when importing

modules. On platforms without threads, this function does nothing.

[clinic start generated code]*/

static PyObject *

_imp_acquire_lock_impl(PyObject *module)

/*[clinic end generated code: output=1aff58cb0ee1b026 input=4a2d4381866d5fdc]*/

{

_PyImport_AcquireLock();

Py_RETURN_NONE;

}

/*[clinic input]

_imp.release_lock

Release the interpreter's import lock.

On platforms without threads, this function does nothing.

[clinic start generated code]*/

static PyObject *

_imp_release_lock_impl(PyObject *module)

/*[clinic end generated code: output=7faab6d0be178b0a input=934fb11516dd778b]*/

{

if (_PyImport_ReleaseLock() < 0) {

PyErr_SetString(PyExc_RuntimeError,

"not holding the import lock");

return NULL;

}

Py_RETURN_NONE;

}

PyStatus

_PyImport_Init(void)

{

if (_PyRuntime.imports.inittab != NULL) {

return _PyStatus_ERR("global import state already initialized");

}

PyStatus status = _PyStatus_OK();

size_t size;

for (size = 0; PyImport_Inittab[size].name != NULL; size++)

;

size++;

/* Force default raw memory allocator to get a known allocator to be able

to release the memory in _PyImport_Fini() */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

/* Make the copy. */

struct _inittab *copied = PyMem_RawMalloc(size * sizeof(struct _inittab));

if (copied == NULL) {

status = PyStatus_NoMemory();

goto done;

}

memcpy(copied, PyImport_Inittab, size * sizeof(struct _inittab));

_PyRuntime.imports.inittab = copied;

done:

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

return status;

}

static inline void _extensions_cache_clear(void);

void

_PyImport_Fini(void)

{

_extensions_cache_clear();

if (import_lock != NULL) {

PyThread_free_lock(import_lock);

import_lock = NULL;

}

/* Use the same memory allocator as _PyImport_Init(). */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

/* Free memory allocated by _PyImport_Init() */

struct _inittab *inittab = _PyRuntime.imports.inittab;

_PyRuntime.imports.inittab = NULL;

PyMem_RawFree(inittab);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

void

_PyImport_Fini2(void)

{

/* Use the same memory allocator than PyImport_ExtendInittab(). */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

// Reset PyImport_Inittab

PyImport_Inittab = _PyImport_Inittab;

/* Free memory allocated by PyImport_ExtendInittab() */

PyMem_RawFree(inittab_copy);

inittab_copy = NULL;

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

/* Helper for sys */

PyObject *

PyImport_GetModuleDict(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (interp->modules == NULL) {

Py_FatalError("interpreter has no modules dictionary");

}

return interp->modules;

}

/* In some corner cases it is important to be sure that the import

machinery has been initialized (or not cleaned up yet). For

example, see issue #4236 and PyModule_Create2(). */

int

_PyImport_IsInitialized(PyInterpreterState *interp)

{

if (interp->modules == NULL)

return 0;

return 1;

}

PyObject *

_PyImport_GetModuleId(_Py_Identifier *nameid)

{

PyObject *name = _PyUnicode_FromId(nameid); /* borrowed */

if (name == NULL) {

return NULL;

}

return PyImport_GetModule(name);

}

int

_PyImport_SetModule(PyObject *name, PyObject *m)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

PyObject *modules = interp->modules;

return PyObject_SetItem(modules, name, m);

}

int

_PyImport_SetModuleString(const char *name, PyObject *m)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

PyObject *modules = interp->modules;

return PyMapping_SetItemString(modules, name, m);

}

static PyObject *

import_get_module(PyThreadState *tstate, PyObject *name)

{

PyObject *modules = tstate->interp->modules;

if (modules == NULL) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"unable to get sys.modules");

return NULL;

}

PyObject *m;

Py_INCREF(modules);

if (PyDict_CheckExact(modules)) {

m = PyDict_GetItemWithError(modules, name); /* borrowed */

Py_XINCREF(m);

}

else {

m = PyObject_GetItem(modules, name);

if (m == NULL && _PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {

_PyErr_Clear(tstate);

}

}

Py_DECREF(modules);

return m;

}

static int

import_ensure_initialized(PyInterpreterState *interp, PyObject *mod, PyObject *name)

{

PyObject *spec;

/* Optimization: only call _bootstrap._lock_unlock_module() if

__spec__._initializing is true.

NOTE: because of this, initializing must be set *before*

stuffing the new module in sys.modules.

*/

spec = PyObject_GetAttr(mod, &_Py_ID(__spec__));

int busy = _PyModuleSpec_IsInitializing(spec);

Py_XDECREF(spec);

if (busy) {

/* Wait until module is done importing. */

PyObject *value = _PyObject_CallMethodOneArg(

interp->importlib, &_Py_ID(_lock_unlock_module), name);

if (value == NULL) {

return -1;

}

Py_DECREF(value);

}

return 0;

}

/* Helper for pythonrun.c -- return magic number and tag. */

long

PyImport_GetMagicNumber(void)

{

long res;

PyInterpreterState *interp = _PyInterpreterState_GET();

PyObject *external, *pyc_magic;

external = PyObject_GetAttrString(interp->importlib, "_bootstrap_external");

if (external == NULL)

return -1;

pyc_magic = PyObject_GetAttrString(external, "_RAW_MAGIC_NUMBER");

Py_DECREF(external);

if (pyc_magic == NULL)

return -1;

res = PyLong_AsLong(pyc_magic);

Py_DECREF(pyc_magic);

return res;

}

extern const char * _PySys_ImplCacheTag;

const char *

PyImport_GetMagicTag(void)

{

return _PySys_ImplCacheTag;

}

/*

We support a number of kinds of single-phase init builtin/extension modules:

* "basic"

* no module state (PyModuleDef.m_size == -1)

* does not support repeated init (we use PyModuleDef.m_base.m_copy)

* may have process-global state

* the module's def is cached in _PyRuntime.imports.extensions,

by (name, filename)

* "reinit"

* no module state (PyModuleDef.m_size == 0)

* supports repeated init (m_copy is never used)

* should not have any process-global state

* its def is never cached in _PyRuntime.imports.extensions

(except, currently, under the main interpreter, for some reason)

* "with state" (almost the same as reinit)

* has module state (PyModuleDef.m_size > 0)

* supports repeated init (m_copy is never used)

* should not have any process-global state

* its def is never cached in _PyRuntime.imports.extensions

(except, currently, under the main interpreter, for some reason)

There are also variants within those classes:

* two or more modules share a PyModuleDef

* a module's init func uses another module's PyModuleDef

* a module's init func calls another's module's init func

* a module's init "func" is actually a variable statically initialized

to another module's init func

* two or modules share "methods"

* a module's init func copies another module's PyModuleDef

(with a different name)

* (basic-only) two or modules share process-global state

In the first case, where modules share a PyModuleDef, the following

notable weirdness happens:

* the module's __name__ matches the def, not the requested name

* the last module (with the same def) to be imported for the first time wins

* returned by PyState_Find_Module() (via interp->modules_by_index)

* (non-basic-only) its init func is used when re-loading any of them

(via the def's m_init)

* (basic-only) the copy of its __dict__ is used when re-loading any of them

(via the def's m_copy)

However, the following happens as expected:

* a new module object (with its own __dict__) is created for each request

* the module's __spec__ has the requested name

* the loaded module is cached in sys.modules under the requested name

* the m_index field of the shared def is not changed,

so at least PyState_FindModule() will always look in the same place

For "basic" modules there are other quirks:

* (whether sharing a def or not) when loaded the first time,

m_copy is set before _init_module_attrs() is called

in importlib._bootstrap.module_from_spec(),

so when the module is re-loaded, the previous value

for __wpec__ (and others) is reset, possibly unexpectedly.

Generally, when multiple interpreters are involved, some of the above

gets even messier.

*/

/* Magic for extension modules (built-in as well as dynamically

loaded). To prevent initializing an extension module more than

once, we keep a static dictionary 'extensions' keyed by the tuple

(module name, module name) (for built-in modules) or by

(filename, module name) (for dynamically loaded modules), containing these

modules. A copy of the module's dictionary is stored by calling

_PyImport_FixupExtensionObject() immediately after the module initialization

function succeeds. A copy can be retrieved from there by calling

import_find_extension().

Modules which do support multiple initialization set their m_size

field to a non-negative number (indicating the size of the

module-specific state). They are still recorded in the extensions

dictionary, to avoid loading shared libraries twice.

*/

static PyModuleDef *

_extensions_cache_get(PyObject *filename, PyObject *name)

{

PyObject *extensions = _PyRuntime.imports.extensions;

if (extensions == NULL) {

return NULL;

}

PyObject *key = PyTuple_Pack(2, filename, name);

if (key == NULL) {

return NULL;

}

PyModuleDef *def = (PyModuleDef *)PyDict_GetItemWithError(extensions, key);

Py_DECREF(key);

return def;

}

static int

_extensions_cache_set(PyObject *filename, PyObject *name, PyModuleDef *def)

{

PyObject *extensions = _PyRuntime.imports.extensions;

if (extensions == NULL) {

extensions = PyDict_New();

if (extensions == NULL) {

return -1;

}

_PyRuntime.imports.extensions = extensions;

}

PyObject *key = PyTuple_Pack(2, filename, name);

if (key == NULL) {

return -1;

}

int res = PyDict_SetItem(extensions, key, (PyObject *)def);

Py_DECREF(key);

if (res < 0) {

return -1;

}

return 0;

}

static void

_extensions_cache_clear(void)

{

Py_CLEAR(_PyRuntime.imports.extensions);

}

static int

fix_up_extension(PyObject *mod, PyObject *name, PyObject *filename)

{

if (mod == NULL || !PyModule_Check(mod)) {

PyErr_BadInternalCall();

return -1;

}

struct PyModuleDef *def = PyModule_GetDef(mod);

if (!def) {

PyErr_BadInternalCall();

return -1;

}

PyThreadState *tstate = _PyThreadState_GET();

if (_PyState_AddModule(tstate, mod, def) < 0) {

return -1;

}

// bpo-44050: Extensions and def->m_base.m_copy can be updated

// when the extension module doesn't support sub-interpreters.

// XXX Why special-case the main interpreter?

if (_Py_IsMainInterpreter(tstate->interp) || def->m_size == -1) {

if (def->m_size == -1) {

if (def->m_base.m_copy) {

/* Somebody already imported the module,

likely under a different name.

XXX this should really not happen. */

Py_CLEAR(def->m_base.m_copy);

}

PyObject *dict = PyModule_GetDict(mod);

if (dict == NULL) {

return -1;

}

def->m_base.m_copy = PyDict_Copy(dict);

if (def->m_base.m_copy == NULL) {

return -1;

}

}

if (_extensions_cache_set(filename, name, def) < 0) {

return -1;

}

}

return 0;

}

int

_PyImport_FixupExtensionObject(PyObject *mod, PyObject *name,

PyObject *filename, PyObject *modules)

{

if (PyObject_SetItem(modules, name, mod) < 0) {

return -1;

}

if (fix_up_extension(mod, name, filename) < 0) {

PyMapping_DelItem(modules, name);

return -1;

}

return 0;

}

int

_PyImport_FixupBuiltin(PyObject *mod, const char *name, PyObject *modules)

{

int res = -1;

PyObject *nameobj;

nameobj = PyUnicode_InternFromString(name);

if (nameobj == NULL) {

return -1;

}

if (PyObject_SetItem(modules, nameobj, mod) < 0) {

goto finally;

}

if (fix_up_extension(mod, nameobj, nameobj) < 0) {

PyMapping_DelItem(modules, nameobj);

goto finally;

}

res = 0;

finally:

Py_DECREF(nameobj);

return res;

}

static PyObject *

import_find_extension(PyThreadState *tstate, PyObject *name,

PyObject *filename)

{

PyModuleDef *def = _extensions_cache_get(filename, name);

if (def == NULL) {

return NULL;

}

PyObject *mod, *mdict;

PyObject *modules = tstate->interp->modules;

if (def->m_size == -1) {

/* Module does not support repeated initialization */

if (def->m_base.m_copy == NULL)

return NULL;

mod = import_add_module(tstate, name);

if (mod == NULL)

return NULL;

mdict = PyModule_GetDict(mod);

if (mdict == NULL) {

Py_DECREF(mod);

return NULL;

}

if (PyDict_Update(mdict, def->m_base.m_copy)) {

Py_DECREF(mod);

return NULL;

}

}

else {

if (def->m_base.m_init == NULL)

return NULL;

mod = _PyImport_InitFunc_TrampolineCall(def->m_base.m_init);

if (mod == NULL)

return NULL;

if (PyObject_SetItem(modules, name, mod) == -1) {

Py_DECREF(mod);

return NULL;

}

}

if (_PyState_AddModule(tstate, mod, def) < 0) {

PyMapping_DelItem(modules, name);

Py_DECREF(mod);

return NULL;

}

int verbose = _PyInterpreterState_GetConfig(tstate->interp)->verbose;

if (verbose) {

PySys_FormatStderr("import %U # previously loaded (%R)\n",

name, filename);

}

return mod;

}

/* Get the module object corresponding to a module name.

First check the modules dictionary if there's one there,

if not, create a new one and insert it in the modules dictionary. */

static PyObject *

import_add_module(PyThreadState *tstate, PyObject *name)

{

PyObject *modules = tstate->interp->modules;

if (modules == NULL) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"no import module dictionary");

return NULL;

}

PyObject *m;

if (PyDict_CheckExact(modules)) {

m = Py_XNewRef(PyDict_GetItemWithError(modules, name));

}

else {

m = PyObject_GetItem(modules, name);

// For backward-compatibility we copy the behavior

// of PyDict_GetItemWithError().

if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {

_PyErr_Clear(tstate);

}

}

if (_PyErr_Occurred(tstate)) {

return NULL;

}

if (m != NULL && PyModule_Check(m)) {

return m;

}

Py_XDECREF(m);

m = PyModule_NewObject(name);

if (m == NULL)

return NULL;

if (PyObject_SetItem(modules, name, m) != 0) {

Py_DECREF(m);

return NULL;

}

return m;

}

PyObject *

PyImport_AddModuleObject(PyObject *name)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *mod = import_add_module(tstate, name);

if (mod) {

PyObject *ref = PyWeakref_NewRef(mod, NULL);

Py_DECREF(mod);

if (ref == NULL) {

return NULL;

}

mod = PyWeakref_GetObject(ref);

Py_DECREF(ref);

}

return mod; /* borrowed reference */

}

PyObject *

PyImport_AddModule(const char *name)

{

PyObject *nameobj = PyUnicode_FromString(name);

if (nameobj == NULL) {

return NULL;

}

PyObject *module = PyImport_AddModuleObject(nameobj);

Py_DECREF(nameobj);

return module;

}

/* Remove name from sys.modules, if it's there.

* Can be called with an exception raised.

* If fail to remove name a new exception will be chained with the old

* exception, otherwise the old exception is preserved.

*/

static void

remove_module(PyThreadState *tstate, PyObject *name)

{

PyObject *type, *value, *traceback;

_PyErr_Fetch(tstate, &type, &value, &traceback);

PyObject *modules = tstate->interp->modules;

if (PyDict_CheckExact(modules)) {

PyObject *mod = _PyDict_Pop(modules, name, Py_None);

Py_XDECREF(mod);

}

else if (PyMapping_DelItem(modules, name) < 0) {

if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {

_PyErr_Clear(tstate);

}

}

_PyErr_ChainExceptions(type, value, traceback);

}

/* Execute a code object in a module and return the module object

* WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is

* removed from sys.modules, to avoid leaving damaged module objects

* in sys.modules. The caller may wish to restore the original

* module object (if any) in this case; PyImport_ReloadModule is an

* example.

*

* Note that PyImport_ExecCodeModuleWithPathnames() is the preferred, richer

* interface. The other two exist primarily for backward compatibility.

*/

PyObject *

PyImport_ExecCodeModule(const char *name, PyObject *co)

{

return PyImport_ExecCodeModuleWithPathnames(

name, co, (char *)NULL, (char *)NULL);

}

PyObject *

PyImport_ExecCodeModuleEx(const char *name, PyObject *co, const char *pathname)

{

return PyImport_ExecCodeModuleWithPathnames(

name, co, pathname, (char *)NULL);

}

PyObject *

PyImport_ExecCodeModuleWithPathnames(const char *name, PyObject *co,

const char *pathname,

const char *cpathname)

{

PyObject *m = NULL;

PyObject *nameobj, *pathobj = NULL, *cpathobj = NULL, *external= NULL;

nameobj = PyUnicode_FromString(name);

if (nameobj == NULL)

return NULL;

if (cpathname != NULL) {

cpathobj = PyUnicode_DecodeFSDefault(cpathname);

if (cpathobj == NULL)

goto error;

}

else

cpathobj = NULL;

if (pathname != NULL) {

pathobj = PyUnicode_DecodeFSDefault(pathname);

if (pathobj == NULL)

goto error;

}

else if (cpathobj != NULL) {

PyInterpreterState *interp = _PyInterpreterState_GET();

if (interp == NULL) {

Py_FatalError("no current interpreter");

}

external= PyObject_GetAttrString(interp->importlib,

"_bootstrap_external");

if (external != NULL) {

pathobj = _PyObject_CallMethodOneArg(

external, &_Py_ID(_get_sourcefile), cpathobj);

Py_DECREF(external);

}

if (pathobj == NULL)

PyErr_Clear();

}

else

pathobj = NULL;

m = PyImport_ExecCodeModuleObject(nameobj, co, pathobj, cpathobj);

error:

Py_DECREF(nameobj);

Py_XDECREF(pathobj);

Py_XDECREF(cpathobj);

return m;

}

static PyObject *

module_dict_for_exec(PyThreadState *tstate, PyObject *name)

{

PyObject *m, *d;

m = import_add_module(tstate, name);

if (m == NULL)

return NULL;

/* If the module is being reloaded, we get the old module back

and re-use its dict to exec the new code. */

d = PyModule_GetDict(m);

int r = PyDict_Contains(d, &_Py_ID(__builtins__));

if (r == 0) {

r = PyDict_SetItem(d, &_Py_ID(__builtins__), PyEval_GetBuiltins());

}

if (r < 0) {

remove_module(tstate, name);

Py_DECREF(m);

return NULL;

}

Py_INCREF(d);

Py_DECREF(m);

return d;

}

static PyObject *

exec_code_in_module(PyThreadState *tstate, PyObject *name,

PyObject *module_dict, PyObject *code_object)

{

PyObject *v, *m;

v = PyEval_EvalCode(code_object, module_dict, module_dict);

if (v == NULL) {

remove_module(tstate, name);

return NULL;

}

Py_DECREF(v);

m = import_get_module(tstate, name);

if (m == NULL && !_PyErr_Occurred(tstate)) {

_PyErr_Format(tstate, PyExc_ImportError,

"Loaded module %R not found in sys.modules",

name);

}

return m;

}

PyObject*

PyImport_ExecCodeModuleObject(PyObject *name, PyObject *co, PyObject *pathname,

PyObject *cpathname)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *d, *external, *res;

d = module_dict_for_exec(tstate, name);

if (d == NULL) {

return NULL;

}

if (pathname == NULL) {

pathname = ((PyCodeObject *)co)->co_filename;

}

external = PyObject_GetAttrString(tstate->interp->importlib,

"_bootstrap_external");

if (external == NULL) {

Py_DECREF(d);

return NULL;

}

res = PyObject_CallMethodObjArgs(external, &_Py_ID(_fix_up_module),

d, name, pathname, cpathname, NULL);

Py_DECREF(external);

if (res != NULL) {

Py_DECREF(res);

res = exec_code_in_module(tstate, name, d, co);

}

Py_DECREF(d);

return res;

}

static void

update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)

{

PyObject *constants, *tmp;

Py_ssize_t i, n;

if (PyUnicode_Compare(co->co_filename, oldname))

return;

Py_XSETREF(co->co_filename, Py_NewRef(newname));

constants = co->co_consts;

n = PyTuple_GET_SIZE(constants);

for (i = 0; i < n; i++) {

tmp = PyTuple_GET_ITEM(constants, i);

if (PyCode_Check(tmp))

update_code_filenames((PyCodeObject *)tmp,

oldname, newname);

}

}

static void

update_compiled_module(PyCodeObject *co, PyObject *newname)

{

PyObject *oldname;

if (PyUnicode_Compare(co->co_filename, newname) == 0)

return;

oldname = co->co_filename;

Py_INCREF(oldname);

update_code_filenames(co, oldname, newname);

Py_DECREF(oldname);

}

/*[clinic input]

_imp._fix_co_filename

code: object(type="PyCodeObject *", subclass_of="&PyCode_Type")

Code object to change.

path: unicode

File path to use.

/