#include "Python.h"

#include "Python-ast.h"

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

#include "errcode.h"

#include "marshal.h"

#include "code.h"

#include "frameobject.h"

#include "osdefs.h"

#include "importdl.h"

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#ifdef __cplusplus

extern "C" {

#define CACHEDIR "__pycache__"

static PyObject *extensions = NULL;

extern struct _inittab _PyImport_Inittab[];

struct _inittab *PyImport_Inittab = _PyImport_Inittab;

static PyObject *initstr = NULL;

#include "clinic/import.c.h"

_PyImport_Init(void)

{

PyInterpreterState *interp = PyThreadState_Get()->interp;

initstr = PyUnicode_InternFromString("__init__");

if (initstr == NULL)

Py_FatalError("Can't initialize import variables");

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

if (interp->builtins_copy == NULL)

Py_FatalError("Can't backup builtins dict");

}

_PyImportHooks_Init(void)

{

PyObject *v, *path_hooks = NULL;

int err = 0;

/* adding sys.path_hooks and sys.path_importer_cache */

v = PyList_New(0);

if (v == NULL)

goto error;

err = PySys_SetObject("meta_path", v);

Py_DECREF(v);

if (err)

goto error;

v = PyDict_New();

if (v == NULL)

goto error;

err = PySys_SetObject("path_importer_cache", v);

Py_DECREF(v);

if (err)

goto error;

path_hooks = PyList_New(0);

if (path_hooks == NULL)

goto error;

err = PySys_SetObject("path_hooks", path_hooks);

if (err) {

error:

PyErr_Print();

Py_FatalError("initializing sys.meta_path, sys.path_hooks, "

"or path_importer_cache failed");

}

Py_DECREF(path_hooks);

}

_PyImportZip_Init(void)

{

PyObject *path_hooks, *zimpimport;

int err = 0;

path_hooks = PySys_GetObject("path_hooks");

if (path_hooks == NULL) {

PyErr_SetString(PyExc_RuntimeError, "unable to get sys.path_hooks");

goto error;

}

if (Py_VerboseFlag)

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

zimpimport = PyImport_ImportModule("zipimport");

if (zimpimport == NULL) {

PyErr_Clear(); /* No zip import module -- okay */

if (Py_VerboseFlag)

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

}

else {

_Py_IDENTIFIER(zipimporter);

PyObject *zipimporter = _PyObject_GetAttrId(zimpimport,

&PyId_zipimporter);

Py_DECREF(zimpimport);

if (zipimporter == NULL) {

PyErr_Clear(); /* No zipimporter object -- okay */

if (Py_VerboseFlag)

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

PySys_WriteStderr(

"# installed zipimport hook\n");

}

}

return;

error:

PyErr_Print();

Py_FatalError("initializing zipimport failed");

}

#ifdef WITH_THREAD

#include "pythread.h"

static PyThread_type_lock import_lock = 0;

static long import_lock_thread = -1;

static int import_lock_level = 0;

_PyImport_AcquireLock(void)

{

long me = PyThread_get_thread_ident();

if (me == -1)

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 != -1 || !PyThread_acquire_lock(import_lock, 0))

{

PyThreadState *tstate = PyEval_SaveThread();

PyThread_acquire_lock(import_lock, 1);

PyEval_RestoreThread(tstate);

}

assert(import_lock_level == 0);

import_lock_thread = me;

import_lock_level = 1;

}

_PyImport_ReleaseLock(void)

{

long me = PyThread_get_thread_ident();

if (me == -1 || 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 = -1;

PyThread_release_lock(import_lock);

}

return 1;

}

_PyImport_ReInitLock(void)

{

if (import_lock != NULL) {

import_lock = PyThread_allocate_lock();

if (import_lock == NULL) {

Py_FatalError("PyImport_ReInitLock failed to create a new lock");

}

}

if (import_lock_level > 1) {

/* Forked as a side effect of import */

long me = PyThread_get_thread_ident();

/* The following could fail if the lock is already held, but forking as

PyThread_acquire_lock(import_lock, NOWAIT_LOCK);

import_lock_thread = me;

import_lock_level--;

} else {

import_lock_thread = -1;

import_lock_level = 0;

}

}

static PyObject *

_imp_lock_held_impl(PyObject *module)

{

#ifdef WITH_THREAD

return PyBool_FromLong(import_lock_thread != -1);

return PyBool_FromLong(0);

}

static PyObject *

_imp_acquire_lock_impl(PyObject *module)

{

#ifdef WITH_THREAD

_PyImport_AcquireLock();

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

_imp_release_lock_impl(PyObject *module)

{

#ifdef WITH_THREAD

if (_PyImport_ReleaseLock() < 0) {

PyErr_SetString(PyExc_RuntimeError,

"not holding the import lock");

return NULL;

}

Py_INCREF(Py_None);

return Py_None;

}

_PyImport_Fini(void)

{

Py_CLEAR(extensions);

#ifdef WITH_THREAD

if (import_lock != NULL) {

PyThread_free_lock(import_lock);

import_lock = NULL;

}

}

PyObject *

PyImport_GetModuleDict(void)

{

PyInterpreterState *interp = PyThreadState_GET()->interp;

if (interp->modules == NULL)

Py_FatalError("PyImport_GetModuleDict: no module dictionary!");

return interp->modules;

}

static const char * const sys_deletes[] = {

"path", "argv", "ps1", "ps2",

"last_type", "last_value", "last_traceback",

"path_hooks", "path_importer_cache", "meta_path",

"__interactivehook__",

/* misc stuff */

"flags", "float_info",

NULL

};

static const char * const sys_files[] = {

"stdin", "__stdin__",

"stdout", "__stdout__",

"stderr", "__stderr__",

NULL

};

PyImport_Cleanup(void)

{

Py_ssize_t pos;

PyObject *key, *value, *dict;

PyInterpreterState *interp = PyThreadState_GET()->interp;

PyObject *modules = interp->modules;

PyObject *weaklist = NULL;

const char * const *p;

if (modules == NULL)

return; /* Already done */

/* Delete some special variables first. These are common

/* XXX Perhaps these precautions are obsolete. Who knows? */

if (Py_VerboseFlag)

PySys_WriteStderr("# clear builtins._\n");

if (PyDict_SetItemString(interp->builtins, "_", Py_None) < 0) {

PyErr_Clear();

}

for (p = sys_deletes; *p != NULL; p++) {

if (Py_VerboseFlag)

PySys_WriteStderr("# clear sys.%s\n", *p);

if (PyDict_SetItemString(interp->sysdict, *p, Py_None) < 0) {

PyErr_Clear();

}

}

for (p = sys_files; *p != NULL; p+=2) {

if (Py_VerboseFlag)

PySys_WriteStderr("# restore sys.%s\n", *p);

value = PyDict_GetItemString(interp->sysdict, *(p+1));

if (value == NULL)

value = Py_None;

if (PyDict_SetItemString(interp->sysdict, *p, value) < 0) {

PyErr_Clear();

}

}

/* We prepare a list which will receive (name, weakref) tuples of

weaklist = PyList_New(0);

if (weaklist == NULL)

PyErr_Clear();

#define STORE_MODULE_WEAKREF(name, mod) \

if (weaklist != NULL) { \

PyObject *wr = PyWeakref_NewRef(mod, NULL); \

if (wr) { \

PyObject *tup = PyTuple_Pack(2, name, wr); \

if (!tup || PyList_Append(weaklist, tup) < 0) { \

PyErr_Clear(); \

} \

Py_XDECREF(tup); \

Py_DECREF(wr); \

} \

else { \

PyErr_Clear(); \

} \

}

/* Remove all modules from sys.modules, hoping that garbage collection

pos = 0;

while (PyDict_Next(modules, &pos, &key, &value)) {

if (PyModule_Check(value)) {

if (Py_VerboseFlag && PyUnicode_Check(key))

PySys_FormatStderr("# cleanup[2] removing %U\n", key);

STORE_MODULE_WEAKREF(key, value);

if (PyDict_SetItem(modules, key, Py_None) < 0) {

PyErr_Clear();

}

}

}

/* Clear the modules dict. */

PyDict_Clear(modules);

/* Restore the original builtins dict, to ensure that any

dict = PyDict_Copy(interp->builtins);

if (dict == NULL)

PyErr_Clear();

PyDict_Clear(interp->builtins);

if (PyDict_Update(interp->builtins, interp->builtins_copy))

PyErr_Clear();

Py_XDECREF(dict);

/* Clear module dict copies stored in the interpreter state */

_PyState_ClearModules();

/* Collect references */

_PyGC_CollectNoFail();

/* Dump GC stats before it's too late, since it uses the warnings

_PyGC_DumpShutdownStats();

/* Now, if there are any modules left alive, clear their globals to

if (weaklist != NULL) {

Py_ssize_t i, n;

n = PyList_GET_SIZE(weaklist);

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

PyObject *tup = PyList_GET_ITEM(weaklist, i);

PyObject *name = PyTuple_GET_ITEM(tup, 0);

PyObject *mod = PyWeakref_GET_OBJECT(PyTuple_GET_ITEM(tup, 1));

if (mod == Py_None)

continue;

assert(PyModule_Check(mod));

dict = PyModule_GetDict(mod);

if (dict == interp->builtins || dict == interp->sysdict)

continue;

Py_INCREF(mod);

if (Py_VerboseFlag && PyUnicode_Check(name))

PySys_FormatStderr("# cleanup[3] wiping %U\n", name);

_PyModule_Clear(mod);

Py_DECREF(mod);

}

Py_DECREF(weaklist);

}

/* Next, delete sys and builtins (in that order) */

if (Py_VerboseFlag)

PySys_FormatStderr("# cleanup[3] wiping sys\n");

_PyModule_ClearDict(interp->sysdict);

if (Py_VerboseFlag)

PySys_FormatStderr("# cleanup[3] wiping builtins\n");

_PyModule_ClearDict(interp->builtins);

/* Clear and delete the modules directory. Actual modules will

interp->modules = NULL;

Py_DECREF(modules);

/* Once more */

_PyGC_CollectNoFail();

#undef CLEAR_MODULE

#undef STORE_MODULE_WEAKREF

}

PyImport_GetMagicNumber(void)

{

long res;

PyInterpreterState *interp = PyThreadState_Get()->interp;

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;

}

_PyImport_FixupExtensionObject(PyObject *mod, PyObject *name,

PyObject *filename)

{

PyObject *modules, *dict, *key;

struct PyModuleDef *def;

int res;

if (extensions == NULL) {

extensions = PyDict_New();

if (extensions == NULL)

return -1;

}

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

PyErr_BadInternalCall();

return -1;

}

def = PyModule_GetDef(mod);

if (!def) {

PyErr_BadInternalCall();

return -1;

}

modules = PyImport_GetModuleDict();

if (PyDict_SetItem(modules, name, mod) < 0)

return -1;

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

PyDict_DelItem(modules, name);

return -1;

}

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

if (def->m_base.m_copy) {

/* Somebody already imported the module,

Py_CLEAR(def->m_base.m_copy);

}

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;

}

key = PyTuple_Pack(2, filename, name);

if (key == NULL)

return -1;

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

Py_DECREF(key);

if (res < 0)

return -1;

return 0;

}

_PyImport_FixupBuiltin(PyObject *mod, const char *name)

{

int res;

PyObject *nameobj;

nameobj = PyUnicode_InternFromString(name);

if (nameobj == NULL)

return -1;

res = _PyImport_FixupExtensionObject(mod, nameobj, nameobj);

Py_DECREF(nameobj);

return res;

}

PyObject *

_PyImport_FindExtensionObject(PyObject *name, PyObject *filename)

{

PyObject *mod, *mdict, *key;

PyModuleDef* def;

if (extensions == NULL)

return NULL;

key = PyTuple_Pack(2, filename, name);

if (key == NULL)

return NULL;

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

Py_DECREF(key);

if (def == NULL)

return NULL;

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

/* Module does not support repeated initialization */

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

return NULL;

mod = PyImport_AddModuleObject(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 (PyDict_SetItem(PyImport_GetModuleDict(), name, mod) == -1) {

Py_DECREF(mod);

return NULL;

}

Py_DECREF(mod);

}

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

PyDict_DelItem(PyImport_GetModuleDict(), name);

Py_DECREF(mod);

return NULL;

}

if (Py_VerboseFlag)

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

name, filename);

return mod;

}

PyObject *

_PyImport_FindBuiltin(const char *name)

{

PyObject *res, *nameobj;

nameobj = PyUnicode_InternFromString(name);

if (nameobj == NULL)

return NULL;

res = _PyImport_FindExtensionObject(nameobj, nameobj);

Py_DECREF(nameobj);

return res;

}

PyObject *

PyImport_AddModuleObject(PyObject *name)

{

PyObject *modules = PyImport_GetModuleDict();

PyObject *m;

if ((m = PyDict_GetItemWithError(modules, name)) != NULL &&

PyModule_Check(m)) {

return m;

}

if (PyErr_Occurred()) {

return NULL;

}

m = PyModule_NewObject(name);

if (m == NULL)

return NULL;

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

Py_DECREF(m);

return NULL;

}

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

return m;

}

PyObject *

PyImport_AddModule(const char *name)

{

PyObject *nameobj, *module;

nameobj = PyUnicode_FromString(name);

if (nameobj == NULL)

return NULL;

module = PyImport_AddModuleObject(nameobj);

Py_DECREF(nameobj);

return module;

}

static void

remove_module(PyObject *name)

{

PyObject *modules = PyImport_GetModuleDict();

if (PyDict_GetItem(modules, name) == NULL)

return;

if (PyDict_DelItem(modules, name) < 0)

Py_FatalError("import: deleting existing key in "

"sys.modules failed");

}

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 = PyThreadState_GET()->interp;

_Py_IDENTIFIER(_get_sourcefile);

if (interp == NULL) {

Py_FatalError("PyImport_ExecCodeModuleWithPathnames: "

"no interpreter!");

}

external= PyObject_GetAttrString(interp->importlib,

"_bootstrap_external");

if (external != NULL) {

pathobj = _PyObject_CallMethodIdObjArgs(external,

&PyId__get_sourcefile, cpathobj,

NULL);

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(PyObject *name)

{

PyObject *m, *d = NULL;

m = PyImport_AddModuleObject(name);

if (m == NULL)

return NULL;

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

d = PyModule_GetDict(m);

if (PyDict_GetItemString(d, "__builtins__") == NULL) {

if (PyDict_SetItemString(d, "__builtins__",

PyEval_GetBuiltins()) != 0) {

remove_module(name);

return NULL;

}

}

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

}

static PyObject *

exec_code_in_module(PyObject *name, PyObject *module_dict, PyObject *code_object)

{

PyObject *modules = PyImport_GetModuleDict();

PyObject *v, *m;

v = PyEval_EvalCode(code_object, module_dict, module_dict);

if (v == NULL) {

remove_module(name);

return NULL;

}

Py_DECREF(v);

if ((m = PyDict_GetItem(modules, name)) == NULL) {

PyErr_Format(PyExc_ImportError,

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

name);

return NULL;

}

Py_INCREF(m);

return m;

}

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

PyObject *cpathname)

{

PyObject *d, *external, *res;

PyInterpreterState *interp = PyThreadState_GET()->interp;

_Py_IDENTIFIER(_fix_up_module);

d = module_dict_for_exec(name);

if (d == NULL) {

return NULL;

}

if (pathname == NULL) {

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

}

external = PyObject_GetAttrString(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(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);

}

static PyObject *

_imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,

PyObject *path)

{

update_compiled_module(code, path);

Py_RETURN_NONE;

}

static const struct _frozen * find_frozen(PyObject *);

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;

}

static PyObject *

get_path_importer(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_GetItem(path_importer_cache, p);

if (importer != NULL)

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_CallFunctionObjArgs(hook, p, NULL);