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)
79 #define MAGIC (62181 | ((long)'\r'<<16) | ((long)'\n'<<24))
81 /* Magic word as global; note that _PyImport_Init() can change the
82 value of this global to accommodate for alterations of how the
83 compiler works which are enabled by command line switches. */
84 static long pyc_magic
= MAGIC
;
86 /* See _PyImport_FixupExtension() below */
87 static PyObject
*extensions
= NULL
;
89 /* This table is defined in config.c: */
90 extern struct _inittab _PyImport_Inittab
[];
92 struct _inittab
*PyImport_Inittab
= _PyImport_Inittab
;
94 /* these tables define the module suffixes that Python recognizes */
95 struct filedescr
* _PyImport_Filetab
= NULL
;
98 static const struct filedescr _PyImport_StandardFiletab
[] = {
99 {"/py", "U", PY_SOURCE
},
100 {"/pyc", "rb", PY_COMPILED
},
104 static const struct filedescr _PyImport_StandardFiletab
[] = {
105 {".py", "U", PY_SOURCE
},
107 {".pyw", "U", PY_SOURCE
},
109 {".pyc", "rb", PY_COMPILED
},
115 /* Initialize things */
120 const struct filedescr
*scan
;
121 struct filedescr
*filetab
;
125 /* prepare _PyImport_Filetab: copy entries from
126 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
128 #ifdef HAVE_DYNAMIC_LOADING
129 for (scan
= _PyImport_DynLoadFiletab
; scan
->suffix
!= NULL
; ++scan
)
132 for (scan
= _PyImport_StandardFiletab
; scan
->suffix
!= NULL
; ++scan
)
134 filetab
= PyMem_NEW(struct filedescr
, countD
+ countS
+ 1);
136 Py_FatalError("Can't initialize import file table.");
137 #ifdef HAVE_DYNAMIC_LOADING
138 memcpy(filetab
, _PyImport_DynLoadFiletab
,
139 countD
* sizeof(struct filedescr
));
141 memcpy(filetab
+ countD
, _PyImport_StandardFiletab
,
142 countS
* sizeof(struct filedescr
));
143 filetab
[countD
+ countS
].suffix
= NULL
;
145 _PyImport_Filetab
= filetab
;
147 if (Py_OptimizeFlag
) {
148 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
149 for (; filetab
->suffix
!= NULL
; filetab
++) {
151 if (strcmp(filetab
->suffix
, ".pyc") == 0)
152 filetab
->suffix
= ".pyo";
154 if (strcmp(filetab
->suffix
, "/pyc") == 0)
155 filetab
->suffix
= "/pyo";
160 if (Py_UnicodeFlag
) {
161 /* Fix the pyc_magic so that byte compiled code created
162 using the all-Unicode method doesn't interfere with
163 code created in normal operation mode. */
164 pyc_magic
= MAGIC
+ 1;
169 _PyImportHooks_Init(void)
171 PyObject
*v
, *path_hooks
= NULL
, *zimpimport
;
174 /* adding sys.path_hooks and sys.path_importer_cache, setting up
176 if (PyType_Ready(&PyNullImporter_Type
) < 0)
180 PySys_WriteStderr("# installing zipimport hook\n");
185 err
= PySys_SetObject("meta_path", v
);
192 err
= PySys_SetObject("path_importer_cache", v
);
196 path_hooks
= PyList_New(0);
197 if (path_hooks
== NULL
)
199 err
= PySys_SetObject("path_hooks", path_hooks
);
203 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
204 "path_importer_cache, or NullImporter failed"
208 zimpimport
= PyImport_ImportModule("zipimport");
209 if (zimpimport
== NULL
) {
210 PyErr_Clear(); /* No zip import module -- okay */
212 PySys_WriteStderr("# can't import zipimport\n");
215 PyObject
*zipimporter
= PyObject_GetAttrString(zimpimport
,
217 Py_DECREF(zimpimport
);
218 if (zipimporter
== NULL
) {
219 PyErr_Clear(); /* No zipimporter object -- okay */
222 "# can't import zipimport.zipimporter\n");
225 /* sys.path_hooks.append(zipimporter) */
226 err
= PyList_Append(path_hooks
, zipimporter
);
227 Py_DECREF(zipimporter
);
232 "# installed zipimport hook\n");
235 Py_DECREF(path_hooks
);
241 Py_XDECREF(extensions
);
243 PyMem_DEL(_PyImport_Filetab
);
244 _PyImport_Filetab
= NULL
;
248 /* Locking primitives to prevent parallel imports of the same module
249 in different threads to return with a partially loaded module.
250 These calls are serialized by the global interpreter lock. */
254 #include "pythread.h"
256 static PyThread_type_lock import_lock
= 0;
257 static long import_lock_thread
= -1;
258 static int import_lock_level
= 0;
263 long me
= PyThread_get_thread_ident();
265 return; /* Too bad */
266 if (import_lock
== NULL
) {
267 import_lock
= PyThread_allocate_lock();
268 if (import_lock
== NULL
)
269 return; /* Nothing much we can do. */
271 if (import_lock_thread
== me
) {
275 if (import_lock_thread
!= -1 || !PyThread_acquire_lock(import_lock
, 0))
277 PyThreadState
*tstate
= PyEval_SaveThread();
278 PyThread_acquire_lock(import_lock
, 1);
279 PyEval_RestoreThread(tstate
);
281 import_lock_thread
= me
;
282 import_lock_level
= 1;
288 long me
= PyThread_get_thread_ident();
289 if (me
== -1 || import_lock
== NULL
)
290 return 0; /* Too bad */
291 if (import_lock_thread
!= me
)
294 if (import_lock_level
== 0) {
295 import_lock_thread
= -1;
296 PyThread_release_lock(import_lock
);
301 /* This function is called from PyOS_AfterFork to ensure that newly
302 created child processes do not share locks with the parent. */
305 _PyImport_ReInitLock(void)
308 if (import_lock
!= NULL
)
309 import_lock
= PyThread_allocate_lock();
315 #define lock_import()
316 #define unlock_import() 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
)
341 imp_release_lock(PyObject
*self
, PyObject
*noargs
)
344 if (unlock_import() < 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 _RemoveModule(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 mode_t mode
= srcstat
->st_mode
;
885 fp
= open_exclusive(cpathname
, mode
);
889 "# can't create %s\n", cpathname
);
892 PyMarshal_WriteLongToFile(pyc_magic
, fp
, Py_MARSHAL_VERSION
);
893 /* First write a 0 for mtime */
894 PyMarshal_WriteLongToFile(0L, fp
, Py_MARSHAL_VERSION
);
895 PyMarshal_WriteObjectToFile((PyObject
*)co
, fp
, Py_MARSHAL_VERSION
);
896 if (fflush(fp
) != 0 || ferror(fp
)) {
898 PySys_WriteStderr("# can't write %s\n", cpathname
);
899 /* Don't keep partial file */
901 (void) unlink(cpathname
);
904 /* Now write the true mtime */
906 assert(mtime
< LONG_MAX
);
907 PyMarshal_WriteLongToFile((long)mtime
, fp
, Py_MARSHAL_VERSION
);
911 PySys_WriteStderr("# wrote %s\n", cpathname
);
915 update_code_filenames(PyCodeObject
*co
, PyObject
*oldname
, PyObject
*newname
)
917 PyObject
*constants
, *tmp
;
920 if (!_PyString_Eq(co
->co_filename
, oldname
))
923 tmp
= co
->co_filename
;
924 co
->co_filename
= newname
;
925 Py_INCREF(co
->co_filename
);
928 constants
= co
->co_consts
;
929 n
= PyTuple_GET_SIZE(constants
);
930 for (i
= 0; i
< n
; i
++) {
931 tmp
= PyTuple_GET_ITEM(constants
, i
);
932 if (PyCode_Check(tmp
))
933 update_code_filenames((PyCodeObject
*)tmp
,
939 update_compiled_module(PyCodeObject
*co
, char *pathname
)
941 PyObject
*oldname
, *newname
;
943 if (strcmp(PyString_AsString(co
->co_filename
), pathname
) == 0)
946 newname
= PyString_FromString(pathname
);
950 oldname
= co
->co_filename
;
952 update_code_filenames(co
, oldname
, newname
);
958 /* Load a source module from a given file and return its module
959 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
960 byte-compiled file, use that instead. */
963 load_source_module(char *name
, char *pathname
, FILE *fp
)
967 char buf
[MAXPATHLEN
+1];
972 if (fstat(fileno(fp
), &st
) != 0) {
973 PyErr_Format(PyExc_RuntimeError
,
974 "unable to get file status from '%s'",
978 #if SIZEOF_TIME_T > 4
979 /* Python's .pyc timestamp handling presumes that the timestamp fits
980 in 4 bytes. This will be fine until sometime in the year 2038,
981 when a 4-byte signed time_t will overflow.
983 if (st
.st_mtime
>> 32) {
984 PyErr_SetString(PyExc_OverflowError
,
985 "modification time overflows a 4 byte field");
989 cpathname
= make_compiled_pathname(pathname
, buf
,
990 (size_t)MAXPATHLEN
+ 1);
991 if (cpathname
!= NULL
&&
992 (fpc
= check_compiled_module(pathname
, st
.st_mtime
, cpathname
))) {
993 co
= read_compiled_module(cpathname
, fpc
);
997 if (update_compiled_module(co
, pathname
) < 0)
1000 PySys_WriteStderr("import %s # precompiled from %s\n",
1002 pathname
= cpathname
;
1005 co
= parse_source_module(pathname
, fp
);
1009 PySys_WriteStderr("import %s # from %s\n",
1012 PyObject
*ro
= PySys_GetObject("dont_write_bytecode");
1013 if (ro
== NULL
|| !PyObject_IsTrue(ro
))
1014 write_compiled_module(co
, cpathname
, &st
);
1017 m
= PyImport_ExecCodeModuleEx(name
, (PyObject
*)co
, pathname
);
1025 static PyObject
*load_module(char *, FILE *, char *, int, PyObject
*);
1026 static struct filedescr
*find_module(char *, char *, PyObject
*,
1027 char *, size_t, FILE **, PyObject
**);
1028 static struct _frozen
*find_frozen(char *name
);
1030 /* Load a package and return its module object WITH INCREMENTED
1034 load_package(char *name
, char *pathname
)
1037 PyObject
*file
= NULL
;
1038 PyObject
*path
= NULL
;
1040 char buf
[MAXPATHLEN
+1];
1042 struct filedescr
*fdp
;
1044 m
= PyImport_AddModule(name
);
1048 PySys_WriteStderr("import %s # directory %s\n",
1050 d
= PyModule_GetDict(m
);
1051 file
= PyString_FromString(pathname
);
1054 path
= Py_BuildValue("[O]", file
);
1057 err
= PyDict_SetItemString(d
, "__file__", file
);
1059 err
= PyDict_SetItemString(d
, "__path__", path
);
1063 fdp
= find_module(name
, "__init__", path
, buf
, sizeof(buf
), &fp
, NULL
);
1065 if (PyErr_ExceptionMatches(PyExc_ImportError
)) {
1073 m
= load_module(name
, fp
, buf
, fdp
->type
, NULL
);
1087 /* Helper to test for built-in module */
1090 is_builtin(char *name
)
1093 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++) {
1094 if (strcmp(name
, PyImport_Inittab
[i
].name
) == 0) {
1095 if (PyImport_Inittab
[i
].initfunc
== NULL
)
1105 /* Return an importer object for a sys.path/pkg.__path__ item 'p',
1106 possibly by fetching it from the path_importer_cache dict. If it
1107 wasn't yet cached, traverse path_hooks until a hook is found
1108 that can handle the path item. Return None if no hook could;
1109 this tells our caller it should fall back to the builtin
1110 import mechanism. Cache the result in path_importer_cache.
1111 Returns a borrowed reference. */
1114 get_path_importer(PyObject
*path_importer_cache
, PyObject
*path_hooks
,
1118 Py_ssize_t j
, nhooks
;
1120 /* These conditions are the caller's responsibility: */
1121 assert(PyList_Check(path_hooks
));
1122 assert(PyDict_Check(path_importer_cache
));
1124 nhooks
= PyList_Size(path_hooks
);
1126 return NULL
; /* Shouldn't happen */
1128 importer
= PyDict_GetItem(path_importer_cache
, p
);
1129 if (importer
!= NULL
)
1132 /* set path_importer_cache[p] to None to avoid recursion */
1133 if (PyDict_SetItem(path_importer_cache
, p
, Py_None
) != 0)
1136 for (j
= 0; j
< nhooks
; j
++) {
1137 PyObject
*hook
= PyList_GetItem(path_hooks
, j
);
1140 importer
= PyObject_CallFunctionObjArgs(hook
, p
, NULL
);
1141 if (importer
!= NULL
)
1144 if (!PyErr_ExceptionMatches(PyExc_ImportError
)) {
1149 if (importer
== NULL
) {
1150 importer
= PyObject_CallFunctionObjArgs(
1151 (PyObject
*)&PyNullImporter_Type
, p
, NULL
1153 if (importer
== NULL
) {
1154 if (PyErr_ExceptionMatches(PyExc_ImportError
)) {
1160 if (importer
!= NULL
) {
1161 int err
= PyDict_SetItem(path_importer_cache
, p
, importer
);
1162 Py_DECREF(importer
);
1169 PyAPI_FUNC(PyObject
*)
1170 PyImport_GetImporter(PyObject
*path
) {
1171 PyObject
*importer
=NULL
, *path_importer_cache
=NULL
, *path_hooks
=NULL
;
1173 if ((path_importer_cache
= PySys_GetObject("path_importer_cache"))) {
1174 if ((path_hooks
= PySys_GetObject("path_hooks"))) {
1175 importer
= get_path_importer(path_importer_cache
,
1179 Py_XINCREF(importer
); /* get_path_importer returns a borrowed reference */
1183 /* Search the path (default sys.path) for a module. Return the
1184 corresponding filedescr struct, and (via return arguments) the
1185 pathname and an open file. Return NULL if the module is not found. */
1188 extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr
**,
1189 char *, Py_ssize_t
);
1192 static int case_ok(char *, Py_ssize_t
, Py_ssize_t
, char *);
1193 static int find_init_module(char *); /* Forward */
1194 static struct filedescr importhookdescr
= {"", "", IMP_HOOK
};
1196 static struct filedescr
*
1197 find_module(char *fullname
, char *subname
, PyObject
*path
, char *buf
,
1198 size_t buflen
, FILE **p_fp
, PyObject
**p_loader
)
1200 Py_ssize_t i
, npath
;
1201 size_t len
, namelen
;
1202 struct filedescr
*fdp
= NULL
;
1205 PyObject
*path_hooks
, *path_importer_cache
;
1207 struct stat statbuf
;
1209 static struct filedescr fd_frozen
= {"", "", PY_FROZEN
};
1210 static struct filedescr fd_builtin
= {"", "", C_BUILTIN
};
1211 static struct filedescr fd_package
= {"", "", PKG_DIRECTORY
};
1212 char name
[MAXPATHLEN
+1];
1213 #if defined(PYOS_OS2)
1215 size_t saved_namelen
;
1216 char *saved_buf
= NULL
;
1218 if (p_loader
!= NULL
)
1221 if (strlen(subname
) > MAXPATHLEN
) {
1222 PyErr_SetString(PyExc_OverflowError
,
1223 "module name is too long");
1226 strcpy(name
, subname
);
1228 /* sys.meta_path import hook */
1229 if (p_loader
!= NULL
) {
1230 PyObject
*meta_path
;
1232 meta_path
= PySys_GetObject("meta_path");
1233 if (meta_path
== NULL
|| !PyList_Check(meta_path
)) {
1234 PyErr_SetString(PyExc_ImportError
,
1235 "sys.meta_path must be a list of "
1239 Py_INCREF(meta_path
); /* zap guard */
1240 npath
= PyList_Size(meta_path
);
1241 for (i
= 0; i
< npath
; i
++) {
1243 PyObject
*hook
= PyList_GetItem(meta_path
, i
);
1244 loader
= PyObject_CallMethod(hook
, "find_module",
1248 if (loader
== NULL
) {
1249 Py_DECREF(meta_path
);
1250 return NULL
; /* true error */
1252 if (loader
!= Py_None
) {
1253 /* a loader was found */
1255 Py_DECREF(meta_path
);
1256 return &importhookdescr
;
1260 Py_DECREF(meta_path
);
1263 if (path
!= NULL
&& PyString_Check(path
)) {
1264 /* The only type of submodule allowed inside a "frozen"
1265 package are other frozen modules or packages. */
1266 if (PyString_Size(path
) + 1 + strlen(name
) >= (size_t)buflen
) {
1267 PyErr_SetString(PyExc_ImportError
,
1268 "full frozen module name too long");
1271 strcpy(buf
, PyString_AsString(path
));
1275 if (find_frozen(name
) != NULL
) {
1279 PyErr_Format(PyExc_ImportError
,
1280 "No frozen submodule named %.200s", name
);
1284 if (is_builtin(name
)) {
1288 if ((find_frozen(name
)) != NULL
) {
1294 fp
= PyWin_FindRegisteredModule(name
, &fdp
, buf
, buflen
);
1300 path
= PySys_GetObject("path");
1302 if (path
== NULL
|| !PyList_Check(path
)) {
1303 PyErr_SetString(PyExc_ImportError
,
1304 "sys.path must be a list of directory names");
1308 path_hooks
= PySys_GetObject("path_hooks");
1309 if (path_hooks
== NULL
|| !PyList_Check(path_hooks
)) {
1310 PyErr_SetString(PyExc_ImportError
,
1311 "sys.path_hooks must be a list of "
1315 path_importer_cache
= PySys_GetObject("path_importer_cache");
1316 if (path_importer_cache
== NULL
||
1317 !PyDict_Check(path_importer_cache
)) {
1318 PyErr_SetString(PyExc_ImportError
,
1319 "sys.path_importer_cache must be a dict");
1323 npath
= PyList_Size(path
);
1324 namelen
= strlen(name
);
1325 for (i
= 0; i
< npath
; i
++) {
1326 PyObject
*copy
= NULL
;
1327 PyObject
*v
= PyList_GetItem(path
, i
);
1330 #ifdef Py_USING_UNICODE
1331 if (PyUnicode_Check(v
)) {
1332 copy
= PyUnicode_Encode(PyUnicode_AS_UNICODE(v
),
1333 PyUnicode_GET_SIZE(v
), Py_FileSystemDefaultEncoding
, NULL
);
1340 if (!PyString_Check(v
))
1342 len
= PyString_GET_SIZE(v
);
1343 if (len
+ 2 + namelen
+ MAXSUFFIXSIZE
>= buflen
) {
1345 continue; /* Too long */
1347 strcpy(buf
, PyString_AS_STRING(v
));
1348 if (strlen(buf
) != len
) {
1350 continue; /* v contains '\0' */
1353 /* sys.path_hooks import hook */
1354 if (p_loader
!= NULL
) {
1357 importer
= get_path_importer(path_importer_cache
,
1359 if (importer
== NULL
) {
1363 /* Note: importer is a borrowed reference */
1364 if (importer
!= Py_None
) {
1366 loader
= PyObject_CallMethod(importer
,
1371 return NULL
; /* error */
1372 if (loader
!= Py_None
) {
1373 /* a loader was found */
1375 return &importhookdescr
;
1381 /* no hook was found, use builtin import */
1383 if (len
> 0 && buf
[len
-1] != SEP
1385 && buf
[len
-1] != ALTSEP
1389 strcpy(buf
+len
, name
);
1392 /* Check for package import (buf holds a directory name,
1393 and there's an __init__ module in that directory */
1395 if (stat(buf
, &statbuf
) == 0 && /* it exists */
1396 S_ISDIR(statbuf
.st_mode
) && /* it's a directory */
1397 case_ok(buf
, len
, namelen
, name
)) { /* case matches */
1398 if (find_init_module(buf
)) { /* and has __init__.py */
1403 char warnstr
[MAXPATHLEN
+80];
1404 sprintf(warnstr
, "Not importing directory "
1405 "'%.*s': missing __init__.py",
1407 if (PyErr_Warn(PyExc_ImportWarning
,
1415 /* XXX How are you going to test for directories? */
1418 case_ok(buf
, len
, namelen
, name
)) {
1419 if (find_init_module(buf
)) {
1424 char warnstr
[MAXPATHLEN
+80];
1425 sprintf(warnstr
, "Not importing directory "
1426 "'%.*s': missing __init__.py",
1428 if (PyErr_Warn(PyExc_ImportWarning
,
1436 #if defined(PYOS_OS2)
1437 /* take a snapshot of the module spec for restoration
1438 * after the 8 character DLL hackery
1440 saved_buf
= strdup(buf
);
1442 saved_namelen
= namelen
;
1443 #endif /* PYOS_OS2 */
1444 for (fdp
= _PyImport_Filetab
; fdp
->suffix
!= NULL
; fdp
++) {
1445 #if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
1446 /* OS/2 limits DLLs to 8 character names (w/o
1448 * so if the name is longer than that and its a
1449 * dynamically loaded module we're going to try,
1450 * truncate the name before trying
1452 if (strlen(subname
) > 8) {
1453 /* is this an attempt to load a C extension? */
1454 const struct filedescr
*scan
;
1455 scan
= _PyImport_DynLoadFiletab
;
1456 while (scan
->suffix
!= NULL
) {
1457 if (!strcmp(scan
->suffix
, fdp
->suffix
))
1462 if (scan
->suffix
!= NULL
) {
1463 /* yes, so truncate the name */
1465 len
-= strlen(subname
) - namelen
;
1469 #endif /* PYOS_OS2 */
1470 strcpy(buf
+len
, fdp
->suffix
);
1471 if (Py_VerboseFlag
> 1)
1472 PySys_WriteStderr("# trying %s\n", buf
);
1473 filemode
= fdp
->mode
;
1474 if (filemode
[0] == 'U')
1475 filemode
= "r" PY_STDIOTEXTMODE
;
1476 fp
= fopen(buf
, filemode
);
1478 if (case_ok(buf
, len
, namelen
, name
))
1480 else { /* continue search */
1485 #if defined(PYOS_OS2)
1486 /* restore the saved snapshot */
1487 strcpy(buf
, saved_buf
);
1489 namelen
= saved_namelen
;
1492 #if defined(PYOS_OS2)
1493 /* don't need/want the module name snapshot anymore */
1505 PyErr_Format(PyExc_ImportError
,
1506 "No module named %.200s", name
);
1513 /* Helpers for main.c
1514 * Find the source file corresponding to a named module
1517 _PyImport_FindModule(const char *name
, PyObject
*path
, char *buf
,
1518 size_t buflen
, FILE **p_fp
, PyObject
**p_loader
)
1520 return find_module((char *) name
, (char *) name
, path
,
1521 buf
, buflen
, p_fp
, p_loader
);
1524 PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr
* fd
)
1526 return fd
->type
== PY_SOURCE
|| fd
->type
== PY_COMPILED
;
1529 /* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
1530 * The arguments here are tricky, best shown by example:
1531 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1533 * |--------------------- buf ---------------------|
1534 * |------------------- len ------------------|
1535 * |------ name -------|
1536 * |----- namelen -----|
1537 * buf is the full path, but len only counts up to (& exclusive of) the
1538 * extension. name is the module name, also exclusive of extension.
1540 * We've already done a successful stat() or fopen() on buf, so know that
1541 * there's some match, possibly case-insensitive.
1543 * case_ok() is to return 1 if there's a case-sensitive match for
1544 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1547 * case_ok() is used to implement case-sensitive import semantics even
1548 * on platforms with case-insensitive filesystems. It's trivial to implement
1549 * for case-sensitive filesystems. It's pretty much a cross-platform
1550 * nightmare for systems with case-insensitive filesystems.
1553 /* First we may need a pile of platform-specific header files; the sequence
1554 * of #if's here should match the sequence in the body of case_ok().
1556 #if defined(MS_WINDOWS)
1557 #include <windows.h>
1559 #elif defined(DJGPP)
1562 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1563 #include <sys/types.h>
1566 #elif defined(PYOS_OS2)
1568 #define INCL_DOSERRORS
1569 #define INCL_NOPMAPI
1572 #elif defined(RISCOS)
1573 #include "oslib/osfscontrol.h"
1577 case_ok(char *buf
, Py_ssize_t len
, Py_ssize_t namelen
, char *name
)
1579 /* Pick a platform-specific implementation; the sequence of #if's here should
1580 * match the sequence just above.
1584 #if defined(MS_WINDOWS)
1585 WIN32_FIND_DATA data
;
1588 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1591 h
= FindFirstFile(buf
, &data
);
1592 if (h
== INVALID_HANDLE_VALUE
) {
1593 PyErr_Format(PyExc_NameError
,
1594 "Can't find file for module %.100s\n(filename %.300s)",
1599 return strncmp(data
.cFileName
, name
, namelen
) == 0;
1602 #elif defined(DJGPP)
1606 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1609 done
= findfirst(buf
, &ffblk
, FA_ARCH
|FA_RDONLY
|FA_HIDDEN
|FA_DIREC
);
1611 PyErr_Format(PyExc_NameError
,
1612 "Can't find file for module %.100s\n(filename %.300s)",
1616 return strncmp(ffblk
.ff_name
, name
, namelen
) == 0;
1618 /* new-fangled macintosh (macosx) or Cygwin */
1619 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1622 char dirname
[MAXPATHLEN
+ 1];
1623 const int dirlen
= len
- namelen
- 1; /* don't want trailing SEP */
1625 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1628 /* Copy the dir component into dirname; substitute "." if empty */
1634 assert(dirlen
<= MAXPATHLEN
);
1635 memcpy(dirname
, buf
, dirlen
);
1636 dirname
[dirlen
] = '\0';
1638 /* Open the directory and search the entries for an exact match. */
1639 dirp
= opendir(dirname
);
1641 char *nameWithExt
= buf
+ len
- namelen
;
1642 while ((dp
= readdir(dirp
)) != NULL
) {
1644 #ifdef _DIRENT_HAVE_D_NAMELEN
1649 if (thislen
>= namelen
&&
1650 strcmp(dp
->d_name
, nameWithExt
) == 0) {
1651 (void)closedir(dirp
);
1652 return 1; /* Found */
1655 (void)closedir(dirp
);
1657 return 0 ; /* Not found */
1660 #elif defined(RISCOS)
1661 char canon
[MAXPATHLEN
+1]; /* buffer for the canonical form of the path */
1662 char buf2
[MAXPATHLEN
+2];
1663 char *nameWithExt
= buf
+len
-namelen
;
1667 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1671 append wildcard, otherwise case of filename wouldn't be touched */
1675 e
= xosfscontrol_canonicalise_path(buf2
,canon
,0,0,MAXPATHLEN
+1,&canonlen
);
1676 canonlen
= MAXPATHLEN
+1-canonlen
;
1677 if (e
|| canonlen
<=0 || canonlen
>(MAXPATHLEN
+1) )
1679 if (strcmp(nameWithExt
, canon
+canonlen
-strlen(nameWithExt
))==0)
1680 return 1; /* match */
1685 #elif defined(PYOS_OS2)
1691 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1694 rc
= DosFindFirst(buf
,
1696 FILE_READONLY
| FILE_HIDDEN
| FILE_SYSTEM
| FILE_DIRECTORY
,
1697 &ffbuf
, sizeof(ffbuf
),
1702 return strncmp(ffbuf
.achName
, name
, namelen
) == 0;
1704 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1713 /* Helper to look for __init__.py or __init__.py[co] in potential package */
1715 find_init_module(char *buf
)
1717 const size_t save_len
= strlen(buf
);
1718 size_t i
= save_len
;
1719 char *pname
; /* pointer to start of __init__ */
1720 struct stat statbuf
;
1722 /* For calling case_ok(buf, len, namelen, name):
1723 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1725 * |--------------------- buf ---------------------|
1726 * |------------------- len ------------------|
1727 * |------ name -------|
1728 * |----- namelen -----|
1730 if (save_len
+ 13 >= MAXPATHLEN
)
1734 strcpy(pname
, "__init__.py");
1735 if (stat(buf
, &statbuf
) == 0) {
1737 save_len
+ 9, /* len("/__init__") */
1738 8, /* len("__init__") */
1740 buf
[save_len
] = '\0';
1745 strcpy(buf
+i
, Py_OptimizeFlag
? "o" : "c");
1746 if (stat(buf
, &statbuf
) == 0) {
1748 save_len
+ 9, /* len("/__init__") */
1749 8, /* len("__init__") */
1751 buf
[save_len
] = '\0';
1755 buf
[save_len
] = '\0';
1763 find_init_module(buf
)
1766 int save_len
= strlen(buf
);
1769 if (save_len
+ 13 >= MAXPATHLEN
)
1772 strcpy(buf
+i
, "__init__/py");
1774 buf
[save_len
] = '\0';
1778 if (Py_OptimizeFlag
)
1783 buf
[save_len
] = '\0';
1786 buf
[save_len
] = '\0';
1791 #endif /* HAVE_STAT */
1794 static int init_builtin(char *); /* Forward */
1796 /* Load an external module using the default search path and return
1797 its module object WITH INCREMENTED REFERENCE COUNT */
1800 load_module(char *name
, FILE *fp
, char *buf
, int type
, PyObject
*loader
)
1806 /* First check that there's an open file (if we need one) */
1811 PyErr_Format(PyExc_ValueError
,
1812 "file object required for import (type code %d)",
1821 m
= load_source_module(name
, buf
, fp
);
1825 m
= load_compiled_module(name
, buf
, fp
);
1828 #ifdef HAVE_DYNAMIC_LOADING
1830 m
= _PyImport_LoadDynamicModule(name
, buf
, fp
);
1835 m
= load_package(name
, buf
);
1840 if (buf
!= NULL
&& buf
[0] != '\0')
1842 if (type
== C_BUILTIN
)
1843 err
= init_builtin(name
);
1845 err
= PyImport_ImportFrozenModule(name
);
1849 PyErr_Format(PyExc_ImportError
,
1850 "Purported %s module %.200s not found",
1852 "builtin" : "frozen",
1856 modules
= PyImport_GetModuleDict();
1857 m
= PyDict_GetItemString(modules
, name
);
1861 "%s module %.200s not properly initialized",
1863 "builtin" : "frozen",
1871 if (loader
== NULL
) {
1872 PyErr_SetString(PyExc_ImportError
,
1873 "import hook without loader");
1876 m
= PyObject_CallMethod(loader
, "load_module", "s", name
);
1881 PyErr_Format(PyExc_ImportError
,
1882 "Don't know how to import %.200s (type code %d)",
1892 /* Initialize a built-in module.
1893 Return 1 for success, 0 if the module is not found, and -1 with
1894 an exception set if the initialization failed. */
1897 init_builtin(char *name
)
1901 if (_PyImport_FindExtension(name
, name
) != NULL
)
1904 for (p
= PyImport_Inittab
; p
->name
!= NULL
; p
++) {
1905 if (strcmp(name
, p
->name
) == 0) {
1906 if (p
->initfunc
== NULL
) {
1907 PyErr_Format(PyExc_ImportError
,
1908 "Cannot re-init internal module %.200s",
1913 PySys_WriteStderr("import %s # builtin\n", name
);
1915 if (PyErr_Occurred())
1917 if (_PyImport_FixupExtension(name
, name
) == NULL
)
1926 /* Frozen modules */
1928 static struct _frozen
*
1929 find_frozen(char *name
)
1933 for (p
= PyImport_FrozenModules
; ; p
++) {
1934 if (p
->name
== NULL
)
1936 if (strcmp(p
->name
, name
) == 0)
1943 get_frozen_object(char *name
)
1945 struct _frozen
*p
= find_frozen(name
);
1949 PyErr_Format(PyExc_ImportError
,
1950 "No such frozen object named %.200s",
1954 if (p
->code
== NULL
) {
1955 PyErr_Format(PyExc_ImportError
,
1956 "Excluded frozen object named %.200s",
1963 return PyMarshal_ReadObjectFromString((char *)p
->code
, size
);
1966 /* Initialize a frozen module.
1967 Return 1 for succes, 0 if the module is not found, and -1 with
1968 an exception set if the initialization failed.
1969 This function is also used from frozenmain.c */
1972 PyImport_ImportFrozenModule(char *name
)
1974 struct _frozen
*p
= find_frozen(name
);
1982 if (p
->code
== NULL
) {
1983 PyErr_Format(PyExc_ImportError
,
1984 "Excluded frozen object named %.200s",
1989 ispackage
= (size
< 0);
1993 PySys_WriteStderr("import %s # frozen%s\n",
1994 name
, ispackage
? " package" : "");
1995 co
= PyMarshal_ReadObjectFromString((char *)p
->code
, size
);
1998 if (!PyCode_Check(co
)) {
1999 PyErr_Format(PyExc_TypeError
,
2000 "frozen object %.200s is not a code object",
2005 /* Set __path__ to the package name */
2008 m
= PyImport_AddModule(name
);
2011 d
= PyModule_GetDict(m
);
2012 s
= PyString_InternFromString(name
);
2015 err
= PyDict_SetItemString(d
, "__path__", s
);
2020 m
= PyImport_ExecCodeModuleEx(name
, co
, "<frozen>");
2032 /* Import a module, either built-in, frozen, or external, and return
2033 its module object WITH INCREMENTED REFERENCE COUNT */
2036 PyImport_ImportModule(const char *name
)
2041 pname
= PyString_FromString(name
);
2044 result
= PyImport_Import(pname
);
2049 /* Import a module without blocking
2051 * At first it tries to fetch the module from sys.modules. If the module was
2052 * never loaded before it loads it with PyImport_ImportModule() unless another
2053 * thread holds the import lock. In the latter case the function raises an
2054 * ImportError instead of blocking.
2056 * Returns the module object with incremented ref count.
2059 PyImport_ImportModuleNoBlock(const char *name
)
2065 /* Try to get the module from sys.modules[name] */
2066 modules
= PyImport_GetModuleDict();
2067 if (modules
== NULL
)
2070 result
= PyDict_GetItemString(modules
, name
);
2071 if (result
!= NULL
) {
2079 /* check the import lock
2080 * me might be -1 but I ignore the error here, the lock function
2081 * takes care of the problem */
2082 me
= PyThread_get_thread_ident();
2083 if (import_lock_thread
== -1 || import_lock_thread
== me
) {
2084 /* no thread or me is holding the lock */
2085 return PyImport_ImportModule(name
);
2088 PyErr_Format(PyExc_ImportError
,
2089 "Failed to import %.200s because the import lock"
2090 "is held by another thread.",
2095 return PyImport_ImportModule(name
);
2099 /* Forward declarations for helper routines */
2100 static PyObject
*get_parent(PyObject
*globals
, char *buf
,
2101 Py_ssize_t
*p_buflen
, int level
);
2102 static PyObject
*load_next(PyObject
*mod
, PyObject
*altmod
,
2103 char **p_name
, char *buf
, Py_ssize_t
*p_buflen
);
2104 static int mark_miss(char *name
);
2105 static int ensure_fromlist(PyObject
*mod
, PyObject
*fromlist
,
2106 char *buf
, Py_ssize_t buflen
, int recursive
);
2107 static PyObject
* import_submodule(PyObject
*mod
, char *name
, char *fullname
);
2109 /* The Magnum Opus of dotted-name import :-) */
2112 import_module_level(char *name
, PyObject
*globals
, PyObject
*locals
,
2113 PyObject
*fromlist
, int level
)
2115 char buf
[MAXPATHLEN
+1];
2116 Py_ssize_t buflen
= 0;
2117 PyObject
*parent
, *head
, *next
, *tail
;
2119 if (strchr(name
, '/') != NULL
2121 || strchr(name
, '\\') != NULL
2124 PyErr_SetString(PyExc_ImportError
,
2125 "Import by filename is not supported.");
2129 parent
= get_parent(globals
, buf
, &buflen
, level
);
2133 head
= load_next(parent
, Py_None
, &name
, buf
, &buflen
);
2140 next
= load_next(tail
, tail
, &name
, buf
, &buflen
);
2148 if (tail
== Py_None
) {
2149 /* If tail is Py_None, both get_parent and load_next found
2150 an empty module name: someone called __import__("") or
2151 doctored faulty bytecode */
2154 PyErr_SetString(PyExc_ValueError
,
2155 "Empty module name");
2159 if (fromlist
!= NULL
) {
2160 if (fromlist
== Py_None
|| !PyObject_IsTrue(fromlist
))
2164 if (fromlist
== NULL
) {
2170 if (!ensure_fromlist(tail
, fromlist
, buf
, buflen
, 0)) {
2179 PyImport_ImportModuleLevel(char *name
, PyObject
*globals
, PyObject
*locals
,
2180 PyObject
*fromlist
, int level
)
2184 result
= import_module_level(name
, globals
, locals
, fromlist
, level
);
2185 if (unlock_import() < 0) {
2187 PyErr_SetString(PyExc_RuntimeError
,
2188 "not holding the import lock");
2194 /* Return the package that an import is being performed in. If globals comes
2195 from the module foo.bar.bat (not itself a package), this returns the
2196 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2197 the package's entry in sys.modules is returned, as a borrowed reference.
2199 The *name* of the returned package is returned in buf, with the length of
2200 the name in *p_buflen.
2202 If globals doesn't come from a package or a module in a package, or a
2203 corresponding entry is not found in sys.modules, Py_None is returned.
2206 get_parent(PyObject
*globals
, char *buf
, Py_ssize_t
*p_buflen
, int level
)
2208 static PyObject
*namestr
= NULL
;
2209 static PyObject
*pathstr
= NULL
;
2210 static PyObject
*pkgstr
= NULL
;
2211 PyObject
*pkgname
, *modname
, *modpath
, *modules
, *parent
;
2212 int orig_level
= level
;
2214 if (globals
== NULL
|| !PyDict_Check(globals
) || !level
)
2217 if (namestr
== NULL
) {
2218 namestr
= PyString_InternFromString("__name__");
2219 if (namestr
== NULL
)
2222 if (pathstr
== NULL
) {
2223 pathstr
= PyString_InternFromString("__path__");
2224 if (pathstr
== NULL
)
2227 if (pkgstr
== NULL
) {
2228 pkgstr
= PyString_InternFromString("__package__");
2235 pkgname
= PyDict_GetItem(globals
, pkgstr
);
2237 if ((pkgname
!= NULL
) && (pkgname
!= Py_None
)) {
2238 /* __package__ is set, so use it */
2240 if (!PyString_Check(pkgname
)) {
2241 PyErr_SetString(PyExc_ValueError
,
2242 "__package__ set to non-string");
2245 len
= PyString_GET_SIZE(pkgname
);
2248 PyErr_SetString(PyExc_ValueError
,
2249 "Attempted relative import in non-package");
2254 if (len
> MAXPATHLEN
) {
2255 PyErr_SetString(PyExc_ValueError
,
2256 "Package name too long");
2259 strcpy(buf
, PyString_AS_STRING(pkgname
));
2261 /* __package__ not set, so figure it out and set it */
2262 modname
= PyDict_GetItem(globals
, namestr
);
2263 if (modname
== NULL
|| !PyString_Check(modname
))
2266 modpath
= PyDict_GetItem(globals
, pathstr
);
2267 if (modpath
!= NULL
) {
2268 /* __path__ is set, so modname is already the package name */
2269 Py_ssize_t len
= PyString_GET_SIZE(modname
);
2271 if (len
> MAXPATHLEN
) {
2272 PyErr_SetString(PyExc_ValueError
,
2273 "Module name too long");
2276 strcpy(buf
, PyString_AS_STRING(modname
));
2277 error
= PyDict_SetItem(globals
, pkgstr
, modname
);
2279 PyErr_SetString(PyExc_ValueError
,
2280 "Could not set __package__");
2284 /* Normal module, so work out the package name if any */
2285 char *start
= PyString_AS_STRING(modname
);
2286 char *lastdot
= strrchr(start
, '.');
2289 if (lastdot
== NULL
&& level
> 0) {
2290 PyErr_SetString(PyExc_ValueError
,
2291 "Attempted relative import in non-package");
2294 if (lastdot
== NULL
) {
2295 error
= PyDict_SetItem(globals
, pkgstr
, Py_None
);
2297 PyErr_SetString(PyExc_ValueError
,
2298 "Could not set __package__");
2303 len
= lastdot
- start
;
2304 if (len
>= MAXPATHLEN
) {
2305 PyErr_SetString(PyExc_ValueError
,
2306 "Module name too long");
2309 strncpy(buf
, start
, len
);
2311 pkgname
= PyString_FromString(buf
);
2312 if (pkgname
== NULL
) {
2315 error
= PyDict_SetItem(globals
, pkgstr
, pkgname
);
2318 PyErr_SetString(PyExc_ValueError
,
2319 "Could not set __package__");
2324 while (--level
> 0) {
2325 char *dot
= strrchr(buf
, '.');
2327 PyErr_SetString(PyExc_ValueError
,
2328 "Attempted relative import beyond "
2329 "toplevel package");
2334 *p_buflen
= strlen(buf
);
2336 modules
= PyImport_GetModuleDict();
2337 parent
= PyDict_GetItemString(modules
, buf
);
2338 if (parent
== NULL
) {
2339 if (orig_level
< 1) {
2340 PyObject
*err_msg
= PyString_FromFormat(
2341 "Parent module '%.200s' not found "
2342 "while handling absolute import", buf
);
2343 if (err_msg
== NULL
) {
2346 if (!PyErr_WarnEx(PyExc_RuntimeWarning
,
2347 PyString_AsString(err_msg
), 1)) {
2354 PyErr_Format(PyExc_SystemError
,
2355 "Parent module '%.200s' not loaded, "
2356 "cannot perform relative import", buf
);
2360 /* We expect, but can't guarantee, if parent != None, that:
2361 - parent.__name__ == buf
2362 - parent.__dict__ is globals
2363 If this is violated... Who cares? */
2366 /* altmod is either None or same as mod */
2368 load_next(PyObject
*mod
, PyObject
*altmod
, char **p_name
, char *buf
,
2369 Py_ssize_t
*p_buflen
)
2371 char *name
= *p_name
;
2372 char *dot
= strchr(name
, '.');
2377 if (strlen(name
) == 0) {
2378 /* completely empty module name should only happen in
2379 'from . import' (or '__import__("")')*/
2394 PyErr_SetString(PyExc_ValueError
,
2395 "Empty module name");
2399 p
= buf
+ *p_buflen
;
2402 if (p
+len
-buf
>= MAXPATHLEN
) {
2403 PyErr_SetString(PyExc_ValueError
,
2404 "Module name too long");
2407 strncpy(p
, name
, len
);
2409 *p_buflen
= p
+len
-buf
;
2411 result
= import_submodule(mod
, p
, buf
);
2412 if (result
== Py_None
&& altmod
!= mod
) {
2414 /* Here, altmod must be None and mod must not be None */
2415 result
= import_submodule(altmod
, p
, p
);
2416 if (result
!= NULL
&& result
!= Py_None
) {
2417 if (mark_miss(buf
) != 0) {
2421 strncpy(buf
, name
, len
);
2429 if (result
== Py_None
) {
2431 PyErr_Format(PyExc_ImportError
,
2432 "No module named %.200s", name
);
2440 mark_miss(char *name
)
2442 PyObject
*modules
= PyImport_GetModuleDict();
2443 return PyDict_SetItemString(modules
, name
, Py_None
);
2447 ensure_fromlist(PyObject
*mod
, PyObject
*fromlist
, char *buf
, Py_ssize_t buflen
,
2452 if (!PyObject_HasAttrString(mod
, "__path__"))
2455 for (i
= 0; ; i
++) {
2456 PyObject
*item
= PySequence_GetItem(fromlist
, i
);
2459 if (PyErr_ExceptionMatches(PyExc_IndexError
)) {
2465 if (!PyString_Check(item
)) {
2466 PyErr_SetString(PyExc_TypeError
,
2467 "Item in ``from list'' not a string");
2471 if (PyString_AS_STRING(item
)[0] == '*') {
2474 /* See if the package defines __all__ */
2476 continue; /* Avoid endless recursion */
2477 all
= PyObject_GetAttrString(mod
, "__all__");
2481 int ret
= ensure_fromlist(mod
, all
, buf
, buflen
, 1);
2488 hasit
= PyObject_HasAttr(mod
, item
);
2490 char *subname
= PyString_AS_STRING(item
);
2493 if (buflen
+ strlen(subname
) >= MAXPATHLEN
) {
2494 PyErr_SetString(PyExc_ValueError
,
2495 "Module name too long");
2502 submod
= import_submodule(mod
, subname
, buf
);
2504 if (submod
== NULL
) {
2516 add_submodule(PyObject
*mod
, PyObject
*submod
, char *fullname
, char *subname
,
2521 /* Irrespective of the success of this load, make a
2522 reference to it in the parent package module. A copy gets
2523 saved in the modules dictionary under the full name, so get a
2524 reference from there, if need be. (The exception is when the
2525 load failed with a SyntaxError -- then there's no trace in
2526 sys.modules. In that case, of course, do nothing extra.) */
2527 if (submod
== NULL
) {
2528 submod
= PyDict_GetItemString(modules
, fullname
);
2532 if (PyModule_Check(mod
)) {
2533 /* We can't use setattr here since it can give a
2534 * spurious warning if the submodule name shadows a
2536 PyObject
*dict
= PyModule_GetDict(mod
);
2539 if (PyDict_SetItemString(dict
, subname
, submod
) < 0)
2543 if (PyObject_SetAttrString(mod
, subname
, submod
) < 0)
2550 import_submodule(PyObject
*mod
, char *subname
, char *fullname
)
2552 PyObject
*modules
= PyImport_GetModuleDict();
2556 if mod == None: subname == fullname
2557 else: mod.__name__ + "." + subname == fullname
2560 if ((m
= PyDict_GetItemString(modules
, fullname
)) != NULL
) {
2564 PyObject
*path
, *loader
= NULL
;
2565 char buf
[MAXPATHLEN
+1];
2566 struct filedescr
*fdp
;
2572 path
= PyObject_GetAttrString(mod
, "__path__");
2581 fdp
= find_module(fullname
, subname
, path
, buf
, MAXPATHLEN
+1,
2585 if (!PyErr_ExceptionMatches(PyExc_ImportError
))
2591 m
= load_module(fullname
, fp
, buf
, fdp
->type
, loader
);
2595 if (!add_submodule(mod
, m
, fullname
, subname
, modules
)) {
2605 /* Re-import a module of any kind and return its module object, WITH
2606 INCREMENTED REFERENCE COUNT */
2609 PyImport_ReloadModule(PyObject
*m
)
2611 PyInterpreterState
*interp
= PyThreadState_Get()->interp
;
2612 PyObject
*modules_reloading
= interp
->modules_reloading
;
2613 PyObject
*modules
= PyImport_GetModuleDict();
2614 PyObject
*path
= NULL
, *loader
= NULL
, *existing_m
= NULL
;
2615 char *name
, *subname
;
2616 char buf
[MAXPATHLEN
+1];
2617 struct filedescr
*fdp
;
2621 if (modules_reloading
== NULL
) {
2622 Py_FatalError("PyImport_ReloadModule: "
2623 "no modules_reloading dictionary!");
2627 if (m
== NULL
|| !PyModule_Check(m
)) {
2628 PyErr_SetString(PyExc_TypeError
,
2629 "reload() argument must be module");
2632 name
= PyModule_GetName(m
);
2635 if (m
!= PyDict_GetItemString(modules
, name
)) {
2636 PyErr_Format(PyExc_ImportError
,
2637 "reload(): module %.200s not in sys.modules",
2641 existing_m
= PyDict_GetItemString(modules_reloading
, name
);
2642 if (existing_m
!= NULL
) {
2643 /* Due to a recursive reload, this module is already
2645 Py_INCREF(existing_m
);
2648 if (PyDict_SetItemString(modules_reloading
, name
, m
) < 0)
2651 subname
= strrchr(name
, '.');
2652 if (subname
== NULL
)
2655 PyObject
*parentname
, *parent
;
2656 parentname
= PyString_FromStringAndSize(name
, (subname
-name
));
2657 if (parentname
== NULL
) {
2658 imp_modules_reloading_clear();
2661 parent
= PyDict_GetItem(modules
, parentname
);
2662 if (parent
== NULL
) {
2663 PyErr_Format(PyExc_ImportError
,
2664 "reload(): parent %.200s not in sys.modules",
2665 PyString_AS_STRING(parentname
));
2666 Py_DECREF(parentname
);
2667 imp_modules_reloading_clear();
2670 Py_DECREF(parentname
);
2672 path
= PyObject_GetAttrString(parent
, "__path__");
2677 fdp
= find_module(name
, subname
, path
, buf
, MAXPATHLEN
+1, &fp
, &loader
);
2682 imp_modules_reloading_clear();
2686 newm
= load_module(name
, fp
, buf
, fdp
->type
, loader
);
2692 /* load_module probably removed name from modules because of
2693 * the error. Put back the original module object. We're
2694 * going to return NULL in this case regardless of whether
2695 * replacing name succeeds, so the return value is ignored.
2697 PyDict_SetItemString(modules
, name
, m
);
2699 imp_modules_reloading_clear();
2704 /* Higher-level import emulator which emulates the "import" statement
2705 more accurately -- it invokes the __import__() function from the
2706 builtins of the current globals. This means that the import is
2707 done using whatever import hooks are installed in the current
2708 environment, e.g. by "rexec".
2709 A dummy list ["__doc__"] is passed as the 4th argument so that
2710 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2711 will return <module "gencache"> instead of <module "win32com">. */
2714 PyImport_Import(PyObject
*module_name
)
2716 static PyObject
*silly_list
= NULL
;
2717 static PyObject
*builtins_str
= NULL
;
2718 static PyObject
*import_str
= NULL
;
2719 PyObject
*globals
= NULL
;
2720 PyObject
*import
= NULL
;
2721 PyObject
*builtins
= NULL
;
2724 /* Initialize constant string objects */
2725 if (silly_list
== NULL
) {
2726 import_str
= PyString_InternFromString("__import__");
2727 if (import_str
== NULL
)
2729 builtins_str
= PyString_InternFromString("__builtins__");
2730 if (builtins_str
== NULL
)
2732 silly_list
= Py_BuildValue("[s]", "__doc__");
2733 if (silly_list
== NULL
)
2737 /* Get the builtins from current globals */
2738 globals
= PyEval_GetGlobals();
2739 if (globals
!= NULL
) {
2741 builtins
= PyObject_GetItem(globals
, builtins_str
);
2742 if (builtins
== NULL
)
2746 /* No globals -- use standard builtins, and fake globals */
2749 builtins
= PyImport_ImportModuleLevel("__builtin__",
2750 NULL
, NULL
, NULL
, 0);
2751 if (builtins
== NULL
)
2753 globals
= Py_BuildValue("{OO}", builtins_str
, builtins
);
2754 if (globals
== NULL
)
2758 /* Get the __import__ function from the builtins */
2759 if (PyDict_Check(builtins
)) {
2760 import
= PyObject_GetItem(builtins
, import_str
);
2762 PyErr_SetObject(PyExc_KeyError
, import_str
);
2765 import
= PyObject_GetAttr(builtins
, import_str
);
2769 /* Call the __import__ function with the proper argument list
2770 * Always use absolute import here. */
2771 r
= PyObject_CallFunction(import
, "OOOOi", module_name
, globals
,
2772 globals
, silly_list
, 0, NULL
);
2775 Py_XDECREF(globals
);
2776 Py_XDECREF(builtins
);
2783 /* Module 'imp' provides Python access to the primitives used for
2788 imp_get_magic(PyObject
*self
, PyObject
*noargs
)
2792 buf
[0] = (char) ((pyc_magic
>> 0) & 0xff);
2793 buf
[1] = (char) ((pyc_magic
>> 8) & 0xff);
2794 buf
[2] = (char) ((pyc_magic
>> 16) & 0xff);
2795 buf
[3] = (char) ((pyc_magic
>> 24) & 0xff);
2797 return PyString_FromStringAndSize(buf
, 4);
2801 imp_get_suffixes(PyObject
*self
, PyObject
*noargs
)
2804 struct filedescr
*fdp
;
2806 list
= PyList_New(0);
2809 for (fdp
= _PyImport_Filetab
; fdp
->suffix
!= NULL
; fdp
++) {
2810 PyObject
*item
= Py_BuildValue("ssi",
2811 fdp
->suffix
, fdp
->mode
, fdp
->type
);
2816 if (PyList_Append(list
, item
) < 0) {
2827 call_find_module(char *name
, PyObject
*path
)
2829 extern int fclose(FILE *);
2830 PyObject
*fob
, *ret
;
2831 struct filedescr
*fdp
;
2832 char pathname
[MAXPATHLEN
+1];
2836 if (path
== Py_None
)
2838 fdp
= find_module(NULL
, name
, path
, pathname
, MAXPATHLEN
+1, &fp
, NULL
);
2842 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
);