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 atleast 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)
74 Python 2.7a0: 62171 (optimize list comprehensions/change LIST_APPEND)
75 Python 2.7a0: 62181 (optimize conditional branches:
76 introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE)
77 Python 2.7a0 62191 (introduce SETUP_WITH)
78 Python 2.7a0 62201 (introduce BUILD_SET)
79 Python 2.7a0 62211 (introduce MAP_ADD and SET_ADD)
82 #define MAGIC (62211 | ((long)'\r'<<16) | ((long)'\n'<<24))
84 /* Magic word as global; note that _PyImport_Init() can change the
85 value of this global to accommodate for alterations of how the
86 compiler works which are enabled by command line switches. */
87 static long pyc_magic = MAGIC;
89 /* See _PyImport_FixupExtension() below */
90 static PyObject *extensions = NULL;
92 /* This table is defined in config.c: */
93 extern struct _inittab _PyImport_Inittab[];
95 struct _inittab *PyImport_Inittab = _PyImport_Inittab;
97 /* these tables define the module suffixes that Python recognizes */
98 struct filedescr * _PyImport_Filetab = NULL;
101 static const struct filedescr _PyImport_StandardFiletab[] = {
102 {"/py", "U", PY_SOURCE},
103 {"/pyc", "rb", PY_COMPILED},
107 static const struct filedescr _PyImport_StandardFiletab[] = {
108 {".py", "U", PY_SOURCE},
110 {".pyw", "U", PY_SOURCE},
112 {".pyc", "rb", PY_COMPILED},
118 /* Initialize things */
123 const struct filedescr *scan;
124 struct filedescr *filetab;
128 /* prepare _PyImport_Filetab: copy entries from
129 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
131 #ifdef HAVE_DYNAMIC_LOADING
132 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
135 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
137 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
139 Py_FatalError("Can't initialize import file table.");
140 #ifdef HAVE_DYNAMIC_LOADING
141 memcpy(filetab, _PyImport_DynLoadFiletab,
142 countD * sizeof(struct filedescr));
144 memcpy(filetab + countD, _PyImport_StandardFiletab,
145 countS * sizeof(struct filedescr));
146 filetab[countD + countS].suffix = NULL;
148 _PyImport_Filetab = filetab;
150 if (Py_OptimizeFlag) {
151 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
152 for (; filetab->suffix != NULL; filetab++) {
154 if (strcmp(filetab->suffix, ".pyc") == 0)
155 filetab->suffix = ".pyo";
157 if (strcmp(filetab->suffix, "/pyc") == 0)
158 filetab->suffix = "/pyo";
163 if (Py_UnicodeFlag) {
164 /* Fix the pyc_magic so that byte compiled code created
165 using the all-Unicode method doesn't interfere with
166 code created in normal operation mode. */
167 pyc_magic = MAGIC + 1;
172 _PyImportHooks_Init(void)
174 PyObject *v, *path_hooks = NULL, *zimpimport;
177 /* adding sys.path_hooks and sys.path_importer_cache, setting up
179 if (PyType_Ready(&PyNullImporter_Type) < 0)
183 PySys_WriteStderr("# installing zipimport hook\n");
188 err = PySys_SetObject("meta_path", v);
195 err = PySys_SetObject("path_importer_cache", v);
199 path_hooks = PyList_New(0);
200 if (path_hooks == NULL)
202 err = PySys_SetObject("path_hooks", path_hooks);
206 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
207 "path_importer_cache, or NullImporter failed"
211 zimpimport = PyImport_ImportModule("zipimport");
212 if (zimpimport == NULL) {
213 PyErr_Clear(); /* No zip import module -- okay */
215 PySys_WriteStderr("# can't import zipimport\n");
218 PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
220 Py_DECREF(zimpimport);
221 if (zipimporter == NULL) {
222 PyErr_Clear(); /* No zipimporter object -- okay */
225 "# can't import zipimport.zipimporter\n");
228 /* sys.path_hooks.append(zipimporter) */
229 err = PyList_Append(path_hooks, zipimporter);
230 Py_DECREF(zipimporter);
235 "# installed zipimport hook\n");
238 Py_DECREF(path_hooks);
244 Py_XDECREF(extensions);
246 PyMem_DEL(_PyImport_Filetab);
247 _PyImport_Filetab = NULL;
251 /* Locking primitives to prevent parallel imports of the same module
252 in different threads to return with a partially loaded module.
253 These calls are serialized by the global interpreter lock. */
257 #include "pythread.h"
259 static PyThread_type_lock import_lock = 0;
260 static long import_lock_thread = -1;
261 static int import_lock_level = 0;
264 _PyImport_AcquireLock(void)
266 long me = PyThread_get_thread_ident();
268 return; /* Too bad */
269 if (import_lock == NULL) {
270 import_lock = PyThread_allocate_lock();
271 if (import_lock == NULL)
272 return; /* Nothing much we can do. */
274 if (import_lock_thread == me) {
278 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
280 PyThreadState *tstate = PyEval_SaveThread();
281 PyThread_acquire_lock(import_lock, 1);
282 PyEval_RestoreThread(tstate);
284 import_lock_thread = me;
285 import_lock_level = 1;
289 _PyImport_ReleaseLock(void)
291 long me = PyThread_get_thread_ident();
292 if (me == -1 || import_lock == NULL)
293 return 0; /* Too bad */
294 if (import_lock_thread != me)
297 if (import_lock_level == 0) {
298 import_lock_thread = -1;
299 PyThread_release_lock(import_lock);
304 /* This function is called from PyOS_AfterFork to ensure that newly
305 created child processes do not share locks with the parent.
306 We now acquire the import lock around fork() calls but on some platforms
307 (Solaris 9 and earlier? see isue7242) that still left us with problems. */
310 _PyImport_ReInitLock(void)
312 if (import_lock != NULL)
313 import_lock = PyThread_allocate_lock();
314 import_lock_thread = -1;
315 import_lock_level = 0;
321 imp_lock_held(PyObject *self, PyObject *noargs)
324 return PyBool_FromLong(import_lock_thread != -1);
326 return PyBool_FromLong(0);
331 imp_acquire_lock(PyObject *self, PyObject *noargs)
334 _PyImport_AcquireLock();
341 imp_release_lock(PyObject *self, PyObject *noargs)
344 if (_PyImport_ReleaseLock() < 0) {
345 PyErr_SetString(PyExc_RuntimeError,
346 "not holding the import lock");
355 imp_modules_reloading_clear(void)
357 PyInterpreterState *interp = PyThreadState_Get()->interp;
358 if (interp->modules_reloading != NULL)
359 PyDict_Clear(interp->modules_reloading);
365 PyImport_GetModuleDict(void)
367 PyInterpreterState *interp = PyThreadState_GET()->interp;
368 if (interp->modules == NULL)
369 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
370 return interp->modules;
374 /* List of names to clear in sys */
375 static char* sys_deletes[] = {
376 "path", "argv", "ps1", "ps2", "exitfunc",
377 "exc_type", "exc_value", "exc_traceback",
378 "last_type", "last_value", "last_traceback",
379 "path_hooks", "path_importer_cache", "meta_path",
381 "flags", "float_info",
385 static char* sys_files[] = {
386 "stdin", "__stdin__",
387 "stdout", "__stdout__",
388 "stderr", "__stderr__",
393 /* Un-initialize things, as good as we can */
396 PyImport_Cleanup(void)
398 Py_ssize_t pos, ndone;
400 PyObject *key, *value, *dict;
401 PyInterpreterState *interp = PyThreadState_GET()->interp;
402 PyObject *modules = interp->modules;
405 return; /* Already done */
407 /* Delete some special variables first. These are common
408 places where user values hide and people complain when their
409 destructors fail. Since the modules containing them are
410 deleted *last* of all, they would come too late in the normal
411 destruction order. Sigh. */
413 value = PyDict_GetItemString(modules, "__builtin__");
414 if (value != NULL && PyModule_Check(value)) {
415 dict = PyModule_GetDict(value);
417 PySys_WriteStderr("# clear __builtin__._\n");
418 PyDict_SetItemString(dict, "_", Py_None);
420 value = PyDict_GetItemString(modules, "sys");
421 if (value != NULL && PyModule_Check(value)) {
424 dict = PyModule_GetDict(value);
425 for (p = sys_deletes; *p != NULL; p++) {
427 PySys_WriteStderr("# clear sys.%s\n", *p);
428 PyDict_SetItemString(dict, *p, Py_None);
430 for (p = sys_files; *p != NULL; p+=2) {
432 PySys_WriteStderr("# restore sys.%s\n", *p);
433 v = PyDict_GetItemString(dict, *(p+1));
436 PyDict_SetItemString(dict, *p, v);
440 /* First, delete __main__ */
441 value = PyDict_GetItemString(modules, "__main__");
442 if (value != NULL && PyModule_Check(value)) {
444 PySys_WriteStderr("# cleanup __main__\n");
445 _PyModule_Clear(value);
446 PyDict_SetItemString(modules, "__main__", Py_None);
449 /* The special treatment of __builtin__ here is because even
450 when it's not referenced as a module, its dictionary is
451 referenced by almost every module's __builtins__. Since
452 deleting a module clears its dictionary (even if there are
453 references left to it), we need to delete the __builtin__
454 module last. Likewise, we don't delete sys until the very
455 end because it is implicitly referenced (e.g. by print).
457 Also note that we 'delete' modules by replacing their entry
458 in the modules dict with None, rather than really deleting
459 them; this avoids a rehash of the modules dictionary and
460 also marks them as "non existent" so they won't be
463 /* Next, repeatedly delete modules with a reference count of
464 one (skipping __builtin__ and sys) and delete them */
468 while (PyDict_Next(modules, &pos, &key, &value)) {
469 if (value->ob_refcnt != 1)
471 if (PyString_Check(key) && PyModule_Check(value)) {
472 name = PyString_AS_STRING(key);
473 if (strcmp(name, "__builtin__") == 0)
475 if (strcmp(name, "sys") == 0)
479 "# cleanup[1] %s\n", name);
480 _PyModule_Clear(value);
481 PyDict_SetItem(modules, key, Py_None);
487 /* Next, delete all modules (still skipping __builtin__ and sys) */
489 while (PyDict_Next(modules, &pos, &key, &value)) {
490 if (PyString_Check(key) && PyModule_Check(value)) {
491 name = PyString_AS_STRING(key);
492 if (strcmp(name, "__builtin__") == 0)
494 if (strcmp(name, "sys") == 0)
497 PySys_WriteStderr("# cleanup[2] %s\n", name);
498 _PyModule_Clear(value);
499 PyDict_SetItem(modules, key, Py_None);
503 /* Next, delete sys and __builtin__ (in that order) */
504 value = PyDict_GetItemString(modules, "sys");
505 if (value != NULL && PyModule_Check(value)) {
507 PySys_WriteStderr("# cleanup sys\n");
508 _PyModule_Clear(value);
509 PyDict_SetItemString(modules, "sys", Py_None);
511 value = PyDict_GetItemString(modules, "__builtin__");
512 if (value != NULL && PyModule_Check(value)) {
514 PySys_WriteStderr("# cleanup __builtin__\n");
515 _PyModule_Clear(value);
516 PyDict_SetItemString(modules, "__builtin__", Py_None);
519 /* Finally, clear and delete the modules directory */
520 PyDict_Clear(modules);
521 interp->modules = NULL;
523 Py_CLEAR(interp->modules_reloading);
527 /* Helper for pythonrun.c -- return magic number */
530 PyImport_GetMagicNumber(void)
536 /* Magic for extension modules (built-in as well as dynamically
537 loaded). To prevent initializing an extension module more than
538 once, we keep a static dictionary 'extensions' keyed by module name
539 (for built-in modules) or by filename (for dynamically loaded
540 modules), containing these modules. A copy of the module's
541 dictionary is stored by calling _PyImport_FixupExtension()
542 immediately after the module initialization function succeeds. A
543 copy can be retrieved from there by calling
544 _PyImport_FindExtension(). */
547 _PyImport_FixupExtension(char *name, char *filename)
549 PyObject *modules, *mod, *dict, *copy;
550 if (extensions == NULL) {
551 extensions = PyDict_New();
552 if (extensions == NULL)
555 modules = PyImport_GetModuleDict();
556 mod = PyDict_GetItemString(modules, name);
557 if (mod == NULL || !PyModule_Check(mod)) {
558 PyErr_Format(PyExc_SystemError,
559 "_PyImport_FixupExtension: module %.200s not loaded", name);
562 dict = PyModule_GetDict(mod);
565 copy = PyDict_Copy(dict);
568 PyDict_SetItemString(extensions, filename, copy);
574 _PyImport_FindExtension(char *name, char *filename)
576 PyObject *dict, *mod, *mdict;
577 if (extensions == NULL)
579 dict = PyDict_GetItemString(extensions, filename);
582 mod = PyImport_AddModule(name);
585 mdict = PyModule_GetDict(mod);
588 if (PyDict_Update(mdict, dict))
591 PySys_WriteStderr("import %s # previously loaded (%s)\n",
597 /* Get the module object corresponding to a module name.
598 First check the modules dictionary if there's one there,
599 if not, create a new one and insert it in the modules dictionary.
600 Because the former action is most common, THIS DOES NOT RETURN A
604 PyImport_AddModule(const char *name)
606 PyObject *modules = PyImport_GetModuleDict();
609 if ((m = PyDict_GetItemString(modules, name)) != NULL &&
612 m = PyModule_New(name);
615 if (PyDict_SetItemString(modules, name, m) != 0) {
619 Py_DECREF(m); /* Yes, it still exists, in modules! */
624 /* Remove name from sys.modules, if it's there. */
626 remove_module(const char *name)
628 PyObject *modules = PyImport_GetModuleDict();
629 if (PyDict_GetItemString(modules, name) == NULL)
631 if (PyDict_DelItemString(modules, name) < 0)
632 Py_FatalError("import: deleting existing key in"
633 "sys.modules failed");
636 /* Execute a code object in a module and return the module object
637 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
638 * removed from sys.modules, to avoid leaving damaged module objects
639 * in sys.modules. The caller may wish to restore the original
640 * module object (if any) in this case; PyImport_ReloadModule is an
644 PyImport_ExecCodeModule(char *name, PyObject *co)
646 return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
650 PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
652 PyObject *modules = PyImport_GetModuleDict();
655 m = PyImport_AddModule(name);
658 /* If the module is being reloaded, we get the old module back
659 and re-use its dict to exec the new code. */
660 d = PyModule_GetDict(m);
661 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
662 if (PyDict_SetItemString(d, "__builtins__",
663 PyEval_GetBuiltins()) != 0)
666 /* Remember the filename as the __file__ attribute */
668 if (pathname != NULL) {
669 v = PyString_FromString(pathname);
674 v = ((PyCodeObject *)co)->co_filename;
677 if (PyDict_SetItemString(d, "__file__", v) != 0)
678 PyErr_Clear(); /* Not important enough to report */
681 v = PyEval_EvalCode((PyCodeObject *)co, d, d);
686 if ((m = PyDict_GetItemString(modules, name)) == NULL) {
687 PyErr_Format(PyExc_ImportError,
688 "Loaded module %.200s not found in sys.modules",
703 /* Given a pathname for a Python source file, fill a buffer with the
704 pathname for the corresponding compiled file. Return the pathname
705 for the compiled file, or NULL if there's no space in the buffer.
706 Doesn't set an exception. */
709 make_compiled_pathname(char *pathname, char *buf, size_t buflen)
711 size_t len = strlen(pathname);
716 /* Treat .pyw as if it were .py. The case of ".pyw" must match
717 that used in _PyImport_StandardFiletab. */
718 if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
719 --len; /* pretend 'w' isn't there */
721 memcpy(buf, pathname, len);
722 buf[len] = Py_OptimizeFlag ? 'o' : 'c';
729 /* Given a pathname for a Python source file, its time of last
730 modification, and a pathname for a compiled file, check whether the
731 compiled file represents the same version of the source. If so,
732 return a FILE pointer for the compiled file, positioned just after
733 the header; if not, return NULL.
734 Doesn't set an exception. */
737 check_compiled_module(char *pathname, time_t mtime, char *cpathname)
743 fp = fopen(cpathname, "rb");
746 magic = PyMarshal_ReadLongFromFile(fp);
747 if (magic != pyc_magic) {
749 PySys_WriteStderr("# %s has bad magic\n", cpathname);
753 pyc_mtime = PyMarshal_ReadLongFromFile(fp);
754 if (pyc_mtime != mtime) {
756 PySys_WriteStderr("# %s has bad mtime\n", cpathname);
761 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
766 /* Read a code object from a file and check it for validity */
768 static PyCodeObject *
769 read_compiled_module(char *cpathname, FILE *fp)
773 co = PyMarshal_ReadLastObjectFromFile(fp);
776 if (!PyCode_Check(co)) {
777 PyErr_Format(PyExc_ImportError,
778 "Non-code object in %.200s", cpathname);
782 return (PyCodeObject *)co;
786 /* Load a module from a compiled file, execute it, and return its
787 module object WITH INCREMENTED REFERENCE COUNT */
790 load_compiled_module(char *name, char *cpathname, FILE *fp)
796 magic = PyMarshal_ReadLongFromFile(fp);
797 if (magic != pyc_magic) {
798 PyErr_Format(PyExc_ImportError,
799 "Bad magic number in %.200s", cpathname);
802 (void) PyMarshal_ReadLongFromFile(fp);
803 co = read_compiled_module(cpathname, fp);
807 PySys_WriteStderr("import %s # precompiled from %s\n",
809 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
815 /* Parse a source file and return the corresponding code object */
817 static PyCodeObject *
818 parse_source_module(const char *pathname, FILE *fp)
820 PyCodeObject *co = NULL;
822 PyCompilerFlags flags;
823 PyArena *arena = PyArena_New();
829 mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags,
832 co = PyAST_Compile(mod, pathname, NULL, arena);
839 /* Helper to open a bytecode file for writing in exclusive mode */
842 open_exclusive(char *filename, mode_t mode)
844 #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
845 /* Use O_EXCL to avoid a race condition when another process tries to
846 write the same file. When that happens, our open() call fails,
847 which is just fine (since it's only a cache).
848 XXX If the file exists and is writable but the directory is not
849 writable, the file will never be written. Oh well.
852 (void) unlink(filename);
853 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
855 |O_BINARY /* necessary for Windows */
858 , mode, "ctxt=bin", "shr=nil"
865 return fdopen(fd, "wb");
867 /* Best we can do -- on Windows this can't happen anyway */
868 return fopen(filename, "wb");
873 /* Write a compiled module to a file, placing the time of last
874 modification of its source into the header.
875 Errors are ignored, if a write error occurs an attempt is made to
879 write_compiled_module(PyCodeObject *co, char *cpathname, struct stat *srcstat)
882 time_t mtime = srcstat->st_mtime;
883 #ifdef MS_WINDOWS /* since Windows uses different permissions */
884 mode_t mode = srcstat->st_mode & ~S_IEXEC;
886 mode_t mode = srcstat->st_mode & ~S_IXUSR & ~S_IXGRP & ~S_IXOTH;
889 fp = open_exclusive(cpathname, mode);
893 "# can't create %s\n", cpathname);
896 PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
897 /* First write a 0 for mtime */
898 PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
899 PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
900 if (fflush(fp) != 0 || ferror(fp)) {
902 PySys_WriteStderr("# can't write %s\n", cpathname);
903 /* Don't keep partial file */
905 (void) unlink(cpathname);
908 /* Now write the true mtime (as a 32-bit field) */
910 assert(mtime <= 0xFFFFFFFF);
911 PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
915 PySys_WriteStderr("# wrote %s\n", cpathname);
919 update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
921 PyObject *constants, *tmp;
924 if (!_PyString_Eq(co->co_filename, oldname))
927 tmp = co->co_filename;
928 co->co_filename = newname;
929 Py_INCREF(co->co_filename);
932 constants = co->co_consts;
933 n = PyTuple_GET_SIZE(constants);
934 for (i = 0; i < n; i++) {
935 tmp = PyTuple_GET_ITEM(constants, i);
936 if (PyCode_Check(tmp))
937 update_code_filenames((PyCodeObject *)tmp,
943 update_compiled_module(PyCodeObject *co, char *pathname)
945 PyObject *oldname, *newname;
947 if (strcmp(PyString_AsString(co->co_filename), pathname) == 0)
950 newname = PyString_FromString(pathname);
954 oldname = co->co_filename;
956 update_code_filenames(co, oldname, newname);
962 /* Load a source module from a given file and return its module
963 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
964 byte-compiled file, use that instead. */
967 load_source_module(char *name, char *pathname, FILE *fp)
971 char buf[MAXPATHLEN+1];
976 if (fstat(fileno(fp), &st) != 0) {
977 PyErr_Format(PyExc_RuntimeError,
978 "unable to get file status from '%s'",
982 if (sizeof st.st_mtime > 4) {
983 /* Python's .pyc timestamp handling presumes that the timestamp fits
984 in 4 bytes. Since the code only does an equality comparison,
985 ordering is not important and we can safely ignore the higher bits
986 (collisions are extremely unlikely).
988 st.st_mtime &= 0xFFFFFFFF;
990 cpathname = make_compiled_pathname(pathname, buf,
991 (size_t)MAXPATHLEN + 1);
992 if (cpathname != NULL &&
993 (fpc = check_compiled_module(pathname, st.st_mtime, cpathname))) {
994 co = read_compiled_module(cpathname, fpc);
998 if (update_compiled_module(co, pathname) < 0)
1001 PySys_WriteStderr("import %s # precompiled from %s\n",
1003 pathname = cpathname;
1006 co = parse_source_module(pathname, fp);
1010 PySys_WriteStderr("import %s # from %s\n",
1013 PyObject *ro = PySys_GetObject("dont_write_bytecode");
1014 if (ro == NULL || !PyObject_IsTrue(ro))
1015 write_compiled_module(co, cpathname, &st);
1018 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
1026 static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
1027 static struct filedescr *find_module(char *, char *, PyObject *,
1028 char *, size_t, FILE **, PyObject **);
1029 static struct _frozen *find_frozen(char *name);
1031 /* Load a package and return its module object WITH INCREMENTED
1035 load_package(char *name, char *pathname)
1038 PyObject *file = NULL;
1039 PyObject *path = NULL;
1041 char buf[MAXPATHLEN+1];
1043 struct filedescr *fdp;
1045 m = PyImport_AddModule(name);
1049 PySys_WriteStderr("import %s # directory %s\n",
1051 d = PyModule_GetDict(m);
1052 file = PyString_FromString(pathname);
1055 path = Py_BuildValue("[O]", file);
1058 err = PyDict_SetItemString(d, "__file__", file);
1060 err = PyDict_SetItemString(d, "__path__", path);
1064 fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
1066 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1074 m = load_module(name, fp, buf, fdp->type, NULL);
1088 /* Helper to test for built-in module */
1091 is_builtin(char *name)
1094 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1095 if (strcmp(name, PyImport_Inittab[i].name) == 0) {
1096 if (PyImport_Inittab[i].initfunc == NULL)
1106 /* Return an importer object for a sys.path/pkg.__path__ item 'p',
1107 possibly by fetching it from the path_importer_cache dict. If it
1108 wasn't yet cached, traverse path_hooks until a hook is found
1109 that can handle the path item. Return None if no hook could;
1110 this tells our caller it should fall back to the builtin
1111 import mechanism. Cache the result in path_importer_cache.
1112 Returns a borrowed reference. */
1115 get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
1119 Py_ssize_t j, nhooks;
1121 /* These conditions are the caller's responsibility: */
1122 assert(PyList_Check(path_hooks));
1123 assert(PyDict_Check(path_importer_cache));
1125 nhooks = PyList_Size(path_hooks);
1127 return NULL; /* Shouldn't happen */
1129 importer = PyDict_GetItem(path_importer_cache, p);
1130 if (importer != NULL)
1133 /* set path_importer_cache[p] to None to avoid recursion */
1134 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1137 for (j = 0; j < nhooks; j++) {
1138 PyObject *hook = PyList_GetItem(path_hooks, j);
1141 importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
1142 if (importer != NULL)
1145 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1150 if (importer == NULL) {
1151 importer = PyObject_CallFunctionObjArgs(
1152 (PyObject *)&PyNullImporter_Type, p, NULL
1154 if (importer == NULL) {
1155 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1161 if (importer != NULL) {
1162 int err = PyDict_SetItem(path_importer_cache, p, importer);
1163 Py_DECREF(importer);
1170 PyAPI_FUNC(PyObject *)
1171 PyImport_GetImporter(PyObject *path) {
1172 PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
1174 if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {
1175 if ((path_hooks = PySys_GetObject("path_hooks"))) {
1176 importer = get_path_importer(path_importer_cache,
1180 Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
1184 /* Search the path (default sys.path) for a module. Return the
1185 corresponding filedescr struct, and (via return arguments) the
1186 pathname and an open file. Return NULL if the module is not found. */
1189 extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
1190 char *, Py_ssize_t);
1193 static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
1194 static int find_init_module(char *); /* Forward */
1195 static struct filedescr importhookdescr = {"", "", IMP_HOOK};
1197 static struct filedescr *
1198 find_module(char *fullname, char *subname, PyObject *path, char *buf,
1199 size_t buflen, FILE **p_fp, PyObject **p_loader)
1201 Py_ssize_t i, npath;
1202 size_t len, namelen;
1203 struct filedescr *fdp = NULL;
1206 PyObject *path_hooks, *path_importer_cache;
1208 struct stat statbuf;
1210 static struct filedescr fd_frozen = {"", "", PY_FROZEN};
1211 static struct filedescr fd_builtin = {"", "", C_BUILTIN};
1212 static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
1213 char name[MAXPATHLEN+1];
1214 #if defined(PYOS_OS2)
1216 size_t saved_namelen;
1217 char *saved_buf = NULL;
1219 if (p_loader != NULL)
1222 if (strlen(subname) > MAXPATHLEN) {
1223 PyErr_SetString(PyExc_OverflowError,
1224 "module name is too long");
1227 strcpy(name, subname);
1229 /* sys.meta_path import hook */
1230 if (p_loader != NULL) {
1231 PyObject *meta_path;
1233 meta_path = PySys_GetObject("meta_path");
1234 if (meta_path == NULL || !PyList_Check(meta_path)) {
1235 PyErr_SetString(PyExc_RuntimeError,
1236 "sys.meta_path must be a list of "
1240 Py_INCREF(meta_path); /* zap guard */
1241 npath = PyList_Size(meta_path);
1242 for (i = 0; i < npath; i++) {
1244 PyObject *hook = PyList_GetItem(meta_path, i);
1245 loader = PyObject_CallMethod(hook, "find_module",
1249 if (loader == NULL) {
1250 Py_DECREF(meta_path);
1251 return NULL; /* true error */
1253 if (loader != Py_None) {
1254 /* a loader was found */
1256 Py_DECREF(meta_path);
1257 return &importhookdescr;
1261 Py_DECREF(meta_path);
1264 if (path != NULL && PyString_Check(path)) {
1265 /* The only type of submodule allowed inside a "frozen"
1266 package are other frozen modules or packages. */
1267 if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
1268 PyErr_SetString(PyExc_ImportError,
1269 "full frozen module name too long");
1272 strcpy(buf, PyString_AsString(path));
1276 if (find_frozen(name) != NULL) {
1280 PyErr_Format(PyExc_ImportError,
1281 "No frozen submodule named %.200s", name);
1285 if (is_builtin(name)) {
1289 if ((find_frozen(name)) != NULL) {
1295 fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
1301 path = PySys_GetObject("path");
1303 if (path == NULL || !PyList_Check(path)) {
1304 PyErr_SetString(PyExc_RuntimeError,
1305 "sys.path must be a list of directory names");
1309 path_hooks = PySys_GetObject("path_hooks");
1310 if (path_hooks == NULL || !PyList_Check(path_hooks)) {
1311 PyErr_SetString(PyExc_RuntimeError,
1312 "sys.path_hooks must be a list of "
1316 path_importer_cache = PySys_GetObject("path_importer_cache");
1317 if (path_importer_cache == NULL ||
1318 !PyDict_Check(path_importer_cache)) {
1319 PyErr_SetString(PyExc_RuntimeError,
1320 "sys.path_importer_cache must be a dict");
1324 npath = PyList_Size(path);
1325 namelen = strlen(name);
1326 for (i = 0; i < npath; i++) {
1327 PyObject *copy = NULL;
1328 PyObject *v = PyList_GetItem(path, i);
1331 #ifdef Py_USING_UNICODE
1332 if (PyUnicode_Check(v)) {
1333 copy = PyUnicode_Encode(PyUnicode_AS_UNICODE(v),
1334 PyUnicode_GET_SIZE(v), Py_FileSystemDefaultEncoding, NULL);
1341 if (!PyString_Check(v))
1343 len = PyString_GET_SIZE(v);
1344 if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
1346 continue; /* Too long */
1348 strcpy(buf, PyString_AS_STRING(v));
1349 if (strlen(buf) != len) {
1351 continue; /* v contains '\0' */
1354 /* sys.path_hooks import hook */
1355 if (p_loader != NULL) {
1358 importer = get_path_importer(path_importer_cache,
1360 if (importer == NULL) {
1364 /* Note: importer is a borrowed reference */
1365 if (importer != Py_None) {
1367 loader = PyObject_CallMethod(importer,
1372 return NULL; /* error */
1373 if (loader != Py_None) {
1374 /* a loader was found */
1376 return &importhookdescr;
1382 /* no hook was found, use builtin import */
1384 if (len > 0 && buf[len-1] != SEP
1386 && buf[len-1] != ALTSEP
1390 strcpy(buf+len, name);
1393 /* Check for package import (buf holds a directory name,
1394 and there's an __init__ module in that directory */
1396 if (stat(buf, &statbuf) == 0 && /* it exists */
1397 S_ISDIR(statbuf.st_mode) && /* it's a directory */
1398 case_ok(buf, len, namelen, name)) { /* case matches */
1399 if (find_init_module(buf)) { /* and has __init__.py */
1404 char warnstr[MAXPATHLEN+80];
1405 sprintf(warnstr, "Not importing directory "
1406 "'%.*s': missing __init__.py",
1408 if (PyErr_Warn(PyExc_ImportWarning,
1416 /* XXX How are you going to test for directories? */
1419 case_ok(buf, len, namelen, name)) {
1420 if (find_init_module(buf)) {
1425 char warnstr[MAXPATHLEN+80];
1426 sprintf(warnstr, "Not importing directory "
1427 "'%.*s': missing __init__.py",
1429 if (PyErr_Warn(PyExc_ImportWarning,
1437 #if defined(PYOS_OS2)
1438 /* take a snapshot of the module spec for restoration
1439 * after the 8 character DLL hackery
1441 saved_buf = strdup(buf);
1443 saved_namelen = namelen;
1444 #endif /* PYOS_OS2 */
1445 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
1446 #if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
1447 /* OS/2 limits DLLs to 8 character names (w/o
1449 * so if the name is longer than that and its a
1450 * dynamically loaded module we're going to try,
1451 * truncate the name before trying
1453 if (strlen(subname) > 8) {
1454 /* is this an attempt to load a C extension? */
1455 const struct filedescr *scan;
1456 scan = _PyImport_DynLoadFiletab;
1457 while (scan->suffix != NULL) {
1458 if (!strcmp(scan->suffix, fdp->suffix))
1463 if (scan->suffix != NULL) {
1464 /* yes, so truncate the name */
1466 len -= strlen(subname) - namelen;
1470 #endif /* PYOS_OS2 */
1471 strcpy(buf+len, fdp->suffix);
1472 if (Py_VerboseFlag > 1)
1473 PySys_WriteStderr("# trying %s\n", buf);
1474 filemode = fdp->mode;
1475 if (filemode[0] == 'U')
1476 filemode = "r" PY_STDIOTEXTMODE;
1477 fp = fopen(buf, filemode);
1479 if (case_ok(buf, len, namelen, name))
1481 else { /* continue search */
1486 #if defined(PYOS_OS2)
1487 /* restore the saved snapshot */
1488 strcpy(buf, saved_buf);
1490 namelen = saved_namelen;
1493 #if defined(PYOS_OS2)
1494 /* don't need/want the module name snapshot anymore */
1506 PyErr_Format(PyExc_ImportError,
1507 "No module named %.200s", name);
1514 /* Helpers for main.c
1515 * Find the source file corresponding to a named module
1518 _PyImport_FindModule(const char *name, PyObject *path, char *buf,
1519 size_t buflen, FILE **p_fp, PyObject **p_loader)
1521 return find_module((char *) name, (char *) name, path,
1522 buf, buflen, p_fp, p_loader);
1525 PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)
1527 return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
1530 /* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
1531 * The arguments here are tricky, best shown by example:
1532 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1534 * |--------------------- buf ---------------------|
1535 * |------------------- len ------------------|
1536 * |------ name -------|
1537 * |----- namelen -----|
1538 * buf is the full path, but len only counts up to (& exclusive of) the
1539 * extension. name is the module name, also exclusive of extension.
1541 * We've already done a successful stat() or fopen() on buf, so know that
1542 * there's some match, possibly case-insensitive.
1544 * case_ok() is to return 1 if there's a case-sensitive match for
1545 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1548 * case_ok() is used to implement case-sensitive import semantics even
1549 * on platforms with case-insensitive filesystems. It's trivial to implement
1550 * for case-sensitive filesystems. It's pretty much a cross-platform
1551 * nightmare for systems with case-insensitive filesystems.
1554 /* First we may need a pile of platform-specific header files; the sequence
1555 * of #if's here should match the sequence in the body of case_ok().
1557 #if defined(MS_WINDOWS)
1558 #include <windows.h>
1560 #elif defined(DJGPP)
1563 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1564 #include <sys/types.h>
1567 #elif defined(PYOS_OS2)
1569 #define INCL_DOSERRORS
1570 #define INCL_NOPMAPI
1573 #elif defined(RISCOS)
1574 #include "oslib/osfscontrol.h"
1578 case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
1580 /* Pick a platform-specific implementation; the sequence of #if's here should
1581 * match the sequence just above.
1585 #if defined(MS_WINDOWS)
1586 WIN32_FIND_DATA data;
1589 if (Py_GETENV("PYTHONCASEOK") != NULL)
1592 h = FindFirstFile(buf, &data);
1593 if (h == INVALID_HANDLE_VALUE) {
1594 PyErr_Format(PyExc_NameError,
1595 "Can't find file for module %.100s\n(filename %.300s)",
1600 return strncmp(data.cFileName, name, namelen) == 0;
1603 #elif defined(DJGPP)
1607 if (Py_GETENV("PYTHONCASEOK") != NULL)
1610 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1612 PyErr_Format(PyExc_NameError,
1613 "Can't find file for module %.100s\n(filename %.300s)",
1617 return strncmp(ffblk.ff_name, name, namelen) == 0;
1619 /* new-fangled macintosh (macosx) or Cygwin */
1620 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1623 char dirname[MAXPATHLEN + 1];
1624 const int dirlen = len - namelen - 1; /* don't want trailing SEP */
1626 if (Py_GETENV("PYTHONCASEOK") != NULL)
1629 /* Copy the dir component into dirname; substitute "." if empty */
1635 assert(dirlen <= MAXPATHLEN);
1636 memcpy(dirname, buf, dirlen);
1637 dirname[dirlen] = '\0';
1639 /* Open the directory and search the entries for an exact match. */
1640 dirp = opendir(dirname);
1642 char *nameWithExt = buf + len - namelen;
1643 while ((dp = readdir(dirp)) != NULL) {
1645 #ifdef _DIRENT_HAVE_D_NAMELEN
1650 if (thislen >= namelen &&
1651 strcmp(dp->d_name, nameWithExt) == 0) {
1652 (void)closedir(dirp);
1653 return 1; /* Found */
1656 (void)closedir(dirp);
1658 return 0 ; /* Not found */
1661 #elif defined(RISCOS)
1662 char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */
1663 char buf2[MAXPATHLEN+2];
1664 char *nameWithExt = buf+len-namelen;
1668 if (Py_GETENV("PYTHONCASEOK") != NULL)
1672 append wildcard, otherwise case of filename wouldn't be touched */
1676 e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen);
1677 canonlen = MAXPATHLEN+1-canonlen;
1678 if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) )
1680 if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)
1681 return 1; /* match */
1686 #elif defined(PYOS_OS2)
1692 if (Py_GETENV("PYTHONCASEOK") != NULL)
1695 rc = DosFindFirst(buf,
1697 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1698 &ffbuf, sizeof(ffbuf),
1703 return strncmp(ffbuf.achName, name, namelen) == 0;
1705 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1714 /* Helper to look for __init__.py or __init__.py[co] in potential package */
1716 find_init_module(char *buf)
1718 const size_t save_len = strlen(buf);
1719 size_t i = save_len;
1720 char *pname; /* pointer to start of __init__ */
1721 struct stat statbuf;
1723 /* For calling case_ok(buf, len, namelen, name):
1724 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1726 * |--------------------- buf ---------------------|
1727 * |------------------- len ------------------|
1728 * |------ name -------|
1729 * |----- namelen -----|
1731 if (save_len + 13 >= MAXPATHLEN)
1735 strcpy(pname, "__init__.py");
1736 if (stat(buf, &statbuf) == 0) {
1738 save_len + 9, /* len("/__init__") */
1739 8, /* len("__init__") */
1741 buf[save_len] = '\0';
1746 strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
1747 if (stat(buf, &statbuf) == 0) {
1749 save_len + 9, /* len("/__init__") */
1750 8, /* len("__init__") */
1752 buf[save_len] = '\0';
1756 buf[save_len] = '\0';
1764 find_init_module(buf)
1767 int save_len = strlen(buf);
1770 if (save_len + 13 >= MAXPATHLEN)
1773 strcpy(buf+i, "__init__/py");
1775 buf[save_len] = '\0';
1779 if (Py_OptimizeFlag)
1784 buf[save_len] = '\0';
1787 buf[save_len] = '\0';
1792 #endif /* HAVE_STAT */
1795 static int init_builtin(char *); /* Forward */
1797 /* Load an external module using the default search path and return
1798 its module object WITH INCREMENTED REFERENCE COUNT */
1801 load_module(char *name, FILE *fp, char *pathname, int type, PyObject *loader)
1807 /* First check that there's an open file (if we need one) */
1812 PyErr_Format(PyExc_ValueError,
1813 "file object required for import (type code %d)",
1822 m = load_source_module(name, pathname, fp);
1826 m = load_compiled_module(name, pathname, fp);
1829 #ifdef HAVE_DYNAMIC_LOADING
1831 m = _PyImport_LoadDynamicModule(name, pathname, fp);
1836 m = load_package(name, pathname);
1841 if (pathname != NULL && pathname[0] != '\0')
1843 if (type == C_BUILTIN)
1844 err = init_builtin(name);
1846 err = PyImport_ImportFrozenModule(name);
1850 PyErr_Format(PyExc_ImportError,
1851 "Purported %s module %.200s not found",
1853 "builtin" : "frozen",
1857 modules = PyImport_GetModuleDict();
1858 m = PyDict_GetItemString(modules, name);
1862 "%s module %.200s not properly initialized",
1864 "builtin" : "frozen",
1872 if (loader == NULL) {
1873 PyErr_SetString(PyExc_ImportError,
1874 "import hook without loader");
1877 m = PyObject_CallMethod(loader, "load_module", "s", name);
1882 PyErr_Format(PyExc_ImportError,
1883 "Don't know how to import %.200s (type code %d)",
1893 /* Initialize a built-in module.
1894 Return 1 for success, 0 if the module is not found, and -1 with
1895 an exception set if the initialization failed. */
1898 init_builtin(char *name)
1902 if (_PyImport_FindExtension(name, name) != NULL)
1905 for (p = PyImport_Inittab; p->name != NULL; p++) {
1906 if (strcmp(name, p->name) == 0) {
1907 if (p->initfunc == NULL) {
1908 PyErr_Format(PyExc_ImportError,
1909 "Cannot re-init internal module %.200s",
1914 PySys_WriteStderr("import %s # builtin\n", name);
1916 if (PyErr_Occurred())
1918 if (_PyImport_FixupExtension(name, name) == NULL)
1927 /* Frozen modules */
1929 static struct _frozen *
1930 find_frozen(char *name)
1934 for (p = PyImport_FrozenModules; ; p++) {
1935 if (p->name == NULL)
1937 if (strcmp(p->name, name) == 0)
1944 get_frozen_object(char *name)
1946 struct _frozen *p = find_frozen(name);
1950 PyErr_Format(PyExc_ImportError,
1951 "No such frozen object named %.200s",
1955 if (p->code == NULL) {
1956 PyErr_Format(PyExc_ImportError,
1957 "Excluded frozen object named %.200s",
1964 return PyMarshal_ReadObjectFromString((char *)p->code, size);
1967 /* Initialize a frozen module.
1968 Return 1 for succes, 0 if the module is not found, and -1 with
1969 an exception set if the initialization failed.
1970 This function is also used from frozenmain.c */
1973 PyImport_ImportFrozenModule(char *name)
1975 struct _frozen *p = find_frozen(name);
1983 if (p->code == NULL) {
1984 PyErr_Format(PyExc_ImportError,
1985 "Excluded frozen object named %.200s",
1990 ispackage = (size < 0);
1994 PySys_WriteStderr("import %s # frozen%s\n",
1995 name, ispackage ? " package" : "");
1996 co = PyMarshal_ReadObjectFromString((char *)p->code, size);
1999 if (!PyCode_Check(co)) {
2000 PyErr_Format(PyExc_TypeError,
2001 "frozen object %.200s is not a code object",
2006 /* Set __path__ to the package name */
2009 m = PyImport_AddModule(name);
2012 d = PyModule_GetDict(m);
2013 s = PyString_InternFromString(name);
2016 err = PyDict_SetItemString(d, "__path__", s);
2021 m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
2033 /* Import a module, either built-in, frozen, or external, and return
2034 its module object WITH INCREMENTED REFERENCE COUNT */
2037 PyImport_ImportModule(const char *name)
2042 pname = PyString_FromString(name);
2045 result = PyImport_Import(pname);
2050 /* Import a module without blocking
2052 * At first it tries to fetch the module from sys.modules. If the module was
2053 * never loaded before it loads it with PyImport_ImportModule() unless another
2054 * thread holds the import lock. In the latter case the function raises an
2055 * ImportError instead of blocking.
2057 * Returns the module object with incremented ref count.
2060 PyImport_ImportModuleNoBlock(const char *name)
2068 /* Try to get the module from sys.modules[name] */
2069 modules = PyImport_GetModuleDict();
2070 if (modules == NULL)
2073 result = PyDict_GetItemString(modules, name);
2074 if (result != NULL) {
2082 /* check the import lock
2083 * me might be -1 but I ignore the error here, the lock function
2084 * takes care of the problem */
2085 me = PyThread_get_thread_ident();
2086 if (import_lock_thread == -1 || import_lock_thread == me) {
2087 /* no thread or me is holding the lock */
2088 return PyImport_ImportModule(name);
2091 PyErr_Format(PyExc_ImportError,
2092 "Failed to import %.200s because the import lock"
2093 "is held by another thread.",
2098 return PyImport_ImportModule(name);
2102 /* Forward declarations for helper routines */
2103 static PyObject *get_parent(PyObject *globals, char *buf,
2104 Py_ssize_t *p_buflen, int level);
2105 static PyObject *load_next(PyObject *mod, PyObject *altmod,
2106 char **p_name, char *buf, Py_ssize_t *p_buflen);
2107 static int mark_miss(char *name);
2108 static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
2109 char *buf, Py_ssize_t buflen, int recursive);
2110 static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
2112 /* The Magnum Opus of dotted-name import :-) */
2115 import_module_level(char *name, PyObject *globals, PyObject *locals,
2116 PyObject *fromlist, int level)
2118 char buf[MAXPATHLEN+1];
2119 Py_ssize_t buflen = 0;
2120 PyObject *parent, *head, *next, *tail;
2122 if (strchr(name, '/') != NULL
2124 || strchr(name, '\\') != NULL
2127 PyErr_SetString(PyExc_ImportError,
2128 "Import by filename is not supported.");
2132 parent = get_parent(globals, buf, &buflen, level);
2136 head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,
2144 next = load_next(tail, tail, &name, buf, &buflen);
2152 if (tail == Py_None) {
2153 /* If tail is Py_None, both get_parent and load_next found
2154 an empty module name: someone called __import__("") or
2155 doctored faulty bytecode */
2158 PyErr_SetString(PyExc_ValueError,
2159 "Empty module name");
2163 if (fromlist != NULL) {
2164 if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
2168 if (fromlist == NULL) {
2174 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
2183 PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
2184 PyObject *fromlist, int level)
2187 _PyImport_AcquireLock();
2188 result = import_module_level(name, globals, locals, fromlist, level);
2189 if (_PyImport_ReleaseLock() < 0) {
2191 PyErr_SetString(PyExc_RuntimeError,
2192 "not holding the import lock");
2198 /* Return the package that an import is being performed in. If globals comes
2199 from the module foo.bar.bat (not itself a package), this returns the
2200 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2201 the package's entry in sys.modules is returned, as a borrowed reference.
2203 The *name* of the returned package is returned in buf, with the length of
2204 the name in *p_buflen.
2206 If globals doesn't come from a package or a module in a package, or a
2207 corresponding entry is not found in sys.modules, Py_None is returned.
2210 get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
2212 static PyObject *namestr = NULL;
2213 static PyObject *pathstr = NULL;
2214 static PyObject *pkgstr = NULL;
2215 PyObject *pkgname, *modname, *modpath, *modules, *parent;
2216 int orig_level = level;
2218 if (globals == NULL || !PyDict_Check(globals) || !level)
2221 if (namestr == NULL) {
2222 namestr = PyString_InternFromString("__name__");
2223 if (namestr == NULL)
2226 if (pathstr == NULL) {
2227 pathstr = PyString_InternFromString("__path__");
2228 if (pathstr == NULL)
2231 if (pkgstr == NULL) {
2232 pkgstr = PyString_InternFromString("__package__");
2239 pkgname = PyDict_GetItem(globals, pkgstr);
2241 if ((pkgname != NULL) && (pkgname != Py_None)) {
2242 /* __package__ is set, so use it */
2244 if (!PyString_Check(pkgname)) {
2245 PyErr_SetString(PyExc_ValueError,
2246 "__package__ set to non-string");
2249 len = PyString_GET_SIZE(pkgname);
2252 PyErr_SetString(PyExc_ValueError,
2253 "Attempted relative import in non-package");
2258 if (len > MAXPATHLEN) {
2259 PyErr_SetString(PyExc_ValueError,
2260 "Package name too long");
2263 strcpy(buf, PyString_AS_STRING(pkgname));
2265 /* __package__ not set, so figure it out and set it */
2266 modname = PyDict_GetItem(globals, namestr);
2267 if (modname == NULL || !PyString_Check(modname))
2270 modpath = PyDict_GetItem(globals, pathstr);
2271 if (modpath != NULL) {
2272 /* __path__ is set, so modname is already the package name */
2273 Py_ssize_t len = PyString_GET_SIZE(modname);
2275 if (len > MAXPATHLEN) {
2276 PyErr_SetString(PyExc_ValueError,
2277 "Module name too long");
2280 strcpy(buf, PyString_AS_STRING(modname));
2281 error = PyDict_SetItem(globals, pkgstr, modname);
2283 PyErr_SetString(PyExc_ValueError,
2284 "Could not set __package__");
2288 /* Normal module, so work out the package name if any */
2289 char *start = PyString_AS_STRING(modname);
2290 char *lastdot = strrchr(start, '.');
2293 if (lastdot == NULL && level > 0) {
2294 PyErr_SetString(PyExc_ValueError,
2295 "Attempted relative import in non-package");
2298 if (lastdot == NULL) {
2299 error = PyDict_SetItem(globals, pkgstr, Py_None);
2301 PyErr_SetString(PyExc_ValueError,
2302 "Could not set __package__");
2307 len = lastdot - start;
2308 if (len >= MAXPATHLEN) {
2309 PyErr_SetString(PyExc_ValueError,
2310 "Module name too long");
2313 strncpy(buf, start, len);
2315 pkgname = PyString_FromString(buf);
2316 if (pkgname == NULL) {
2319 error = PyDict_SetItem(globals, pkgstr, pkgname);
2322 PyErr_SetString(PyExc_ValueError,
2323 "Could not set __package__");
2328 while (--level > 0) {
2329 char *dot = strrchr(buf, '.');
2331 PyErr_SetString(PyExc_ValueError,
2332 "Attempted relative import beyond "
2333 "toplevel package");
2338 *p_buflen = strlen(buf);
2340 modules = PyImport_GetModuleDict();
2341 parent = PyDict_GetItemString(modules, buf);
2342 if (parent == NULL) {
2343 if (orig_level < 1) {
2344 PyObject *err_msg = PyString_FromFormat(
2345 "Parent module '%.200s' not found "
2346 "while handling absolute import", buf);
2347 if (err_msg == NULL) {
2350 if (!PyErr_WarnEx(PyExc_RuntimeWarning,
2351 PyString_AsString(err_msg), 1)) {
2358 PyErr_Format(PyExc_SystemError,
2359 "Parent module '%.200s' not loaded, "
2360 "cannot perform relative import", buf);
2364 /* We expect, but can't guarantee, if parent != None, that:
2365 - parent.__name__ == buf
2366 - parent.__dict__ is globals
2367 If this is violated... Who cares? */
2370 /* altmod is either None or same as mod */
2372 load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
2373 Py_ssize_t *p_buflen)
2375 char *name = *p_name;
2376 char *dot = strchr(name, '.');
2381 if (strlen(name) == 0) {
2382 /* completely empty module name should only happen in
2383 'from . import' (or '__import__("")')*/
2398 PyErr_SetString(PyExc_ValueError,
2399 "Empty module name");
2403 p = buf + *p_buflen;
2406 if (p+len-buf >= MAXPATHLEN) {
2407 PyErr_SetString(PyExc_ValueError,
2408 "Module name too long");
2411 strncpy(p, name, len);
2413 *p_buflen = p+len-buf;
2415 result = import_submodule(mod, p, buf);
2416 if (result == Py_None && altmod != mod) {
2418 /* Here, altmod must be None and mod must not be None */
2419 result = import_submodule(altmod, p, p);
2420 if (result != NULL && result != Py_None) {
2421 if (mark_miss(buf) != 0) {
2425 strncpy(buf, name, len);
2433 if (result == Py_None) {
2435 PyErr_Format(PyExc_ImportError,
2436 "No module named %.200s", name);
2444 mark_miss(char *name)
2446 PyObject *modules = PyImport_GetModuleDict();
2447 return PyDict_SetItemString(modules, name, Py_None);
2451 ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
2456 if (!PyObject_HasAttrString(mod, "__path__"))
2459 for (i = 0; ; i++) {
2460 PyObject *item = PySequence_GetItem(fromlist, i);
2463 if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2469 if (!PyString_Check(item)) {
2470 PyErr_SetString(PyExc_TypeError,
2471 "Item in ``from list'' not a string");
2475 if (PyString_AS_STRING(item)[0] == '*') {
2478 /* See if the package defines __all__ */
2480 continue; /* Avoid endless recursion */
2481 all = PyObject_GetAttrString(mod, "__all__");
2485 int ret = ensure_fromlist(mod, all, buf, buflen, 1);
2492 hasit = PyObject_HasAttr(mod, item);
2494 char *subname = PyString_AS_STRING(item);
2497 if (buflen + strlen(subname) >= MAXPATHLEN) {
2498 PyErr_SetString(PyExc_ValueError,
2499 "Module name too long");
2506 submod = import_submodule(mod, subname, buf);
2508 if (submod == NULL) {
2520 add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
2525 /* Irrespective of the success of this load, make a
2526 reference to it in the parent package module. A copy gets
2527 saved in the modules dictionary under the full name, so get a
2528 reference from there, if need be. (The exception is when the
2529 load failed with a SyntaxError -- then there's no trace in
2530 sys.modules. In that case, of course, do nothing extra.) */
2531 if (submod == NULL) {
2532 submod = PyDict_GetItemString(modules, fullname);
2536 if (PyModule_Check(mod)) {
2537 /* We can't use setattr here since it can give a
2538 * spurious warning if the submodule name shadows a
2540 PyObject *dict = PyModule_GetDict(mod);
2543 if (PyDict_SetItemString(dict, subname, submod) < 0)
2547 if (PyObject_SetAttrString(mod, subname, submod) < 0)
2554 import_submodule(PyObject *mod, char *subname, char *fullname)
2556 PyObject *modules = PyImport_GetModuleDict();
2560 if mod == None: subname == fullname
2561 else: mod.__name__ + "." + subname == fullname
2564 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
2568 PyObject *path, *loader = NULL;
2569 char buf[MAXPATHLEN+1];
2570 struct filedescr *fdp;
2576 path = PyObject_GetAttrString(mod, "__path__");
2585 fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
2589 if (!PyErr_ExceptionMatches(PyExc_ImportError))
2595 m = load_module(fullname, fp, buf, fdp->type, loader);
2599 if (!add_submodule(mod, m, fullname, subname, modules)) {
2609 /* Re-import a module of any kind and return its module object, WITH
2610 INCREMENTED REFERENCE COUNT */
2613 PyImport_ReloadModule(PyObject *m)
2615 PyInterpreterState *interp = PyThreadState_Get()->interp;
2616 PyObject *modules_reloading = interp->modules_reloading;
2617 PyObject *modules = PyImport_GetModuleDict();
2618 PyObject *path = NULL, *loader = NULL, *existing_m = NULL;
2619 char *name, *subname;
2620 char buf[MAXPATHLEN+1];
2621 struct filedescr *fdp;
2625 if (modules_reloading == NULL) {
2626 Py_FatalError("PyImport_ReloadModule: "
2627 "no modules_reloading dictionary!");
2631 if (m == NULL || !PyModule_Check(m)) {
2632 PyErr_SetString(PyExc_TypeError,
2633 "reload() argument must be module");
2636 name = PyModule_GetName(m);
2639 if (m != PyDict_GetItemString(modules, name)) {
2640 PyErr_Format(PyExc_ImportError,
2641 "reload(): module %.200s not in sys.modules",
2645 existing_m = PyDict_GetItemString(modules_reloading, name);
2646 if (existing_m != NULL) {
2647 /* Due to a recursive reload, this module is already
2649 Py_INCREF(existing_m);
2652 if (PyDict_SetItemString(modules_reloading, name, m) < 0)
2655 subname = strrchr(name, '.');
2656 if (subname == NULL)
2659 PyObject *parentname, *parent;
2660 parentname = PyString_FromStringAndSize(name, (subname-name));
2661 if (parentname == NULL) {
2662 imp_modules_reloading_clear();
2665 parent = PyDict_GetItem(modules, parentname);
2666 if (parent == NULL) {
2667 PyErr_Format(PyExc_ImportError,
2668 "reload(): parent %.200s not in sys.modules",
2669 PyString_AS_STRING(parentname));
2670 Py_DECREF(parentname);
2671 imp_modules_reloading_clear();
2674 Py_DECREF(parentname);
2676 path = PyObject_GetAttrString(parent, "__path__");
2681 fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
2686 imp_modules_reloading_clear();
2690 newm = load_module(name, fp, buf, fdp->type, loader);
2696 /* load_module probably removed name from modules because of
2697 * the error. Put back the original module object. We're
2698 * going to return NULL in this case regardless of whether
2699 * replacing name succeeds, so the return value is ignored.
2701 PyDict_SetItemString(modules, name, m);
2703 imp_modules_reloading_clear();
2708 /* Higher-level import emulator which emulates the "import" statement
2709 more accurately -- it invokes the __import__() function from the
2710 builtins of the current globals. This means that the import is
2711 done using whatever import hooks are installed in the current
2712 environment, e.g. by "rexec".
2713 A dummy list ["__doc__"] is passed as the 4th argument so that
2714 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2715 will return <module "gencache"> instead of <module "win32com">. */
2718 PyImport_Import(PyObject *module_name)
2720 static PyObject *silly_list = NULL;
2721 static PyObject *builtins_str = NULL;
2722 static PyObject *import_str = NULL;
2723 PyObject *globals = NULL;
2724 PyObject *import = NULL;
2725 PyObject *builtins = NULL;
2728 /* Initialize constant string objects */
2729 if (silly_list == NULL) {
2730 import_str = PyString_InternFromString("__import__");
2731 if (import_str == NULL)
2733 builtins_str = PyString_InternFromString("__builtins__");
2734 if (builtins_str == NULL)
2736 silly_list = Py_BuildValue("[s]", "__doc__");
2737 if (silly_list == NULL)
2741 /* Get the builtins from current globals */
2742 globals = PyEval_GetGlobals();
2743 if (globals != NULL) {
2745 builtins = PyObject_GetItem(globals, builtins_str);
2746 if (builtins == NULL)
2750 /* No globals -- use standard builtins, and fake globals */
2751 builtins = PyImport_ImportModuleLevel("__builtin__",
2752 NULL, NULL, NULL, 0);
2753 if (builtins == NULL)
2755 globals = Py_BuildValue("{OO}", builtins_str, builtins);
2756 if (globals == NULL)
2760 /* Get the __import__ function from the builtins */
2761 if (PyDict_Check(builtins)) {
2762 import = PyObject_GetItem(builtins, import_str);
2764 PyErr_SetObject(PyExc_KeyError, import_str);
2767 import = PyObject_GetAttr(builtins, import_str);
2771 /* Call the __import__ function with the proper argument list
2772 * Always use absolute import here. */
2773 r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
2774 globals, silly_list, 0, NULL);
2777 Py_XDECREF(globals);
2778 Py_XDECREF(builtins);
2785 /* Module 'imp' provides Python access to the primitives used for
2790 imp_get_magic(PyObject *self, PyObject *noargs)
2794 buf[0] = (char) ((pyc_magic >> 0) & 0xff);
2795 buf[1] = (char) ((pyc_magic >> 8) & 0xff);
2796 buf[2] = (char) ((pyc_magic >> 16) & 0xff);
2797 buf[3] = (char) ((pyc_magic >> 24) & 0xff);
2799 return PyString_FromStringAndSize(buf, 4);
2803 imp_get_suffixes(PyObject *self, PyObject *noargs)
2806 struct filedescr *fdp;
2808 list = PyList_New(0);
2811 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
2812 PyObject *item = Py_BuildValue("ssi",
2813 fdp->suffix, fdp->mode, fdp->type);
2818 if (PyList_Append(list, item) < 0) {
2829 call_find_module(char *name, PyObject *path)
2831 extern int fclose(FILE *);
2832 PyObject *fob, *ret;
2833 struct filedescr *fdp;
2834 char pathname[MAXPATHLEN+1];
2838 if (path == Py_None)
2840 fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
2844 fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);
2852 ret = Py_BuildValue("Os(ssi)",
2853 fob, pathname, fdp->suffix, fdp->mode, fdp->type);
2859 imp_find_module(PyObject *self, PyObject *args)
2862 PyObject *path = NULL;
2863 if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))
2865 return call_find_module(name, path);
2869 imp_init_builtin(PyObject *self, PyObject *args)
2874 if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
2876 ret = init_builtin(name);
2883 m = PyImport_AddModule(name);
2889 imp_init_frozen(PyObject *self, PyObject *args)
2894 if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
2896 ret = PyImport_ImportFrozenModule(name);
2903 m = PyImport_AddModule(name);
2909 imp_get_frozen_object(PyObject *self, PyObject *args)
2913 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
2915 return get_frozen_object(name);
2919 imp_is_builtin(PyObject *self, PyObject *args)
2922 if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
2924 return PyInt_FromLong(is_builtin(name));
2928 imp_is_frozen(PyObject *self, PyObject *args)
2932 if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
2934 p = find_frozen(name);
2935 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
2939 get_file(char *pathname, PyObject *fob, char *mode)
2944 mode = "r" PY_STDIOTEXTMODE;
2945 fp = fopen(pathname, mode);
2947 PyErr_SetFromErrno(PyExc_IOError);
2950 fp = PyFile_AsFile(fob);
2952 PyErr_SetString(PyExc_ValueError,
2953 "bad/closed file object");
2959 imp_load_compiled(PyObject *self, PyObject *args)
2963 PyObject *fob = NULL;
2966 if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,
2967 &PyFile_Type, &fob))
2969 fp = get_file(pathname, fob, "rb");
2972 m = load_compiled_module(name, pathname, fp);
2978 #ifdef HAVE_DYNAMIC_LOADING
2981 imp_load_dynamic(PyObject *self, PyObject *args)
2985 PyObject *fob = NULL;
2988 if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,
2989 &PyFile_Type, &fob))
2992 fp = get_file(pathname, fob, "r");
2996 m = _PyImport_LoadDynamicModule(name, pathname, fp);
3000 #endif /* HAVE_DYNAMIC_LOADING */
3003 imp_load_source(PyObject *self, PyObject *args)
3007 PyObject *fob = NULL;
3010 if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,
3011 &PyFile_Type, &fob))
3013 fp = get_file(pathname, fob, "r");
3016 m = load_source_module(name, pathname, fp);
3023 imp_load_module(PyObject *self, PyObject *args)
3028 char *suffix; /* Unused */
3033 if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
3034 &name, &fob, &pathname,
3035 &suffix, &mode, &type))
3038 /* Mode must start with 'r' or 'U' and must not contain '+'.
3039 Implicit in this test is the assumption that the mode
3040 may contain other modifiers like 'b' or 't'. */
3042 if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
3043 PyErr_Format(PyExc_ValueError,
3044 "invalid file open mode %.200s", mode);
3051 if (!PyFile_Check(fob)) {
3052 PyErr_SetString(PyExc_ValueError,
3053 "load_module arg#2 should be a file or None");
3056 fp = get_file(pathname, fob, mode);
3060 return load_module(name, fp, pathname, type, NULL);
3064 imp_load_package(PyObject *self, PyObject *args)
3068 if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
3070 return load_package(name, pathname);
3074 imp_new_module(PyObject *self, PyObject *args)
3077 if (!PyArg_ParseTuple(args, "s:new_module", &name))
3079 return PyModule_New(name);
3083 imp_reload(PyObject *self, PyObject *v)
3085 return PyImport_ReloadModule(v);
3091 PyDoc_STRVAR(doc_imp,
3092 "This module provides the components needed to build your own\n\
3093 __import__ function. Undocumented functions are obsolete.");
3095 PyDoc_STRVAR(doc_reload,
3096 "reload(module) -> module\n\
3098 Reload the module. The module must have been successfully imported before.");
3100 PyDoc_STRVAR(doc_find_module,
3101 "find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
3102 Search for a module. If path is omitted or None, search for a\n\
3103 built-in, frozen or special module and continue search in sys.path.\n\
3104 The module name cannot contain '.'; to search for a submodule of a\n\
3105 package, pass the submodule name and the package's __path__.");
3107 PyDoc_STRVAR(doc_load_module,
3108 "load_module(name, file, filename, (suffix, mode, type)) -> module\n\
3109 Load a module, given information returned by find_module().\n\
3110 The module name must include the full package name, if any.");
3112 PyDoc_STRVAR(doc_get_magic,
3113 "get_magic() -> string\n\
3114 Return the magic number for .pyc or .pyo files.");
3116 PyDoc_STRVAR(doc_get_suffixes,
3117 "get_suffixes() -> [(suffix, mode, type), ...]\n\
3118 Return a list of (suffix, mode, type) tuples describing the files\n\
3119 that find_module() looks for.");
3121 PyDoc_STRVAR(doc_new_module,
3122 "new_module(name) -> module\n\
3123 Create a new module. Do not enter it in sys.modules.\n\
3124 The module name must include the full package name, if any.");
3126 PyDoc_STRVAR(doc_lock_held,
3127 "lock_held() -> boolean\n\
3128 Return True if the import lock is currently held, else False.\n\
3129 On platforms without threads, return False.");
3131 PyDoc_STRVAR(doc_acquire_lock,
3132 "acquire_lock() -> None\n\
3133 Acquires the interpreter's import lock for the current thread.\n\
3134 This lock should be used by import hooks to ensure thread-safety\n\
3135 when importing modules.\n\
3136 On platforms without threads, this function does nothing.");
3138 PyDoc_STRVAR(doc_release_lock,
3139 "release_lock() -> None\n\
3140 Release the interpreter's import lock.\n\
3141 On platforms without threads, this function does nothing.");
3143 static PyMethodDef imp_methods[] = {
3144 {"reload", imp_reload, METH_O, doc_reload},
3145 {"find_module", imp_find_module, METH_VARARGS, doc_find_module},
3146 {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},
3147 {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},
3148 {"load_module", imp_load_module, METH_VARARGS, doc_load_module},
3149 {"new_module", imp_new_module, METH_VARARGS, doc_new_module},
3150 {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
3151 {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
3152 {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
3153 /* The rest are obsolete */
3154 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
3155 {"init_builtin", imp_init_builtin, METH_VARARGS},
3156 {"init_frozen", imp_init_frozen, METH_VARARGS},
3157 {"is_builtin", imp_is_builtin, METH_VARARGS},
3158 {"is_frozen", imp_is_frozen, METH_VARARGS},
3159 {"load_compiled", imp_load_compiled, METH_VARARGS},
3160 #ifdef HAVE_DYNAMIC_LOADING
3161 {"load_dynamic", imp_load_dynamic, METH_VARARGS},
3163 {"load_package", imp_load_package, METH_VARARGS},
3164 {"load_source", imp_load_source, METH_VARARGS},
3165 {NULL, NULL} /* sentinel */
3169 setint(PyObject *d, char *name, int value)
3174 v = PyInt_FromLong((long)value);
3175 err = PyDict_SetItemString(d, name, v);
3185 NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
3190 if (!_PyArg_NoKeywords("NullImporter()", kwds))
3193 if (!PyArg_ParseTuple(args, "s:NullImporter",
3197 pathlen = strlen(path);
3199 PyErr_SetString(PyExc_ImportError, "empty pathname");
3204 struct stat statbuf;
3207 rv = stat(path, &statbuf);
3210 if (S_ISDIR(statbuf.st_mode)) {
3211 /* it's a directory */
3212 PyErr_SetString(PyExc_ImportError,
3213 "existing directory");
3217 #else /* MS_WINDOWS */
3219 /* see issue1293 and issue3677:
3220 * stat() on Windows doesn't recognise paths like
3221 * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
3223 rv = GetFileAttributesA(path);
3224 if (rv != INVALID_FILE_ATTRIBUTES) {
3226 if (rv & FILE_ATTRIBUTE_DIRECTORY) {
3227 /* it's a directory */
3228 PyErr_SetString(PyExc_ImportError,
3229 "existing directory");
3235 if (object_exists(path)) {
3238 /* it's a directory */
3239 PyErr_SetString(PyExc_ImportError,
3240 "existing directory");
3250 NullImporter_find_module(NullImporter *self, PyObject *args)
3255 static PyMethodDef NullImporter_methods[] = {
3256 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
3257 "Always return None"
3259 {NULL} /* Sentinel */
3263 PyTypeObject PyNullImporter_Type = {
3264 PyVarObject_HEAD_INIT(NULL, 0)
3265 "imp.NullImporter", /*tp_name*/
3266 sizeof(NullImporter), /*tp_basicsize*/
3275 0, /*tp_as_sequence*/
3276 0, /*tp_as_mapping*/
3283 Py_TPFLAGS_DEFAULT, /*tp_flags*/
3284 "Null importer object", /* tp_doc */
3285 0, /* tp_traverse */
3287 0, /* tp_richcompare */
3288 0, /* tp_weaklistoffset */
3290 0, /* tp_iternext */
3291 NullImporter_methods, /* tp_methods */
3296 0, /* tp_descr_get */
3297 0, /* tp_descr_set */
3298 0, /* tp_dictoffset */
3299 (initproc)NullImporter_init, /* tp_init */
3301 PyType_GenericNew /* tp_new */
3310 if (PyType_Ready(&PyNullImporter_Type) < 0)
3313 m = Py_InitModule4("imp", imp_methods, doc_imp,
3314 NULL, PYTHON_API_VERSION);
3317 d = PyModule_GetDict(m);
3321 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
3322 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
3323 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
3324 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
3325 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
3326 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
3327 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
3328 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
3329 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
3330 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
3332 Py_INCREF(&PyNullImporter_Type);
3333 PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
3339 /* API for embedding applications that want to add their own entries
3340 to the table of built-in modules. This should normally be called
3341 *before* Py_Initialize(). When the table resize fails, -1 is
3342 returned and the existing table is unchanged.
3344 After a similar function by Just van Rossum. */
3347 PyImport_ExtendInittab(struct _inittab *newtab)
3349 static struct _inittab *our_copy = NULL;
3353 /* Count the number of entries in both tables */
3354 for (n = 0; newtab[n].name != NULL; n++)
3357 return 0; /* Nothing to do */
3358 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3361 /* Allocate new memory for the combined table */
3363 PyMem_RESIZE(p, struct _inittab, i+n+1);
3367 /* Copy the tables into the new memory */
3368 if (our_copy != PyImport_Inittab)
3369 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
3370 PyImport_Inittab = our_copy = p;
3371 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
3376 /* Shorthand to add a single entry given a name and a function */
3379 PyImport_AppendInittab(const char *name, void (*initfunc)(void))
3381 struct _inittab newtab[2];
3383 memset(newtab, '\0', sizeof newtab);
3385 newtab[0].name = (char *)name;
3386 newtab[0].initfunc = initfunc;
3388 return PyImport_ExtendInittab(newtab);