2
/* Module definition and import implementation */
6
#include "Python-ast.h"
7
#undef Yield /* undefine macro conflicting with winbase.h */
26
/* for stat.st_mode */
27
typedef unsigned short mode_t;
31
/* Magic word to reject .pyc files generated by other Python versions.
32
It should change for each incompatible change to the bytecode.
34
The value of CR and LF is incorporated so if you ever read or write
35
a .pyc file in text mode the magic number will be wrong; also, the
36
Apple MPW compiler swaps their values, botching string constants.
38
The magic numbers must be spaced apart at least 2 values, as the
39
-U interpeter flag will cause MAGIC+1 being used. They have been
40
odd numbers for some time now.
42
There were a variety of old schemes for setting the magic number.
43
The current working scheme is to increment the previous value by
59
Python 2.3a0: 62011 (!)
64
Python 2.5a0: 62081 (ast-branch)
65
Python 2.5a0: 62091 (with)
66
Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)
67
Python 2.5b3: 62101 (fix wrong code: for x, in ...)
68
Python 2.5b3: 62111 (fix wrong code: x += yield)
69
Python 2.5c1: 62121 (fix wrong lnotab with for loops and
70
storing constants that should have been removed)
71
Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)
72
Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode)
73
Python 2.6a1: 62161 (WITH_CLEANUP optimization)
75
3010 (removed UNARY_CONVERT)
76
3020 (added BUILD_SET)
77
3030 (added keyword-only parameters)
78
3040 (added signature annotations)
79
3050 (print becomes a function)
80
3060 (PEP 3115 metaclass syntax)
81
3070 (PEP 3109 raise changes)
82
3080 (PEP 3137 make __file__ and __name__ unicode)
83
3090 (kill str8 interning)
84
3100 (merge from 2.6a0, see 62151)
85
3102 (__file__ points to source file)
86
Python 3.0a4: 3110 (WITH_CLEANUP optimization).
87
Python 3.0a5: 3130 (lexical exception stacking, including POP_EXCEPT)
88
Python 3.1a0: 3140 (optimize list, set and dict comprehensions:
89
change LIST_APPEND and SET_ADD, add MAP_ADD)
90
Python 3.1a0: 3150 (optimize conditional branches:
91
introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE)
93
#define MAGIC (3150 | ((long)'\r'<<16) | ((long)'\n'<<24))
95
/* Magic word as global; note that _PyImport_Init() can change the
96
value of this global to accommodate for alterations of how the
97
compiler works which are enabled by command line switches. */
98
static long pyc_magic = MAGIC;
100
/* See _PyImport_FixupExtension() below */
101
static PyObject *extensions = NULL;
103
/* This table is defined in config.c: */
104
extern struct _inittab _PyImport_Inittab[];
106
/* Method from Parser/tokenizer.c */
107
extern char * PyTokenizer_FindEncoding(int);
109
struct _inittab *PyImport_Inittab = _PyImport_Inittab;
111
/* these tables define the module suffixes that Python recognizes */
112
struct filedescr * _PyImport_Filetab = NULL;
114
static const struct filedescr _PyImport_StandardFiletab[] = {
115
{".py", "U", PY_SOURCE},
117
{".pyw", "U", PY_SOURCE},
119
{".pyc", "rb", PY_COMPILED},
124
/* Initialize things */
129
const struct filedescr *scan;
130
struct filedescr *filetab;
134
/* prepare _PyImport_Filetab: copy entries from
135
_PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
137
#ifdef HAVE_DYNAMIC_LOADING
138
for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
141
for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
143
filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
145
Py_FatalError("Can't initialize import file table.");
146
#ifdef HAVE_DYNAMIC_LOADING
147
memcpy(filetab, _PyImport_DynLoadFiletab,
148
countD * sizeof(struct filedescr));
150
memcpy(filetab + countD, _PyImport_StandardFiletab,
151
countS * sizeof(struct filedescr));
152
filetab[countD + countS].suffix = NULL;
154
_PyImport_Filetab = filetab;
156
if (Py_OptimizeFlag) {
157
/* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
158
for (; filetab->suffix != NULL; filetab++) {
159
if (strcmp(filetab->suffix, ".pyc") == 0)
160
filetab->suffix = ".pyo";
165
/* Fix the pyc_magic so that byte compiled code created
166
using the all-Unicode method doesn't interfere with
167
code created in normal operation mode. */
168
pyc_magic = MAGIC + 1;
173
_PyImportHooks_Init(void)
175
PyObject *v, *path_hooks = NULL, *zimpimport;
178
/* adding sys.path_hooks and sys.path_importer_cache, setting up
180
if (PyType_Ready(&PyNullImporter_Type) < 0)
184
PySys_WriteStderr("# installing zipimport hook\n");
189
err = PySys_SetObject("meta_path", v);
196
err = PySys_SetObject("path_importer_cache", v);
200
path_hooks = PyList_New(0);
201
if (path_hooks == NULL)
203
err = PySys_SetObject("path_hooks", path_hooks);
207
Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
208
"path_importer_cache, or NullImporter failed"
212
zimpimport = PyImport_ImportModule("zipimport");
213
if (zimpimport == NULL) {
214
PyErr_Clear(); /* No zip import module -- okay */
216
PySys_WriteStderr("# can't import zipimport\n");
219
PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
221
Py_DECREF(zimpimport);
222
if (zipimporter == NULL) {
223
PyErr_Clear(); /* No zipimporter object -- okay */
226
"# can't import zipimport.zipimporter\n");
229
/* sys.path_hooks.append(zipimporter) */
230
err = PyList_Append(path_hooks, zipimporter);
231
Py_DECREF(zipimporter);
236
"# installed zipimport hook\n");
239
Py_DECREF(path_hooks);
245
Py_XDECREF(extensions);
247
PyMem_DEL(_PyImport_Filetab);
248
_PyImport_Filetab = NULL;
252
/* Locking primitives to prevent parallel imports of the same module
253
in different threads to return with a partially loaded module.
254
These calls are serialized by the global interpreter lock. */
258
#include "pythread.h"
260
static PyThread_type_lock import_lock = 0;
261
static long import_lock_thread = -1;
262
static int import_lock_level = 0;
267
long me = PyThread_get_thread_ident();
269
return; /* Too bad */
270
if (import_lock == NULL) {
271
import_lock = PyThread_allocate_lock();
272
if (import_lock == NULL)
273
return; /* Nothing much we can do. */
275
if (import_lock_thread == me) {
279
if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
281
PyThreadState *tstate = PyEval_SaveThread();
282
PyThread_acquire_lock(import_lock, 1);
283
PyEval_RestoreThread(tstate);
285
import_lock_thread = me;
286
import_lock_level = 1;
292
long me = PyThread_get_thread_ident();
293
if (me == -1 || import_lock == NULL)
294
return 0; /* Too bad */
295
if (import_lock_thread != me)
298
if (import_lock_level == 0) {
299
import_lock_thread = -1;
300
PyThread_release_lock(import_lock);
305
/* This function is called from PyOS_AfterFork to ensure that newly
306
created child processes do not share locks with the parent. */
309
_PyImport_ReInitLock(void)
312
if (import_lock != NULL)
313
import_lock = PyThread_allocate_lock();
319
#define lock_import()
320
#define unlock_import() 0
325
imp_lock_held(PyObject *self, PyObject *noargs)
328
return PyBool_FromLong(import_lock_thread != -1);
330
return PyBool_FromLong(0);
335
imp_acquire_lock(PyObject *self, PyObject *noargs)
345
imp_release_lock(PyObject *self, PyObject *noargs)
348
if (unlock_import() < 0) {
349
PyErr_SetString(PyExc_RuntimeError,
350
"not holding the import lock");
359
imp_modules_reloading_clear(void)
361
PyInterpreterState *interp = PyThreadState_Get()->interp;
362
if (interp->modules_reloading != NULL)
363
PyDict_Clear(interp->modules_reloading);
369
PyImport_GetModuleDict(void)
371
PyInterpreterState *interp = PyThreadState_GET()->interp;
372
if (interp->modules == NULL)
373
Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
374
return interp->modules;
378
/* List of names to clear in sys */
379
static char* sys_deletes[] = {
380
"path", "argv", "ps1", "ps2",
381
"last_type", "last_value", "last_traceback",
382
"path_hooks", "path_importer_cache", "meta_path",
384
"flags", "float_info",
388
static char* sys_files[] = {
389
"stdin", "__stdin__",
390
"stdout", "__stdout__",
391
"stderr", "__stderr__",
396
/* Un-initialize things, as good as we can */
399
PyImport_Cleanup(void)
401
Py_ssize_t pos, ndone;
403
PyObject *key, *value, *dict;
404
PyInterpreterState *interp = PyThreadState_GET()->interp;
405
PyObject *modules = interp->modules;
408
return; /* Already done */
410
/* Delete some special variables first. These are common
411
places where user values hide and people complain when their
412
destructors fail. Since the modules containing them are
413
deleted *last* of all, they would come too late in the normal
414
destruction order. Sigh. */
416
value = PyDict_GetItemString(modules, "builtins");
417
if (value != NULL && PyModule_Check(value)) {
418
dict = PyModule_GetDict(value);
420
PySys_WriteStderr("# clear builtins._\n");
421
PyDict_SetItemString(dict, "_", Py_None);
423
value = PyDict_GetItemString(modules, "sys");
424
if (value != NULL && PyModule_Check(value)) {
427
dict = PyModule_GetDict(value);
428
for (p = sys_deletes; *p != NULL; p++) {
430
PySys_WriteStderr("# clear sys.%s\n", *p);
431
PyDict_SetItemString(dict, *p, Py_None);
433
for (p = sys_files; *p != NULL; p+=2) {
435
PySys_WriteStderr("# restore sys.%s\n", *p);
436
v = PyDict_GetItemString(dict, *(p+1));
439
PyDict_SetItemString(dict, *p, v);
443
/* First, delete __main__ */
444
value = PyDict_GetItemString(modules, "__main__");
445
if (value != NULL && PyModule_Check(value)) {
447
PySys_WriteStderr("# cleanup __main__\n");
448
_PyModule_Clear(value);
449
PyDict_SetItemString(modules, "__main__", Py_None);
452
/* The special treatment of "builtins" here is because even
453
when it's not referenced as a module, its dictionary is
454
referenced by almost every module's __builtins__. Since
455
deleting a module clears its dictionary (even if there are
456
references left to it), we need to delete the "builtins"
457
module last. Likewise, we don't delete sys until the very
458
end because it is implicitly referenced (e.g. by print).
460
Also note that we 'delete' modules by replacing their entry
461
in the modules dict with None, rather than really deleting
462
them; this avoids a rehash of the modules dictionary and
463
also marks them as "non existent" so they won't be
466
/* Next, repeatedly delete modules with a reference count of
467
one (skipping builtins and sys) and delete them */
471
while (PyDict_Next(modules, &pos, &key, &value)) {
472
if (value->ob_refcnt != 1)
474
if (PyUnicode_Check(key) && PyModule_Check(value)) {
475
name = _PyUnicode_AsString(key);
476
if (strcmp(name, "builtins") == 0)
478
if (strcmp(name, "sys") == 0)
482
"# cleanup[1] %s\n", name);
483
_PyModule_Clear(value);
484
PyDict_SetItem(modules, key, Py_None);
490
/* Next, delete all modules (still skipping builtins and sys) */
492
while (PyDict_Next(modules, &pos, &key, &value)) {
493
if (PyUnicode_Check(key) && PyModule_Check(value)) {
494
name = _PyUnicode_AsString(key);
495
if (strcmp(name, "builtins") == 0)
497
if (strcmp(name, "sys") == 0)
500
PySys_WriteStderr("# cleanup[2] %s\n", name);
501
_PyModule_Clear(value);
502
PyDict_SetItem(modules, key, Py_None);
506
/* Next, delete sys and builtins (in that order) */
507
value = PyDict_GetItemString(modules, "sys");
508
if (value != NULL && PyModule_Check(value)) {
510
PySys_WriteStderr("# cleanup sys\n");
511
_PyModule_Clear(value);
512
PyDict_SetItemString(modules, "sys", Py_None);
514
value = PyDict_GetItemString(modules, "builtins");
515
if (value != NULL && PyModule_Check(value)) {
517
PySys_WriteStderr("# cleanup builtins\n");
518
_PyModule_Clear(value);
519
PyDict_SetItemString(modules, "builtins", Py_None);
522
/* Finally, clear and delete the modules directory */
523
PyDict_Clear(modules);
524
interp->modules = NULL;
526
Py_CLEAR(interp->modules_reloading);
530
/* Helper for pythonrun.c -- return magic number */
533
PyImport_GetMagicNumber(void)
539
/* Magic for extension modules (built-in as well as dynamically
540
loaded). To prevent initializing an extension module more than
541
once, we keep a static dictionary 'extensions' keyed by module name
542
(for built-in modules) or by filename (for dynamically loaded
543
modules), containing these modules. A copy of the module's
544
dictionary is stored by calling _PyImport_FixupExtension()
545
immediately after the module initialization function succeeds. A
546
copy can be retrieved from there by calling
547
_PyImport_FindExtension().
549
Modules which do support multiple multiple initialization set
550
their m_size field to a non-negative number (indicating the size
551
of the module-specific state). They are still recorded in the
552
extensions dictionary, to avoid loading shared libraries twice.
556
_PyImport_FixupExtension(PyObject *mod, char *name, char *filename)
558
PyObject *modules, *dict;
559
struct PyModuleDef *def;
560
if (extensions == NULL) {
561
extensions = PyDict_New();
562
if (extensions == NULL)
565
if (mod == NULL || !PyModule_Check(mod)) {
566
PyErr_BadInternalCall();
569
def = PyModule_GetDef(mod);
571
PyErr_BadInternalCall();
574
modules = PyImport_GetModuleDict();
575
if (PyDict_SetItemString(modules, name, mod) < 0)
577
if (_PyState_AddModule(mod, def) < 0) {
578
PyDict_DelItemString(modules, name);
581
if (def->m_size == -1) {
582
if (def->m_base.m_copy) {
583
/* Somebody already imported the module,
584
likely under a different name.
585
XXX this should really not happen. */
586
Py_DECREF(def->m_base.m_copy);
587
def->m_base.m_copy = NULL;
589
dict = PyModule_GetDict(mod);
592
def->m_base.m_copy = PyDict_Copy(dict);
593
if (def->m_base.m_copy == NULL)
596
PyDict_SetItemString(extensions, filename, (PyObject*)def);
601
_PyImport_FindExtension(char *name, char *filename)
603
PyObject *mod, *mdict;
605
if (extensions == NULL)
607
def = (PyModuleDef*)PyDict_GetItemString(extensions, filename);
610
if (def->m_size == -1) {
611
/* Module does not support repeated initialization */
612
if (def->m_base.m_copy == NULL)
614
mod = PyImport_AddModule(name);
617
mdict = PyModule_GetDict(mod);
620
if (PyDict_Update(mdict, def->m_base.m_copy))
624
if (def->m_base.m_init == NULL)
626
mod = def->m_base.m_init();
629
PyDict_SetItemString(PyImport_GetModuleDict(), name, mod);
632
if (_PyState_AddModule(mod, def) < 0) {
633
PyDict_DelItemString(PyImport_GetModuleDict(), name);
638
PySys_WriteStderr("import %s # previously loaded (%s)\n",
645
/* Get the module object corresponding to a module name.
646
First check the modules dictionary if there's one there,
647
if not, create a new one and insert it in the modules dictionary.
648
Because the former action is most common, THIS DOES NOT RETURN A
652
PyImport_AddModule(const char *name)
654
PyObject *modules = PyImport_GetModuleDict();
657
if ((m = PyDict_GetItemString(modules, name)) != NULL &&
660
m = PyModule_New(name);
663
if (PyDict_SetItemString(modules, name, m) != 0) {
667
Py_DECREF(m); /* Yes, it still exists, in modules! */
672
/* Remove name from sys.modules, if it's there. */
674
_RemoveModule(const char *name)
676
PyObject *modules = PyImport_GetModuleDict();
677
if (PyDict_GetItemString(modules, name) == NULL)
679
if (PyDict_DelItemString(modules, name) < 0)
680
Py_FatalError("import: deleting existing key in"
681
"sys.modules failed");
684
static PyObject * get_sourcefile(const char *file);
686
/* Execute a code object in a module and return the module object
687
* WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
688
* removed from sys.modules, to avoid leaving damaged module objects
689
* in sys.modules. The caller may wish to restore the original
690
* module object (if any) in this case; PyImport_ReloadModule is an
694
PyImport_ExecCodeModule(char *name, PyObject *co)
696
return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
700
PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
702
PyObject *modules = PyImport_GetModuleDict();
705
m = PyImport_AddModule(name);
708
/* If the module is being reloaded, we get the old module back
709
and re-use its dict to exec the new code. */
710
d = PyModule_GetDict(m);
711
if (PyDict_GetItemString(d, "__builtins__") == NULL) {
712
if (PyDict_SetItemString(d, "__builtins__",
713
PyEval_GetBuiltins()) != 0)
716
/* Remember the filename as the __file__ attribute */
718
if (pathname != NULL) {
719
v = get_sourcefile(pathname);
724
v = ((PyCodeObject *)co)->co_filename;
727
if (PyDict_SetItemString(d, "__file__", v) != 0)
728
PyErr_Clear(); /* Not important enough to report */
731
v = PyEval_EvalCode((PyCodeObject *)co, d, d);
736
if ((m = PyDict_GetItemString(modules, name)) == NULL) {
737
PyErr_Format(PyExc_ImportError,
738
"Loaded module %.200s not found in sys.modules",
753
/* Given a pathname for a Python source file, fill a buffer with the
754
pathname for the corresponding compiled file. Return the pathname
755
for the compiled file, or NULL if there's no space in the buffer.
756
Doesn't set an exception. */
759
make_compiled_pathname(char *pathname, char *buf, size_t buflen)
761
size_t len = strlen(pathname);
766
/* Treat .pyw as if it were .py. The case of ".pyw" must match
767
that used in _PyImport_StandardFiletab. */
768
if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
769
--len; /* pretend 'w' isn't there */
771
memcpy(buf, pathname, len);
772
buf[len] = Py_OptimizeFlag ? 'o' : 'c';
779
/* Given a pathname for a Python source file, its time of last
780
modification, and a pathname for a compiled file, check whether the
781
compiled file represents the same version of the source. If so,
782
return a FILE pointer for the compiled file, positioned just after
783
the header; if not, return NULL.
784
Doesn't set an exception. */
787
check_compiled_module(char *pathname, time_t mtime, char *cpathname)
793
fp = fopen(cpathname, "rb");
796
magic = PyMarshal_ReadLongFromFile(fp);
797
if (magic != pyc_magic) {
799
PySys_WriteStderr("# %s has bad magic\n", cpathname);
803
pyc_mtime = PyMarshal_ReadLongFromFile(fp);
804
if (pyc_mtime != mtime) {
806
PySys_WriteStderr("# %s has bad mtime\n", cpathname);
811
PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
816
/* Read a code object from a file and check it for validity */
818
static PyCodeObject *
819
read_compiled_module(char *cpathname, FILE *fp)
823
co = PyMarshal_ReadLastObjectFromFile(fp);
826
if (!PyCode_Check(co)) {
827
PyErr_Format(PyExc_ImportError,
828
"Non-code object in %.200s", cpathname);
832
return (PyCodeObject *)co;
836
/* Load a module from a compiled file, execute it, and return its
837
module object WITH INCREMENTED REFERENCE COUNT */
840
load_compiled_module(char *name, char *cpathname, FILE *fp)
846
magic = PyMarshal_ReadLongFromFile(fp);
847
if (magic != pyc_magic) {
848
PyErr_Format(PyExc_ImportError,
849
"Bad magic number in %.200s", cpathname);
852
(void) PyMarshal_ReadLongFromFile(fp);
853
co = read_compiled_module(cpathname, fp);
857
PySys_WriteStderr("import %s # precompiled from %s\n",
859
m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
865
/* Parse a source file and return the corresponding code object */
867
static PyCodeObject *
868
parse_source_module(const char *pathname, FILE *fp)
870
PyCodeObject *co = NULL;
872
PyCompilerFlags flags;
873
PyArena *arena = PyArena_New();
878
mod = PyParser_ASTFromFile(fp, pathname, NULL,
879
Py_file_input, 0, 0, &flags,
882
co = PyAST_Compile(mod, pathname, NULL, arena);
889
/* Helper to open a bytecode file for writing in exclusive mode */
892
open_exclusive(char *filename, mode_t mode)
894
#if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
895
/* Use O_EXCL to avoid a race condition when another process tries to
896
write the same file. When that happens, our open() call fails,
897
which is just fine (since it's only a cache).
898
XXX If the file exists and is writable but the directory is not
899
writable, the file will never be written. Oh well.
902
(void) unlink(filename);
903
fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
905
|O_BINARY /* necessary for Windows */
908
, mode, "ctxt=bin", "shr=nil"
915
return fdopen(fd, "wb");
917
/* Best we can do -- on Windows this can't happen anyway */
918
return fopen(filename, "wb");
923
/* Write a compiled module to a file, placing the time of last
924
modification of its source into the header.
925
Errors are ignored, if a write error occurs an attempt is made to
929
write_compiled_module(PyCodeObject *co, char *cpathname, struct stat *srcstat)
932
time_t mtime = srcstat->st_mtime;
933
mode_t mode = srcstat->st_mode;
935
fp = open_exclusive(cpathname, mode);
939
"# can't create %s\n", cpathname);
942
PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
943
/* First write a 0 for mtime */
944
PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
945
PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
946
if (fflush(fp) != 0 || ferror(fp)) {
948
PySys_WriteStderr("# can't write %s\n", cpathname);
949
/* Don't keep partial file */
951
(void) unlink(cpathname);
954
/* Now write the true mtime */
956
assert(mtime < LONG_MAX);
957
PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
961
PySys_WriteStderr("# wrote %s\n", cpathname);
965
update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
967
PyObject *constants, *tmp;
970
if (PyUnicode_Compare(co->co_filename, oldname))
973
tmp = co->co_filename;
974
co->co_filename = newname;
975
Py_INCREF(co->co_filename);
978
constants = co->co_consts;
979
n = PyTuple_GET_SIZE(constants);
980
for (i = 0; i < n; i++) {
981
tmp = PyTuple_GET_ITEM(constants, i);
982
if (PyCode_Check(tmp))
983
update_code_filenames((PyCodeObject *)tmp,
989
update_compiled_module(PyCodeObject *co, char *pathname)
991
PyObject *oldname, *newname;
993
newname = PyUnicode_DecodeFSDefault(pathname);
997
if (!PyUnicode_Compare(co->co_filename, newname)) {
1002
oldname = co->co_filename;
1004
update_code_filenames(co, oldname, newname);
1010
/* Load a source module from a given file and return its module
1011
object WITH INCREMENTED REFERENCE COUNT. If there's a matching
1012
byte-compiled file, use that instead. */
1015
load_source_module(char *name, char *pathname, FILE *fp)
1019
char buf[MAXPATHLEN+1];
1024
if (fstat(fileno(fp), &st) != 0) {
1025
PyErr_Format(PyExc_RuntimeError,
1026
"unable to get file status from '%s'",
1030
#if SIZEOF_TIME_T > 4
1031
/* Python's .pyc timestamp handling presumes that the timestamp fits
1032
in 4 bytes. This will be fine until sometime in the year 2038,
1033
when a 4-byte signed time_t will overflow.
1035
if (st.st_mtime >> 32) {
1036
PyErr_SetString(PyExc_OverflowError,
1037
"modification time overflows a 4 byte field");
1041
cpathname = make_compiled_pathname(pathname, buf,
1042
(size_t)MAXPATHLEN + 1);
1043
if (cpathname != NULL &&
1044
(fpc = check_compiled_module(pathname, st.st_mtime, cpathname))) {
1045
co = read_compiled_module(cpathname, fpc);
1049
if (update_compiled_module(co, pathname) < 0)
1052
PySys_WriteStderr("import %s # precompiled from %s\n",
1054
pathname = cpathname;
1057
co = parse_source_module(pathname, fp);
1061
PySys_WriteStderr("import %s # from %s\n",
1064
PyObject *ro = PySys_GetObject("dont_write_bytecode");
1065
if (ro == NULL || !PyObject_IsTrue(ro))
1066
write_compiled_module(co, cpathname, &st);
1069
m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
1075
/* Get source file -> unicode or None
1076
* Returns the path to the py file if available, else the given path
1079
get_sourcefile(const char *file)
1081
char py[MAXPATHLEN + 1];
1084
struct stat statbuf;
1086
if (!file || !*file) {
1092
if (len > MAXPATHLEN || PyOS_strnicmp(&file[len-4], ".py", 3) != 0) {
1093
return PyUnicode_DecodeFSDefault(file);
1096
strncpy(py, file, len-1);
1098
if (stat(py, &statbuf) == 0 &&
1099
S_ISREG(statbuf.st_mode)) {
1100
u = PyUnicode_DecodeFSDefault(py);
1103
u = PyUnicode_DecodeFSDefault(file);
1109
static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
1110
static struct filedescr *find_module(char *, char *, PyObject *,
1111
char *, size_t, FILE **, PyObject **);
1112
static struct _frozen * find_frozen(char *);
1114
/* Load a package and return its module object WITH INCREMENTED
1118
load_package(char *name, char *pathname)
1121
PyObject *file = NULL;
1122
PyObject *path = NULL;
1124
char buf[MAXPATHLEN+1];
1126
struct filedescr *fdp;
1128
m = PyImport_AddModule(name);
1132
PySys_WriteStderr("import %s # directory %s\n",
1134
d = PyModule_GetDict(m);
1135
file = get_sourcefile(pathname);
1138
path = Py_BuildValue("[O]", file);
1141
err = PyDict_SetItemString(d, "__file__", file);
1143
err = PyDict_SetItemString(d, "__path__", path);
1147
fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
1149
if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1157
m = load_module(name, fp, buf, fdp->type, NULL);
1171
/* Helper to test for built-in module */
1174
is_builtin(char *name)
1177
for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1178
if (strcmp(name, PyImport_Inittab[i].name) == 0) {
1179
if (PyImport_Inittab[i].initfunc == NULL)
1189
/* Return an importer object for a sys.path/pkg.__path__ item 'p',
1190
possibly by fetching it from the path_importer_cache dict. If it
1191
wasn't yet cached, traverse path_hooks until a hook is found
1192
that can handle the path item. Return None if no hook could;
1193
this tells our caller it should fall back to the builtin
1194
import mechanism. Cache the result in path_importer_cache.
1195
Returns a borrowed reference. */
1198
get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
1202
Py_ssize_t j, nhooks;
1204
/* These conditions are the caller's responsibility: */
1205
assert(PyList_Check(path_hooks));
1206
assert(PyDict_Check(path_importer_cache));
1208
nhooks = PyList_Size(path_hooks);
1210
return NULL; /* Shouldn't happen */
1212
importer = PyDict_GetItem(path_importer_cache, p);
1213
if (importer != NULL)
1216
/* set path_importer_cache[p] to None to avoid recursion */
1217
if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1220
for (j = 0; j < nhooks; j++) {
1221
PyObject *hook = PyList_GetItem(path_hooks, j);
1224
importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
1225
if (importer != NULL)
1228
if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1233
if (importer == NULL) {
1234
importer = PyObject_CallFunctionObjArgs(
1235
(PyObject *)&PyNullImporter_Type, p, NULL
1237
if (importer == NULL) {
1238
if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1244
if (importer != NULL) {
1245
int err = PyDict_SetItem(path_importer_cache, p, importer);
1246
Py_DECREF(importer);
1253
PyAPI_FUNC(PyObject *)
1254
PyImport_GetImporter(PyObject *path) {
1255
PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
1257
if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {
1258
if ((path_hooks = PySys_GetObject("path_hooks"))) {
1259
importer = get_path_importer(path_importer_cache,
1263
Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
1267
/* Search the path (default sys.path) for a module. Return the
1268
corresponding filedescr struct, and (via return arguments) the
1269
pathname and an open file. Return NULL if the module is not found. */
1272
extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
1273
char *, Py_ssize_t);
1276
static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
1277
static int find_init_module(char *); /* Forward */
1278
static struct filedescr importhookdescr = {"", "", IMP_HOOK};
1280
static struct filedescr *
1281
find_module(char *fullname, char *subname, PyObject *path, char *buf,
1282
size_t buflen, FILE **p_fp, PyObject **p_loader)
1284
Py_ssize_t i, npath;
1285
size_t len, namelen;
1286
struct filedescr *fdp = NULL;
1289
PyObject *path_hooks, *path_importer_cache;
1290
struct stat statbuf;
1291
static struct filedescr fd_frozen = {"", "", PY_FROZEN};
1292
static struct filedescr fd_builtin = {"", "", C_BUILTIN};
1293
static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
1294
char name[MAXPATHLEN+1];
1295
#if defined(PYOS_OS2)
1297
size_t saved_namelen;
1298
char *saved_buf = NULL;
1300
if (p_loader != NULL)
1303
if (strlen(subname) > MAXPATHLEN) {
1304
PyErr_SetString(PyExc_OverflowError,
1305
"module name is too long");
1308
strcpy(name, subname);
1310
/* sys.meta_path import hook */
1311
if (p_loader != NULL) {
1312
PyObject *meta_path;
1314
meta_path = PySys_GetObject("meta_path");
1315
if (meta_path == NULL || !PyList_Check(meta_path)) {
1316
PyErr_SetString(PyExc_ImportError,
1317
"sys.meta_path must be a list of "
1321
Py_INCREF(meta_path); /* zap guard */
1322
npath = PyList_Size(meta_path);
1323
for (i = 0; i < npath; i++) {
1325
PyObject *hook = PyList_GetItem(meta_path, i);
1326
loader = PyObject_CallMethod(hook, "find_module",
1330
if (loader == NULL) {
1331
Py_DECREF(meta_path);
1332
return NULL; /* true error */
1334
if (loader != Py_None) {
1335
/* a loader was found */
1337
Py_DECREF(meta_path);
1338
return &importhookdescr;
1342
Py_DECREF(meta_path);
1345
if (find_frozen(fullname) != NULL) {
1346
strcpy(buf, fullname);
1351
if (is_builtin(name)) {
1356
fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
1362
path = PySys_GetObject("path");
1365
if (path == NULL || !PyList_Check(path)) {
1366
PyErr_SetString(PyExc_ImportError,
1367
"sys.path must be a list of directory names");
1371
path_hooks = PySys_GetObject("path_hooks");
1372
if (path_hooks == NULL || !PyList_Check(path_hooks)) {
1373
PyErr_SetString(PyExc_ImportError,
1374
"sys.path_hooks must be a list of "
1378
path_importer_cache = PySys_GetObject("path_importer_cache");
1379
if (path_importer_cache == NULL ||
1380
!PyDict_Check(path_importer_cache)) {
1381
PyErr_SetString(PyExc_ImportError,
1382
"sys.path_importer_cache must be a dict");
1386
npath = PyList_Size(path);
1387
namelen = strlen(name);
1388
for (i = 0; i < npath; i++) {
1389
PyObject *v = PyList_GetItem(path, i);
1390
PyObject *origv = v;
1395
if (PyUnicode_Check(v)) {
1396
v = PyUnicode_AsEncodedString(v,
1397
Py_FileSystemDefaultEncoding, NULL);
1401
else if (!PyBytes_Check(v))
1406
base = PyBytes_AS_STRING(v);
1407
size = PyBytes_GET_SIZE(v);
1409
if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
1411
continue; /* Too long */
1416
if (strlen(buf) != len) {
1417
continue; /* v contains '\0' */
1420
/* sys.path_hooks import hook */
1421
if (p_loader != NULL) {
1424
importer = get_path_importer(path_importer_cache,
1426
if (importer == NULL) {
1429
/* Note: importer is a borrowed reference */
1430
if (importer != Py_None) {
1432
loader = PyObject_CallMethod(importer,
1436
return NULL; /* error */
1437
if (loader != Py_None) {
1438
/* a loader was found */
1440
return &importhookdescr;
1446
/* no hook was found, use builtin import */
1448
if (len > 0 && buf[len-1] != SEP
1450
&& buf[len-1] != ALTSEP
1454
strcpy(buf+len, name);
1457
/* Check for package import (buf holds a directory name,
1458
and there's an __init__ module in that directory */
1460
if (stat(buf, &statbuf) == 0 && /* it exists */
1461
S_ISDIR(statbuf.st_mode) && /* it's a directory */
1462
case_ok(buf, len, namelen, name)) { /* case matches */
1463
if (find_init_module(buf)) { /* and has __init__.py */
1467
char warnstr[MAXPATHLEN+80];
1468
sprintf(warnstr, "Not importing directory "
1469
"'%.*s': missing __init__.py",
1471
if (PyErr_WarnEx(PyExc_ImportWarning,
1478
#if defined(PYOS_OS2)
1479
/* take a snapshot of the module spec for restoration
1480
* after the 8 character DLL hackery
1482
saved_buf = strdup(buf);
1484
saved_namelen = namelen;
1485
#endif /* PYOS_OS2 */
1486
for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
1487
#if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
1488
/* OS/2 limits DLLs to 8 character names (w/o
1490
* so if the name is longer than that and its a
1491
* dynamically loaded module we're going to try,
1492
* truncate the name before trying
1494
if (strlen(subname) > 8) {
1495
/* is this an attempt to load a C extension? */
1496
const struct filedescr *scan;
1497
scan = _PyImport_DynLoadFiletab;
1498
while (scan->suffix != NULL) {
1499
if (!strcmp(scan->suffix, fdp->suffix))
1504
if (scan->suffix != NULL) {
1505
/* yes, so truncate the name */
1507
len -= strlen(subname) - namelen;
1511
#endif /* PYOS_OS2 */
1512
strcpy(buf+len, fdp->suffix);
1513
if (Py_VerboseFlag > 1)
1514
PySys_WriteStderr("# trying %s\n", buf);
1515
filemode = fdp->mode;
1516
if (filemode[0] == 'U')
1517
filemode = "r" PY_STDIOTEXTMODE;
1518
fp = fopen(buf, filemode);
1520
if (case_ok(buf, len, namelen, name))
1522
else { /* continue search */
1527
#if defined(PYOS_OS2)
1528
/* restore the saved snapshot */
1529
strcpy(buf, saved_buf);
1531
namelen = saved_namelen;
1534
#if defined(PYOS_OS2)
1535
/* don't need/want the module name snapshot anymore */
1546
PyErr_Format(PyExc_ImportError,
1547
"No module named %.200s", name);
1554
/* Helpers for main.c
1555
* Find the source file corresponding to a named module
1558
_PyImport_FindModule(const char *name, PyObject *path, char *buf,
1559
size_t buflen, FILE **p_fp, PyObject **p_loader)
1561
return find_module((char *) name, (char *) name, path,
1562
buf, buflen, p_fp, p_loader);
1565
PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)
1567
return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
1570
/* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
1571
* The arguments here are tricky, best shown by example:
1572
* /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1574
* |--------------------- buf ---------------------|
1575
* |------------------- len ------------------|
1576
* |------ name -------|
1577
* |----- namelen -----|
1578
* buf is the full path, but len only counts up to (& exclusive of) the
1579
* extension. name is the module name, also exclusive of extension.
1581
* We've already done a successful stat() or fopen() on buf, so know that
1582
* there's some match, possibly case-insensitive.
1584
* case_ok() is to return 1 if there's a case-sensitive match for
1585
* name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1588
* case_ok() is used to implement case-sensitive import semantics even
1589
* on platforms with case-insensitive filesystems. It's trivial to implement
1590
* for case-sensitive filesystems. It's pretty much a cross-platform
1591
* nightmare for systems with case-insensitive filesystems.
1594
/* First we may need a pile of platform-specific header files; the sequence
1595
* of #if's here should match the sequence in the body of case_ok().
1597
#if defined(MS_WINDOWS)
1598
#include <windows.h>
1600
#elif defined(DJGPP)
1603
#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1604
#include <sys/types.h>
1607
#elif defined(PYOS_OS2)
1609
#define INCL_DOSERRORS
1610
#define INCL_NOPMAPI
1615
case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
1617
/* Pick a platform-specific implementation; the sequence of #if's here should
1618
* match the sequence just above.
1622
#if defined(MS_WINDOWS)
1623
WIN32_FIND_DATA data;
1626
if (Py_GETENV("PYTHONCASEOK") != NULL)
1629
h = FindFirstFile(buf, &data);
1630
if (h == INVALID_HANDLE_VALUE) {
1631
PyErr_Format(PyExc_NameError,
1632
"Can't find file for module %.100s\n(filename %.300s)",
1637
return strncmp(data.cFileName, name, namelen) == 0;
1640
#elif defined(DJGPP)
1644
if (Py_GETENV("PYTHONCASEOK") != NULL)
1647
done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1649
PyErr_Format(PyExc_NameError,
1650
"Can't find file for module %.100s\n(filename %.300s)",
1654
return strncmp(ffblk.ff_name, name, namelen) == 0;
1656
/* new-fangled macintosh (macosx) or Cygwin */
1657
#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1660
char dirname[MAXPATHLEN + 1];
1661
const int dirlen = len - namelen - 1; /* don't want trailing SEP */
1663
if (Py_GETENV("PYTHONCASEOK") != NULL)
1666
/* Copy the dir component into dirname; substitute "." if empty */
1672
assert(dirlen <= MAXPATHLEN);
1673
memcpy(dirname, buf, dirlen);
1674
dirname[dirlen] = '\0';
1676
/* Open the directory and search the entries for an exact match. */
1677
dirp = opendir(dirname);
1679
char *nameWithExt = buf + len - namelen;
1680
while ((dp = readdir(dirp)) != NULL) {
1682
#ifdef _DIRENT_HAVE_D_NAMELEN
1687
if (thislen >= namelen &&
1688
strcmp(dp->d_name, nameWithExt) == 0) {
1689
(void)closedir(dirp);
1690
return 1; /* Found */
1693
(void)closedir(dirp);
1695
return 0 ; /* Not found */
1698
#elif defined(PYOS_OS2)
1704
if (Py_GETENV("PYTHONCASEOK") != NULL)
1707
rc = DosFindFirst(buf,
1709
FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1710
&ffbuf, sizeof(ffbuf),
1715
return strncmp(ffbuf.achName, name, namelen) == 0;
1717
/* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1726
/* Helper to look for __init__.py or __init__.py[co] in potential package */
1728
find_init_module(char *buf)
1730
const size_t save_len = strlen(buf);
1731
size_t i = save_len;
1732
char *pname; /* pointer to start of __init__ */
1733
struct stat statbuf;
1735
/* For calling case_ok(buf, len, namelen, name):
1736
* /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1738
* |--------------------- buf ---------------------|
1739
* |------------------- len ------------------|
1740
* |------ name -------|
1741
* |----- namelen -----|
1743
if (save_len + 13 >= MAXPATHLEN)
1747
strcpy(pname, "__init__.py");
1748
if (stat(buf, &statbuf) == 0) {
1750
save_len + 9, /* len("/__init__") */
1751
8, /* len("__init__") */
1753
buf[save_len] = '\0';
1758
strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
1759
if (stat(buf, &statbuf) == 0) {
1761
save_len + 9, /* len("/__init__") */
1762
8, /* len("__init__") */
1764
buf[save_len] = '\0';
1768
buf[save_len] = '\0';
1772
#endif /* HAVE_STAT */
1775
static int init_builtin(char *); /* Forward */
1777
/* Load an external module using the default search path and return
1778
its module object WITH INCREMENTED REFERENCE COUNT */
1781
load_module(char *name, FILE *fp, char *buf, int type, PyObject *loader)
1787
/* First check that there's an open file (if we need one) */
1792
PyErr_Format(PyExc_ValueError,
1793
"file object required for import (type code %d)",
1802
m = load_source_module(name, buf, fp);
1806
m = load_compiled_module(name, buf, fp);
1809
#ifdef HAVE_DYNAMIC_LOADING
1811
m = _PyImport_LoadDynamicModule(name, buf, fp);
1816
m = load_package(name, buf);
1821
if (buf != NULL && buf[0] != '\0')
1823
if (type == C_BUILTIN)
1824
err = init_builtin(name);
1826
err = PyImport_ImportFrozenModule(name);
1830
PyErr_Format(PyExc_ImportError,
1831
"Purported %s module %.200s not found",
1833
"builtin" : "frozen",
1837
modules = PyImport_GetModuleDict();
1838
m = PyDict_GetItemString(modules, name);
1842
"%s module %.200s not properly initialized",
1844
"builtin" : "frozen",
1852
if (loader == NULL) {
1853
PyErr_SetString(PyExc_ImportError,
1854
"import hook without loader");
1857
m = PyObject_CallMethod(loader, "load_module", "s", name);
1862
PyErr_Format(PyExc_ImportError,
1863
"Don't know how to import %.200s (type code %d)",
1873
/* Initialize a built-in module.
1874
Return 1 for success, 0 if the module is not found, and -1 with
1875
an exception set if the initialization failed. */
1878
init_builtin(char *name)
1882
if (_PyImport_FindExtension(name, name) != NULL)
1885
for (p = PyImport_Inittab; p->name != NULL; p++) {
1887
if (strcmp(name, p->name) == 0) {
1888
if (p->initfunc == NULL) {
1889
PyErr_Format(PyExc_ImportError,
1890
"Cannot re-init internal module %.200s",
1895
PySys_WriteStderr("import %s # builtin\n", name);
1896
mod = (*p->initfunc)();
1899
if (_PyImport_FixupExtension(mod, name, name) < 0)
1901
/* FixupExtension has put the module into sys.modules,
1902
so we can release our own reference. */
1911
/* Frozen modules */
1913
static struct _frozen *
1914
find_frozen(char *name)
1921
for (p = PyImport_FrozenModules; ; p++) {
1922
if (p->name == NULL)
1924
if (strcmp(p->name, name) == 0)
1931
get_frozen_object(char *name)
1933
struct _frozen *p = find_frozen(name);
1937
PyErr_Format(PyExc_ImportError,
1938
"No such frozen object named %.200s",
1942
if (p->code == NULL) {
1943
PyErr_Format(PyExc_ImportError,
1944
"Excluded frozen object named %.200s",
1951
return PyMarshal_ReadObjectFromString((char *)p->code, size);
1955
is_frozen_package(char *name)
1957
struct _frozen *p = find_frozen(name);
1961
PyErr_Format(PyExc_ImportError,
1962
"No such frozen object named %.200s",
1976
/* Initialize a frozen module.
1977
Return 1 for success, 0 if the module is not found, and -1 with
1978
an exception set if the initialization failed.
1979
This function is also used from frozenmain.c */
1982
PyImport_ImportFrozenModule(char *name)
1984
struct _frozen *p = find_frozen(name);
1992
if (p->code == NULL) {
1993
PyErr_Format(PyExc_ImportError,
1994
"Excluded frozen object named %.200s",
1999
ispackage = (size < 0);
2003
PySys_WriteStderr("import %s # frozen%s\n",
2004
name, ispackage ? " package" : "");
2005
co = PyMarshal_ReadObjectFromString((char *)p->code, size);
2008
if (!PyCode_Check(co)) {
2009
PyErr_Format(PyExc_TypeError,
2010
"frozen object %.200s is not a code object",
2015
/* Set __path__ to the package name */
2016
PyObject *d, *s, *l;
2018
m = PyImport_AddModule(name);
2021
d = PyModule_GetDict(m);
2022
s = PyUnicode_InternFromString(name);
2030
PyList_SET_ITEM(l, 0, s);
2031
err = PyDict_SetItemString(d, "__path__", l);
2036
m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
2048
/* Import a module, either built-in, frozen, or external, and return
2049
its module object WITH INCREMENTED REFERENCE COUNT */
2052
PyImport_ImportModule(const char *name)
2057
pname = PyUnicode_FromString(name);
2060
result = PyImport_Import(pname);
2065
/* Import a module without blocking
2067
* At first it tries to fetch the module from sys.modules. If the module was
2068
* never loaded before it loads it with PyImport_ImportModule() unless another
2069
* thread holds the import lock. In the latter case the function raises an
2070
* ImportError instead of blocking.
2072
* Returns the module object with incremented ref count.
2075
PyImport_ImportModuleNoBlock(const char *name)
2081
/* Try to get the module from sys.modules[name] */
2082
modules = PyImport_GetModuleDict();
2083
if (modules == NULL)
2086
result = PyDict_GetItemString(modules, name);
2087
if (result != NULL) {
2095
/* check the import lock
2096
* me might be -1 but I ignore the error here, the lock function
2097
* takes care of the problem */
2098
me = PyThread_get_thread_ident();
2099
if (import_lock_thread == -1 || import_lock_thread == me) {
2100
/* no thread or me is holding the lock */
2101
return PyImport_ImportModule(name);
2104
PyErr_Format(PyExc_ImportError,
2105
"Failed to import %.200s because the import lock"
2106
"is held by another thread.",
2111
return PyImport_ImportModule(name);
2115
/* Forward declarations for helper routines */
2116
static PyObject *get_parent(PyObject *globals, char *buf,
2117
Py_ssize_t *p_buflen, int level);
2118
static PyObject *load_next(PyObject *mod, PyObject *altmod,
2119
char **p_name, char *buf, Py_ssize_t *p_buflen);
2120
static int mark_miss(char *name);
2121
static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
2122
char *buf, Py_ssize_t buflen, int recursive);
2123
static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
2125
/* The Magnum Opus of dotted-name import :-) */
2128
import_module_level(char *name, PyObject *globals, PyObject *locals,
2129
PyObject *fromlist, int level)
2131
char buf[MAXPATHLEN+1];
2132
Py_ssize_t buflen = 0;
2133
PyObject *parent, *head, *next, *tail;
2135
if (strchr(name, '/') != NULL
2137
|| strchr(name, '\\') != NULL
2140
PyErr_SetString(PyExc_ImportError,
2141
"Import by filename is not supported.");
2145
parent = get_parent(globals, buf, &buflen, level);
2149
head = load_next(parent, Py_None, &name, buf, &buflen);
2156
next = load_next(tail, tail, &name, buf, &buflen);
2164
if (tail == Py_None) {
2165
/* If tail is Py_None, both get_parent and load_next found
2166
an empty module name: someone called __import__("") or
2167
doctored faulty bytecode */
2170
PyErr_SetString(PyExc_ValueError,
2171
"Empty module name");
2175
if (fromlist != NULL) {
2176
if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
2180
if (fromlist == NULL) {
2186
if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
2195
PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
2196
PyObject *fromlist, int level)
2200
result = import_module_level(name, globals, locals, fromlist, level);
2201
if (unlock_import() < 0) {
2203
PyErr_SetString(PyExc_RuntimeError,
2204
"not holding the import lock");
2210
/* Return the package that an import is being performed in. If globals comes
2211
from the module foo.bar.bat (not itself a package), this returns the
2212
sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2213
the package's entry in sys.modules is returned, as a borrowed reference.
2215
The *name* of the returned package is returned in buf, with the length of
2216
the name in *p_buflen.
2218
If globals doesn't come from a package or a module in a package, or a
2219
corresponding entry is not found in sys.modules, Py_None is returned.
2222
get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
2224
static PyObject *namestr = NULL;
2225
static PyObject *pathstr = NULL;
2226
static PyObject *pkgstr = NULL;
2227
PyObject *pkgname, *modname, *modpath, *modules, *parent;
2228
int orig_level = level;
2230
if (globals == NULL || !PyDict_Check(globals) || !level)
2233
if (namestr == NULL) {
2234
namestr = PyUnicode_InternFromString("__name__");
2235
if (namestr == NULL)
2238
if (pathstr == NULL) {
2239
pathstr = PyUnicode_InternFromString("__path__");
2240
if (pathstr == NULL)
2243
if (pkgstr == NULL) {
2244
pkgstr = PyUnicode_InternFromString("__package__");
2251
pkgname = PyDict_GetItem(globals, pkgstr);
2253
if ((pkgname != NULL) && (pkgname != Py_None)) {
2254
/* __package__ is set, so use it */
2258
if (!PyUnicode_Check(pkgname)) {
2259
PyErr_SetString(PyExc_ValueError,
2260
"__package__ set to non-string");
2263
pkgname_str = _PyUnicode_AsStringAndSize(pkgname, &len);
2266
PyErr_SetString(PyExc_ValueError,
2267
"Attempted relative import in non-package");
2272
if (len > MAXPATHLEN) {
2273
PyErr_SetString(PyExc_ValueError,
2274
"Package name too long");
2277
strcpy(buf, pkgname_str);
2279
/* __package__ not set, so figure it out and set it */
2280
modname = PyDict_GetItem(globals, namestr);
2281
if (modname == NULL || !PyUnicode_Check(modname))
2284
modpath = PyDict_GetItem(globals, pathstr);
2285
if (modpath != NULL) {
2286
/* __path__ is set, so modname is already the package name */
2291
modname_str = _PyUnicode_AsStringAndSize(modname, &len);
2292
if (len > MAXPATHLEN) {
2293
PyErr_SetString(PyExc_ValueError,
2294
"Module name too long");
2297
strcpy(buf, modname_str);
2298
error = PyDict_SetItem(globals, pkgstr, modname);
2300
PyErr_SetString(PyExc_ValueError,
2301
"Could not set __package__");
2305
/* Normal module, so work out the package name if any */
2306
char *start = _PyUnicode_AsString(modname);
2307
char *lastdot = strrchr(start, '.');
2310
if (lastdot == NULL && level > 0) {
2311
PyErr_SetString(PyExc_ValueError,
2312
"Attempted relative import in non-package");
2315
if (lastdot == NULL) {
2316
error = PyDict_SetItem(globals, pkgstr, Py_None);
2318
PyErr_SetString(PyExc_ValueError,
2319
"Could not set __package__");
2324
len = lastdot - start;
2325
if (len >= MAXPATHLEN) {
2326
PyErr_SetString(PyExc_ValueError,
2327
"Module name too long");
2330
strncpy(buf, start, len);
2332
pkgname = PyUnicode_FromString(buf);
2333
if (pkgname == NULL) {
2336
error = PyDict_SetItem(globals, pkgstr, pkgname);
2339
PyErr_SetString(PyExc_ValueError,
2340
"Could not set __package__");
2345
while (--level > 0) {
2346
char *dot = strrchr(buf, '.');
2348
PyErr_SetString(PyExc_ValueError,
2349
"Attempted relative import beyond "
2350
"toplevel package");
2355
*p_buflen = strlen(buf);
2357
modules = PyImport_GetModuleDict();
2358
parent = PyDict_GetItemString(modules, buf);
2359
if (parent == NULL) {
2360
if (orig_level < 1) {
2361
PyObject *err_msg = PyBytes_FromFormat(
2362
"Parent module '%.200s' not found "
2363
"while handling absolute import", buf);
2364
if (err_msg == NULL) {
2367
if (!PyErr_WarnEx(PyExc_RuntimeWarning,
2368
PyBytes_AsString(err_msg), 1)) {
2375
PyErr_Format(PyExc_SystemError,
2376
"Parent module '%.200s' not loaded, "
2377
"cannot perform relative import", buf);
2381
/* We expect, but can't guarantee, if parent != None, that:
2382
- parent.__name__ == buf
2383
- parent.__dict__ is globals
2384
If this is violated... Who cares? */
2387
/* altmod is either None or same as mod */
2389
load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
2390
Py_ssize_t *p_buflen)
2392
char *name = *p_name;
2393
char *dot = strchr(name, '.');
2398
if (strlen(name) == 0) {
2399
/* completely empty module name should only happen in
2400
'from . import' (or '__import__("")')*/
2415
PyErr_SetString(PyExc_ValueError,
2416
"Empty module name");
2420
p = buf + *p_buflen;
2423
if (p+len-buf >= MAXPATHLEN) {
2424
PyErr_SetString(PyExc_ValueError,
2425
"Module name too long");
2428
strncpy(p, name, len);
2430
*p_buflen = p+len-buf;
2432
result = import_submodule(mod, p, buf);
2433
if (result == Py_None && altmod != mod) {
2435
/* Here, altmod must be None and mod must not be None */
2436
result = import_submodule(altmod, p, p);
2437
if (result != NULL && result != Py_None) {
2438
if (mark_miss(buf) != 0) {
2442
strncpy(buf, name, len);
2450
if (result == Py_None) {
2452
PyErr_Format(PyExc_ImportError,
2453
"No module named %.200s", name);
2461
mark_miss(char *name)
2463
PyObject *modules = PyImport_GetModuleDict();
2464
return PyDict_SetItemString(modules, name, Py_None);
2468
ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
2473
if (!PyObject_HasAttrString(mod, "__path__"))
2476
for (i = 0; ; i++) {
2477
PyObject *item = PySequence_GetItem(fromlist, i);
2480
if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2486
if (!PyUnicode_Check(item)) {
2487
PyErr_SetString(PyExc_TypeError,
2488
"Item in ``from list'' not a string");
2492
if (PyUnicode_AS_UNICODE(item)[0] == '*') {
2495
/* See if the package defines __all__ */
2497
continue; /* Avoid endless recursion */
2498
all = PyObject_GetAttrString(mod, "__all__");
2502
int ret = ensure_fromlist(mod, all, buf, buflen, 1);
2509
hasit = PyObject_HasAttr(mod, item);
2515
if (!Py_FileSystemDefaultEncoding) {
2516
item8 = PyUnicode_EncodeASCII(PyUnicode_AsUnicode(item),
2517
PyUnicode_GetSize(item),
2520
item8 = PyUnicode_AsEncodedString(item,
2521
Py_FileSystemDefaultEncoding, NULL);
2524
PyErr_SetString(PyExc_ValueError, "Cannot encode path item");
2527
subname = PyBytes_AS_STRING(item8);
2528
if (buflen + strlen(subname) >= MAXPATHLEN) {
2529
PyErr_SetString(PyExc_ValueError,
2530
"Module name too long");
2537
submod = import_submodule(mod, subname, buf);
2540
if (submod == NULL) {
2552
add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
2557
/* Irrespective of the success of this load, make a
2558
reference to it in the parent package module. A copy gets
2559
saved in the modules dictionary under the full name, so get a
2560
reference from there, if need be. (The exception is when the
2561
load failed with a SyntaxError -- then there's no trace in
2562
sys.modules. In that case, of course, do nothing extra.) */
2563
if (submod == NULL) {
2564
submod = PyDict_GetItemString(modules, fullname);
2568
if (PyModule_Check(mod)) {
2569
/* We can't use setattr here since it can give a
2570
* spurious warning if the submodule name shadows a
2572
PyObject *dict = PyModule_GetDict(mod);
2575
if (PyDict_SetItemString(dict, subname, submod) < 0)
2579
if (PyObject_SetAttrString(mod, subname, submod) < 0)
2586
import_submodule(PyObject *mod, char *subname, char *fullname)
2588
PyObject *modules = PyImport_GetModuleDict();
2592
if mod == None: subname == fullname
2593
else: mod.__name__ + "." + subname == fullname
2596
if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
2600
PyObject *path, *loader = NULL;
2601
char buf[MAXPATHLEN+1];
2602
struct filedescr *fdp;
2608
path = PyObject_GetAttrString(mod, "__path__");
2617
fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
2621
if (!PyErr_ExceptionMatches(PyExc_ImportError))
2627
m = load_module(fullname, fp, buf, fdp->type, loader);
2631
if (!add_submodule(mod, m, fullname, subname, modules)) {
2641
/* Re-import a module of any kind and return its module object, WITH
2642
INCREMENTED REFERENCE COUNT */
2645
PyImport_ReloadModule(PyObject *m)
2647
PyInterpreterState *interp = PyThreadState_Get()->interp;
2648
PyObject *modules_reloading = interp->modules_reloading;
2649
PyObject *modules = PyImport_GetModuleDict();
2650
PyObject *path = NULL, *loader = NULL, *existing_m = NULL;
2651
char *name, *subname;
2652
char buf[MAXPATHLEN+1];
2653
struct filedescr *fdp;
2657
if (modules_reloading == NULL) {
2658
Py_FatalError("PyImport_ReloadModule: "
2659
"no modules_reloading dictionary!");
2663
if (m == NULL || !PyModule_Check(m)) {
2664
PyErr_SetString(PyExc_TypeError,
2665
"reload() argument must be module");
2668
name = (char*)PyModule_GetName(m);
2671
if (m != PyDict_GetItemString(modules, name)) {
2672
PyErr_Format(PyExc_ImportError,
2673
"reload(): module %.200s not in sys.modules",
2677
existing_m = PyDict_GetItemString(modules_reloading, name);
2678
if (existing_m != NULL) {
2679
/* Due to a recursive reload, this module is already
2681
Py_INCREF(existing_m);
2684
if (PyDict_SetItemString(modules_reloading, name, m) < 0)
2687
subname = strrchr(name, '.');
2688
if (subname == NULL)
2691
PyObject *parentname, *parent;
2692
parentname = PyUnicode_FromStringAndSize(name, (subname-name));
2693
if (parentname == NULL) {
2694
imp_modules_reloading_clear();
2697
parent = PyDict_GetItem(modules, parentname);
2698
if (parent == NULL) {
2699
PyErr_Format(PyExc_ImportError,
2700
"reload(): parent %.200s not in sys.modules",
2701
_PyUnicode_AsString(parentname));
2702
Py_DECREF(parentname);
2703
imp_modules_reloading_clear();
2706
Py_DECREF(parentname);
2708
path = PyObject_GetAttrString(parent, "__path__");
2713
fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
2718
imp_modules_reloading_clear();
2722
newm = load_module(name, fp, buf, fdp->type, loader);
2728
/* load_module probably removed name from modules because of
2729
* the error. Put back the original module object. We're
2730
* going to return NULL in this case regardless of whether
2731
* replacing name succeeds, so the return value is ignored.
2733
PyDict_SetItemString(modules, name, m);
2735
imp_modules_reloading_clear();
2740
/* Higher-level import emulator which emulates the "import" statement
2741
more accurately -- it invokes the __import__() function from the
2742
builtins of the current globals. This means that the import is
2743
done using whatever import hooks are installed in the current
2744
environment, e.g. by "rexec".
2745
A dummy list ["__doc__"] is passed as the 4th argument so that
2746
e.g. PyImport_Import(PyUnicode_FromString("win32com.client.gencache"))
2747
will return <module "gencache"> instead of <module "win32com">. */
2750
PyImport_Import(PyObject *module_name)
2752
static PyObject *silly_list = NULL;
2753
static PyObject *builtins_str = NULL;
2754
static PyObject *import_str = NULL;
2755
PyObject *globals = NULL;
2756
PyObject *import = NULL;
2757
PyObject *builtins = NULL;
2760
/* Initialize constant string objects */
2761
if (silly_list == NULL) {
2762
import_str = PyUnicode_InternFromString("__import__");
2763
if (import_str == NULL)
2765
builtins_str = PyUnicode_InternFromString("__builtins__");
2766
if (builtins_str == NULL)
2768
silly_list = Py_BuildValue("[s]", "__doc__");
2769
if (silly_list == NULL)
2773
/* Get the builtins from current globals */
2774
globals = PyEval_GetGlobals();
2775
if (globals != NULL) {
2777
builtins = PyObject_GetItem(globals, builtins_str);
2778
if (builtins == NULL)
2782
/* No globals -- use standard builtins, and fake globals */
2785
builtins = PyImport_ImportModuleLevel("builtins",
2786
NULL, NULL, NULL, 0);
2787
if (builtins == NULL)
2789
globals = Py_BuildValue("{OO}", builtins_str, builtins);
2790
if (globals == NULL)
2794
/* Get the __import__ function from the builtins */
2795
if (PyDict_Check(builtins)) {
2796
import = PyObject_GetItem(builtins, import_str);
2798
PyErr_SetObject(PyExc_KeyError, import_str);
2801
import = PyObject_GetAttr(builtins, import_str);
2805
/* Call the __import__ function with the proper argument list
2806
* Always use absolute import here. */
2807
r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
2808
globals, silly_list, 0, NULL);
2811
Py_XDECREF(globals);
2812
Py_XDECREF(builtins);
2819
/* Module 'imp' provides Python access to the primitives used for
2824
imp_get_magic(PyObject *self, PyObject *noargs)
2828
buf[0] = (char) ((pyc_magic >> 0) & 0xff);
2829
buf[1] = (char) ((pyc_magic >> 8) & 0xff);
2830
buf[2] = (char) ((pyc_magic >> 16) & 0xff);
2831
buf[3] = (char) ((pyc_magic >> 24) & 0xff);
2833
return PyBytes_FromStringAndSize(buf, 4);
2837
imp_get_suffixes(PyObject *self, PyObject *noargs)
2840
struct filedescr *fdp;
2842
list = PyList_New(0);
2845
for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
2846
PyObject *item = Py_BuildValue("ssi",
2847
fdp->suffix, fdp->mode, fdp->type);
2852
if (PyList_Append(list, item) < 0) {
2863
call_find_module(char *name, PyObject *path)
2865
extern int fclose(FILE *);
2866
PyObject *fob, *ret;
2868
struct filedescr *fdp;
2869
char pathname[MAXPATHLEN+1];
2872
char *found_encoding = NULL;
2873
char *encoding = NULL;
2876
if (path == Py_None)
2878
fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
2889
if (strchr(fdp->mode, 'b') == NULL) {
2890
/* PyTokenizer_FindEncoding() returns PyMem_MALLOC'ed
2892
found_encoding = PyTokenizer_FindEncoding(fd);
2893
lseek(fd, 0, 0); /* Reset position */
2894
if (found_encoding == NULL && PyErr_Occurred())
2896
encoding = (found_encoding != NULL) ? found_encoding :
2897
(char*)PyUnicode_GetDefaultEncoding();
2899
fob = PyFile_FromFd(fd, pathname, fdp->mode, -1,
2900
(char*)encoding, NULL, NULL, 1);
2903
PyMem_FREE(found_encoding);
2911
pathobj = PyUnicode_DecodeFSDefault(pathname);
2912
ret = Py_BuildValue("NN(ssi)",
2913
fob, pathobj, fdp->suffix, fdp->mode, fdp->type);
2914
PyMem_FREE(found_encoding);
2920
imp_find_module(PyObject *self, PyObject *args)
2923
PyObject *ret, *path = NULL;
2924
if (!PyArg_ParseTuple(args, "es|O:find_module",
2925
Py_FileSystemDefaultEncoding, &name,
2928
ret = call_find_module(name, path);
2934
imp_init_builtin(PyObject *self, PyObject *args)
2939
if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
2941
ret = init_builtin(name);
2948
m = PyImport_AddModule(name);
2954
imp_init_frozen(PyObject *self, PyObject *args)
2959
if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
2961
ret = PyImport_ImportFrozenModule(name);
2968
m = PyImport_AddModule(name);
2974
imp_get_frozen_object(PyObject *self, PyObject *args)
2978
if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
2980
return get_frozen_object(name);
2984
imp_is_frozen_package(PyObject *self, PyObject *args)
2988
if (!PyArg_ParseTuple(args, "s:is_frozen_package", &name))
2990
return is_frozen_package(name);
2994
imp_is_builtin(PyObject *self, PyObject *args)
2997
if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
2999
return PyLong_FromLong(is_builtin(name));
3003
imp_is_frozen(PyObject *self, PyObject *args)
3007
if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
3009
p = find_frozen(name);
3010
return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
3014
get_file(char *pathname, PyObject *fob, char *mode)
3018
mode = "r" PY_STDIOTEXTMODE;
3020
fp = fopen(pathname, mode);
3023
int fd = PyObject_AsFileDescriptor(fob);
3026
/* XXX This will leak a FILE struct. Fix this!!!!
3027
(But it doesn't leak a file descrioptor!) */
3028
fp = fdopen(fd, mode);
3031
PyErr_SetFromErrno(PyExc_IOError);
3036
imp_load_compiled(PyObject *self, PyObject *args)
3040
PyObject *fob = NULL;
3043
if (!PyArg_ParseTuple(args, "ss|O:load_compiled",
3044
&name, &pathname, &fob))
3046
fp = get_file(pathname, fob, "rb");
3049
m = load_compiled_module(name, pathname, fp);
3055
#ifdef HAVE_DYNAMIC_LOADING
3058
imp_load_dynamic(PyObject *self, PyObject *args)
3062
PyObject *fob = NULL;
3065
if (!PyArg_ParseTuple(args, "ss|O:load_dynamic",
3066
&name, &pathname, &fob))
3069
fp = get_file(pathname, fob, "r");
3073
m = _PyImport_LoadDynamicModule(name, pathname, fp);
3077
#endif /* HAVE_DYNAMIC_LOADING */
3080
imp_load_source(PyObject *self, PyObject *args)
3084
PyObject *fob = NULL;
3087
if (!PyArg_ParseTuple(args, "ss|O:load_source",
3088
&name, &pathname, &fob))
3090
fp = get_file(pathname, fob, "r");
3093
m = load_source_module(name, pathname, fp);
3100
imp_load_module(PyObject *self, PyObject *args)
3105
char *suffix; /* Unused */
3110
if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
3111
&name, &fob, &pathname,
3112
&suffix, &mode, &type))
3115
/* Mode must start with 'r' or 'U' and must not contain '+'.
3116
Implicit in this test is the assumption that the mode
3117
may contain other modifiers like 'b' or 't'. */
3119
if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
3120
PyErr_Format(PyExc_ValueError,
3121
"invalid file open mode %.200s", mode);
3128
fp = get_file(NULL, fob, mode);
3132
return load_module(name, fp, pathname, type, NULL);
3136
imp_load_package(PyObject *self, PyObject *args)
3140
if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
3142
return load_package(name, pathname);
3146
imp_new_module(PyObject *self, PyObject *args)
3149
if (!PyArg_ParseTuple(args, "s:new_module", &name))
3151
return PyModule_New(name);
3155
imp_reload(PyObject *self, PyObject *v)
3157
return PyImport_ReloadModule(v);
3160
PyDoc_STRVAR(doc_reload,
3161
"reload(module) -> module\n\
3163
Reload the module. The module must have been successfully imported before.");
3167
PyDoc_STRVAR(doc_imp,
3168
"This module provides the components needed to build your own\n\
3169
__import__ function. Undocumented functions are obsolete.");
3171
PyDoc_STRVAR(doc_find_module,
3172
"find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
3173
Search for a module. If path is omitted or None, search for a\n\
3174
built-in, frozen or special module and continue search in sys.path.\n\
3175
The module name cannot contain '.'; to search for a submodule of a\n\
3176
package, pass the submodule name and the package's __path__.");
3178
PyDoc_STRVAR(doc_load_module,
3179
"load_module(name, file, filename, (suffix, mode, type)) -> module\n\
3180
Load a module, given information returned by find_module().\n\
3181
The module name must include the full package name, if any.");
3183
PyDoc_STRVAR(doc_get_magic,
3184
"get_magic() -> string\n\
3185
Return the magic number for .pyc or .pyo files.");
3187
PyDoc_STRVAR(doc_get_suffixes,
3188
"get_suffixes() -> [(suffix, mode, type), ...]\n\
3189
Return a list of (suffix, mode, type) tuples describing the files\n\
3190
that find_module() looks for.");
3192
PyDoc_STRVAR(doc_new_module,
3193
"new_module(name) -> module\n\
3194
Create a new module. Do not enter it in sys.modules.\n\
3195
The module name must include the full package name, if any.");
3197
PyDoc_STRVAR(doc_lock_held,
3198
"lock_held() -> boolean\n\
3199
Return True if the import lock is currently held, else False.\n\
3200
On platforms without threads, return False.");
3202
PyDoc_STRVAR(doc_acquire_lock,
3203
"acquire_lock() -> None\n\
3204
Acquires the interpreter's import lock for the current thread.\n\
3205
This lock should be used by import hooks to ensure thread-safety\n\
3206
when importing modules.\n\
3207
On platforms without threads, this function does nothing.");
3209
PyDoc_STRVAR(doc_release_lock,
3210
"release_lock() -> None\n\
3211
Release the interpreter's import lock.\n\
3212
On platforms without threads, this function does nothing.");
3214
static PyMethodDef imp_methods[] = {
3215
{"find_module", imp_find_module, METH_VARARGS, doc_find_module},
3216
{"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},
3217
{"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},
3218
{"load_module", imp_load_module, METH_VARARGS, doc_load_module},
3219
{"new_module", imp_new_module, METH_VARARGS, doc_new_module},
3220
{"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
3221
{"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
3222
{"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
3223
{"reload", imp_reload, METH_O, doc_reload},
3224
/* The rest are obsolete */
3225
{"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
3226
{"is_frozen_package", imp_is_frozen_package, METH_VARARGS},
3227
{"init_builtin", imp_init_builtin, METH_VARARGS},
3228
{"init_frozen", imp_init_frozen, METH_VARARGS},
3229
{"is_builtin", imp_is_builtin, METH_VARARGS},
3230
{"is_frozen", imp_is_frozen, METH_VARARGS},
3231
{"load_compiled", imp_load_compiled, METH_VARARGS},
3232
#ifdef HAVE_DYNAMIC_LOADING
3233
{"load_dynamic", imp_load_dynamic, METH_VARARGS},
3235
{"load_package", imp_load_package, METH_VARARGS},
3236
{"load_source", imp_load_source, METH_VARARGS},
3237
{NULL, NULL} /* sentinel */
3241
setint(PyObject *d, char *name, int value)
3246
v = PyLong_FromLong((long)value);
3247
err = PyDict_SetItemString(d, name, v);
3257
NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
3262
if (!_PyArg_NoKeywords("NullImporter()", kwds))
3265
if (!PyArg_ParseTuple(args, "es:NullImporter",
3266
Py_FileSystemDefaultEncoding, &path))
3269
pathlen = strlen(path);
3272
PyErr_SetString(PyExc_ImportError, "empty pathname");
3276
struct stat statbuf;
3279
rv = stat(path, &statbuf);
3283
if (S_ISDIR(statbuf.st_mode)) {
3284
/* it's a directory */
3285
PyErr_SetString(PyExc_ImportError,
3286
"existing directory");
3290
#else /* MS_WINDOWS */
3292
/* see issue1293 and issue3677:
3293
* stat() on Windows doesn't recognise paths like
3294
* "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
3296
rv = GetFileAttributesA(path);
3298
if (rv != INVALID_FILE_ATTRIBUTES) {
3300
if (rv & FILE_ATTRIBUTE_DIRECTORY) {
3301
/* it's a directory */
3302
PyErr_SetString(PyExc_ImportError,
3303
"existing directory");
3313
NullImporter_find_module(NullImporter *self, PyObject *args)
3318
static PyMethodDef NullImporter_methods[] = {
3319
{"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
3320
"Always return None"
3322
{NULL} /* Sentinel */
3326
PyTypeObject PyNullImporter_Type = {
3327
PyVarObject_HEAD_INIT(NULL, 0)
3328
"imp.NullImporter", /*tp_name*/
3329
sizeof(NullImporter), /*tp_basicsize*/
3338
0, /*tp_as_sequence*/
3339
0, /*tp_as_mapping*/
3346
Py_TPFLAGS_DEFAULT, /*tp_flags*/
3347
"Null importer object", /* tp_doc */
3348
0, /* tp_traverse */
3350
0, /* tp_richcompare */
3351
0, /* tp_weaklistoffset */
3353
0, /* tp_iternext */
3354
NullImporter_methods, /* tp_methods */
3359
0, /* tp_descr_get */
3360
0, /* tp_descr_set */
3361
0, /* tp_dictoffset */
3362
(initproc)NullImporter_init, /* tp_init */
3364
PyType_GenericNew /* tp_new */
3367
static struct PyModuleDef impmodule = {
3368
PyModuleDef_HEAD_INIT,
3384
if (PyType_Ready(&PyNullImporter_Type) < 0)
3387
m = PyModule_Create(&impmodule);
3390
d = PyModule_GetDict(m);
3394
if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
3395
if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
3396
if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
3397
if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
3398
if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
3399
if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
3400
if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
3401
if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
3402
if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
3403
if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
3405
Py_INCREF(&PyNullImporter_Type);
3406
PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
3415
/* API for embedding applications that want to add their own entries
3416
to the table of built-in modules. This should normally be called
3417
*before* Py_Initialize(). When the table resize fails, -1 is
3418
returned and the existing table is unchanged.
3420
After a similar function by Just van Rossum. */
3423
PyImport_ExtendInittab(struct _inittab *newtab)
3425
static struct _inittab *our_copy = NULL;
3429
/* Count the number of entries in both tables */
3430
for (n = 0; newtab[n].name != NULL; n++)
3433
return 0; /* Nothing to do */
3434
for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3437
/* Allocate new memory for the combined table */
3439
PyMem_RESIZE(p, struct _inittab, i+n+1);
3443
/* Copy the tables into the new memory */
3444
if (our_copy != PyImport_Inittab)
3445
memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
3446
PyImport_Inittab = our_copy = p;
3447
memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
3452
/* Shorthand to add a single entry given a name and a function */
3455
PyImport_AppendInittab(char *name, PyObject* (*initfunc)(void))
3457
struct _inittab newtab[2];
3459
memset(newtab, '\0', sizeof newtab);
3461
newtab[0].name = name;
3462
newtab[0].initfunc = initfunc;
3464
return PyImport_ExtendInittab(newtab);
added
removed
Python/import.c
