/* Module definition and import implementation */

#include "Python.h"

#include "Python-ast.h"

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

#include "pycore_initconfig.h"

#include "pycore_pyerrors.h"

#include "pycore_pyhash.h"

#include "pycore_pylifecycle.h"

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

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

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

#include "pycore_sysmodule.h"

#include "errcode.h"

#include "marshal.h"

#include "code.h"

#include "importdl.h"

#include "pydtrace.h"

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#ifdef __cplusplus

extern "C" {

#endif

#define CACHEDIR "__pycache__"

/* Forward references */

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

/* See _PyImport_FixupExtensionObject() below */

static PyObject *extensions = NULL;

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

extern struct _inittab _PyImport_Inittab[];

struct _inittab *PyImport_Inittab = _PyImport_Inittab;

static struct _inittab *inittab_copy = NULL;

_Py_IDENTIFIER(__path__);

_Py_IDENTIFIER(__spec__);

/*[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, *zipimport;

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");

}

zipimport = PyImport_ImportModule("zipimport");

if (zipimport == NULL) {

_PyErr_Clear(tstate); /* No zip import module -- okay */

if (verbose) {

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

}

}

else {

_Py_IDENTIFIER(zipimporter);

PyObject *zipimporter = _PyObject_GetAttrId(zipimport,

&PyId_zipimporter);

Py_DECREF(zipimport);

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

static PyThread_type_lock import_lock = NULL;

static unsigned long import_lock_thread = PYTHREAD_INVALID_THREAD_ID;

static int import_lock_level = 0;

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;

}

void

_PyImport_Fini(void)

{

Py_CLEAR(extensions);

if (import_lock != NULL) {

PyThread_free_lock(import_lock);

import_lock = NULL;

}

}

void

_PyImport_Fini2(void)

{

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

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

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

{

PyThreadState *tstate = _PyThreadState_GET();

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

return PyObject_SetItem(modules, name, m);

}

int

_PyImport_SetModuleString(const char *name, PyObject *m)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *modules = tstate->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(PyThreadState *tstate, PyObject *mod, PyObject *name)

{

PyInterpreterState *interp = tstate->interp;

PyObject *spec;

_Py_IDENTIFIER(_lock_unlock_module);

/* 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_GetAttrId(mod, &PyId___spec__);

int busy = _PyModuleSpec_IsInitializing(spec);

Py_XDECREF(spec);

if (busy) {

/* Wait until module is done importing. */

PyObject *value = _PyObject_CallMethodIdOneArg(

interp->importlib, &PyId__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;

}

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

_PyImport_FindExtensionObject().

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.

*/

int

_PyImport_FixupExtensionObject(PyObject *mod, PyObject *name,

PyObject *filename, PyObject *modules)

{

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 (PyObject_SetItem(modules, name, mod) < 0) {

return -1;

}

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

PyMapping_DelItem(modules, name);

return -1;

}

if (_Py_IsMainInterpreter(tstate)) {

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 == NULL) {

extensions = PyDict_New();

if (extensions == NULL) {

return -1;

}

}

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;

}

int

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

{

int res;

PyObject *nameobj;

nameobj = PyUnicode_InternFromString(name);

if (nameobj == NULL)

return -1;

res = _PyImport_FixupExtensionObject(mod, nameobj, nameobj, modules);

Py_DECREF(nameobj);

return res;

}

static PyObject *

import_find_extension(PyThreadState *tstate, PyObject *name,

PyObject *filename)

{

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

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)

return NULL;

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

return NULL;

}

else {

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

return NULL;

mod = def->m_base.m_init();

if (mod == NULL)

return NULL;

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

Py_DECREF(mod);

return NULL;

}

Py_DECREF(mod);

}

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

PyMapping_DelItem(modules, name);

return NULL;

}

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

if (verbose) {

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

name, filename);

}

return mod;

}

PyObject *

_PyImport_FindExtensionObject(PyObject *name, PyObject *filename)

{

PyThreadState *tstate = _PyThreadState_GET();

return import_find_extension(tstate, name, filename);

}

PyObject *

_PyImport_FindBuiltin(PyThreadState *tstate, const char *name)

{

PyObject *res, *nameobj;

nameobj = PyUnicode_InternFromString(name);

if (nameobj == NULL)

return NULL;

res = import_find_extension(tstate, nameobj, nameobj);

Py_DECREF(nameobj);

return res;

}

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

Because the former action is most common, THIS DOES NOT RETURN A

'NEW' REFERENCE! */

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

}

m = PyModule_NewObject(name);

if (m == NULL)

return NULL;

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

Py_DECREF(m);

return NULL;

}

Py_DECREF(m); /* Yes, it still exists, in modules! */

return m;

}

PyObject *

PyImport_AddModuleObject(PyObject *name)

{

PyThreadState *tstate = _PyThreadState_GET();

return import_add_module(tstate, name);

}

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();

_Py_IDENTIFIER(_get_sourcefile);

if (interp == NULL) {

Py_FatalError("no current interpreter");

}

external= PyObject_GetAttrString(interp->importlib,

"_bootstrap_external");

if (external != NULL) {

pathobj = _PyObject_CallMethodIdOneArg(

external, &PyId__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)

{

_Py_IDENTIFIER(__builtins__);

PyObject *m, *d = NULL;

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_ContainsId(d, &PyId___builtins__);

if (r == 0) {

r = _PyDict_SetItemId(d, &PyId___builtins__,

PyEval_GetBuiltins());

}

if (r < 0) {

remove_module(tstate, name);

return NULL;

}

return d; /* Return a borrowed reference. */

}

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;

_Py_IDENTIFIER(_fix_up_module);

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)

return NULL;

res = _PyObject_CallMethodIdObjArgs(external,

&PyId__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);

}

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_INCREF(newname);

Py_XSETREF(co->co_filename, 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.

/

Changes code.co_filename to specify the passed-in file path.

[clinic start generated code]*/

static PyObject *

_imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,

PyObject *path)

/*[clinic end generated code: output=1d002f100235587d input=895ba50e78b82f05]*/

{

update_compiled_module(code, path);

Py_RETURN_NONE;

}

/* Forward */

static const struct _frozen * find_frozen(PyObject *);

/* Helper to test for built-in module */

static int

is_builtin(PyObject *name)

{

int i;

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

if (_PyUnicode_EqualToASCIIString(name, PyImport_Inittab[i].name)) {

if (PyImport_Inittab[i].initfunc == NULL)

return -1;

else

return 1;

}

}

return 0;

}

/* Return a finder object for a sys.path/pkg.__path__ item 'p',

possibly by fetching it from the path_importer_cache dict. If it

wasn't yet cached, traverse path_hooks until a hook is found

that can handle the path item. Return None if no hook could;

this tells our caller that the path based finder could not find

a finder for this path item. Cache the result in

path_importer_cache.

Returns a borrowed reference. */

static PyObject *

get_path_importer(PyThreadState *tstate, PyObject *path_importer_cache,

PyObject *path_hooks, PyObject *p)

{

PyObject *importer;

Py_ssize_t j, nhooks;

/* These conditions are the caller's responsibility: */

assert(PyList_Check(path_hooks));

assert(PyDict_Check(path_importer_cache));

nhooks = PyList_Size(path_hooks);

if (nhooks < 0)

return NULL; /* Shouldn't happen */

importer = PyDict_GetItemWithError(path_importer_cache, p);

if (importer != NULL || _PyErr_Occurred(tstate))

return importer;

/* set path_importer_cache[p] to None to avoid recursion */

if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)

return NULL;

for (j = 0; j < nhooks; j++) {

PyObject *hook = PyList_GetItem(path_hooks, j);

if (hook == NULL)

return NULL;

importer = PyObject_CallOneArg(hook, p);

if (importer != NULL)

break;

if (!_PyErr_ExceptionMatches(tstate, PyExc_ImportError)) {

return NULL;

}

_PyErr_Clear(tstate);

}

if (importer == NULL) {

return Py_None;

}

if (importer != NULL) {

int err = PyDict_SetItem(path_importer_cache, p, importer);

Py_DECREF(importer);

if (err != 0)

return NULL;

}

return importer;

}

PyObject *

PyImport_GetImporter(PyObject *path)

{

PyThreadState *tstate = _PyThreadState_GET();

PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;

path_importer_cache = PySys_GetObject("path_importer_cache");

path_hooks = PySys_GetObject("path_hooks");

if (path_importer_cache != NULL && path_hooks != NULL) {

importer = get_path_importer(tstate, path_importer_cache,

path_hooks, path);

}

Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */

return importer;

}

/*[clinic input]

_imp.create_builtin

spec: object

/

Create an extension module.

[clinic start generated code]*/

static PyObject *

_imp_create_builtin(PyObject *module, PyObject *spec)

/*[clinic end generated code: output=ace7ff22271e6f39 input=37f966f890384e47]*/

{

PyThreadState *tstate = _PyThreadState_GET();

struct _inittab *p;

PyObject *name;

const char *namestr;

PyObject *mod;

name = PyObject_GetAttrString(spec, "name");