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 */
910 assert(mtime
< LONG_MAX
);
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_TIME_T > 4
983 /* Python's .pyc timestamp handling presumes that the timestamp fits
984 in 4 bytes. This will be fine until sometime in the year 2038,
985 when a 4-byte signed time_t will overflow.
987 if (st
.st_mtime
>> 32) {
988 PyErr_SetString(PyExc_OverflowError
,
989 "modification time overflows a 4 byte field");
993 cpathname
= make_compiled_pathname(pathname
, buf
,
994 (size_t)MAXPATHLEN
+ 1);
995 if (cpathname
!= NULL
&&
996 (fpc
= check_compiled_module(pathname
, st
.st_mtime
, cpathname
))) {
997 co
= read_compiled_module(cpathname
, fpc
);
1001 if (update_compiled_module(co
, pathname
) < 0)
1004 PySys_WriteStderr("import %s # precompiled from %s\n",
1006 pathname
= cpathname
;
1009 co
= parse_source_module(pathname
, fp
);
1013 PySys_WriteStderr("import %s # from %s\n",
1016 PyObject
*ro
= PySys_GetObject("dont_write_bytecode");
1017 if (ro
== NULL
|| !PyObject_IsTrue(ro
))
1018 write_compiled_module(co
, cpathname
, &st
);
1021 m
= PyImport_ExecCodeModuleEx(name
, (PyObject
*)co
, pathname
);
1029 static PyObject
*load_module(char *, FILE *, char *, int, PyObject
*);
1030 static struct filedescr
*find_module(char *, char *, PyObject
*,
1031 char *, size_t, FILE **, PyObject
**);
1032 static struct _frozen
*find_frozen(char *name
);
1034 /* Load a package and return its module object WITH INCREMENTED
1038 load_package(char *name
, char *pathname
)
1041 PyObject
*file
= NULL
;
1042 PyObject
*path
= NULL
;
1044 char buf
[MAXPATHLEN
+1];
1046 struct filedescr
*fdp
;
1048 m
= PyImport_AddModule(name
);
1052 PySys_WriteStderr("import %s # directory %s\n",
1054 d
= PyModule_GetDict(m
);
1055 file
= PyString_FromString(pathname
);
1058 path
= Py_BuildValue("[O]", file
);
1061 err
= PyDict_SetItemString(d
, "__file__", file
);
1063 err
= PyDict_SetItemString(d
, "__path__", path
);
1067 fdp
= find_module(name
, "__init__", path
, buf
, sizeof(buf
), &fp
, NULL
);
1069 if (PyErr_ExceptionMatches(PyExc_ImportError
)) {
1077 m
= load_module(name
, fp
, buf
, fdp
->type
, NULL
);
1091 /* Helper to test for built-in module */
1094 is_builtin(char *name
)
1097 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++) {
1098 if (strcmp(name
, PyImport_Inittab
[i
].name
) == 0) {
1099 if (PyImport_Inittab
[i
].initfunc
== NULL
)
1109 /* Return an importer object for a sys.path/pkg.__path__ item 'p',
1110 possibly by fetching it from the path_importer_cache dict. If it
1111 wasn't yet cached, traverse path_hooks until a hook is found
1112 that can handle the path item. Return None if no hook could;
1113 this tells our caller it should fall back to the builtin
1114 import mechanism. Cache the result in path_importer_cache.
1115 Returns a borrowed reference. */
1118 get_path_importer(PyObject
*path_importer_cache
, PyObject
*path_hooks
,
1122 Py_ssize_t j
, nhooks
;
1124 /* These conditions are the caller's responsibility: */
1125 assert(PyList_Check(path_hooks
));
1126 assert(PyDict_Check(path_importer_cache
));
1128 nhooks
= PyList_Size(path_hooks
);
1130 return NULL
; /* Shouldn't happen */
1132 importer
= PyDict_GetItem(path_importer_cache
, p
);
1133 if (importer
!= NULL
)
1136 /* set path_importer_cache[p] to None to avoid recursion */
1137 if (PyDict_SetItem(path_importer_cache
, p
, Py_None
) != 0)
1140 for (j
= 0; j
< nhooks
; j
++) {
1141 PyObject
*hook
= PyList_GetItem(path_hooks
, j
);
1144 importer
= PyObject_CallFunctionObjArgs(hook
, p
, NULL
);
1145 if (importer
!= NULL
)
1148 if (!PyErr_ExceptionMatches(PyExc_ImportError
)) {
1153 if (importer
== NULL
) {
1154 importer
= PyObject_CallFunctionObjArgs(
1155 (PyObject
*)&PyNullImporter_Type
, p
, NULL
1157 if (importer
== NULL
) {
1158 if (PyErr_ExceptionMatches(PyExc_ImportError
)) {
1164 if (importer
!= NULL
) {
1165 int err
= PyDict_SetItem(path_importer_cache
, p
, importer
);
1166 Py_DECREF(importer
);
1173 PyAPI_FUNC(PyObject
*)
1174 PyImport_GetImporter(PyObject
*path
) {
1175 PyObject
*importer
=NULL
, *path_importer_cache
=NULL
, *path_hooks
=NULL
;
1177 if ((path_importer_cache
= PySys_GetObject("path_importer_cache"))) {
1178 if ((path_hooks
= PySys_GetObject("path_hooks"))) {
1179 importer
= get_path_importer(path_importer_cache
,
1183 Py_XINCREF(importer
); /* get_path_importer returns a borrowed reference */
1187 /* Search the path (default sys.path) for a module. Return the
1188 corresponding filedescr struct, and (via return arguments) the
1189 pathname and an open file. Return NULL if the module is not found. */
1192 extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr
**,
1193 char *, Py_ssize_t
);
1196 static int case_ok(char *, Py_ssize_t
, Py_ssize_t
, char *);
1197 static int find_init_module(char *); /* Forward */
1198 static struct filedescr importhookdescr
= {"", "", IMP_HOOK
};
1200 static struct filedescr
*
1201 find_module(char *fullname
, char *subname
, PyObject
*path
, char *buf
,
1202 size_t buflen
, FILE **p_fp
, PyObject
**p_loader
)
1204 Py_ssize_t i
, npath
;
1205 size_t len
, namelen
;
1206 struct filedescr
*fdp
= NULL
;
1209 PyObject
*path_hooks
, *path_importer_cache
;
1211 struct stat statbuf
;
1213 static struct filedescr fd_frozen
= {"", "", PY_FROZEN
};
1214 static struct filedescr fd_builtin
= {"", "", C_BUILTIN
};
1215 static struct filedescr fd_package
= {"", "", PKG_DIRECTORY
};
1216 char name
[MAXPATHLEN
+1];
1217 #if defined(PYOS_OS2)
1219 size_t saved_namelen
;
1220 char *saved_buf
= NULL
;
1222 if (p_loader
!= NULL
)
1225 if (strlen(subname
) > MAXPATHLEN
) {
1226 PyErr_SetString(PyExc_OverflowError
,
1227 "module name is too long");
1230 strcpy(name
, subname
);
1232 /* sys.meta_path import hook */
1233 if (p_loader
!= NULL
) {
1234 PyObject
*meta_path
;
1236 meta_path
= PySys_GetObject("meta_path");
1237 if (meta_path
== NULL
|| !PyList_Check(meta_path
)) {
1238 PyErr_SetString(PyExc_ImportError
,
1239 "sys.meta_path must be a list of "
1243 Py_INCREF(meta_path
); /* zap guard */
1244 npath
= PyList_Size(meta_path
);
1245 for (i
= 0; i
< npath
; i
++) {
1247 PyObject
*hook
= PyList_GetItem(meta_path
, i
);
1248 loader
= PyObject_CallMethod(hook
, "find_module",
1252 if (loader
== NULL
) {
1253 Py_DECREF(meta_path
);
1254 return NULL
; /* true error */
1256 if (loader
!= Py_None
) {
1257 /* a loader was found */
1259 Py_DECREF(meta_path
);
1260 return &importhookdescr
;
1264 Py_DECREF(meta_path
);
1267 if (path
!= NULL
&& PyString_Check(path
)) {
1268 /* The only type of submodule allowed inside a "frozen"
1269 package are other frozen modules or packages. */
1270 if (PyString_Size(path
) + 1 + strlen(name
) >= (size_t)buflen
) {
1271 PyErr_SetString(PyExc_ImportError
,
1272 "full frozen module name too long");
1275 strcpy(buf
, PyString_AsString(path
));
1279 if (find_frozen(name
) != NULL
) {
1283 PyErr_Format(PyExc_ImportError
,
1284 "No frozen submodule named %.200s", name
);
1288 if (is_builtin(name
)) {
1292 if ((find_frozen(name
)) != NULL
) {
1298 fp
= PyWin_FindRegisteredModule(name
, &fdp
, buf
, buflen
);
1304 path
= PySys_GetObject("path");
1306 if (path
== NULL
|| !PyList_Check(path
)) {
1307 PyErr_SetString(PyExc_ImportError
,
1308 "sys.path must be a list of directory names");
1312 path_hooks
= PySys_GetObject("path_hooks");
1313 if (path_hooks
== NULL
|| !PyList_Check(path_hooks
)) {
1314 PyErr_SetString(PyExc_ImportError
,
1315 "sys.path_hooks must be a list of "
1319 path_importer_cache
= PySys_GetObject("path_importer_cache");
1320 if (path_importer_cache
== NULL
||
1321 !PyDict_Check(path_importer_cache
)) {
1322 PyErr_SetString(PyExc_ImportError
,
1323 "sys.path_importer_cache must be a dict");
1327 npath
= PyList_Size(path
);
1328 namelen
= strlen(name
);
1329 for (i
= 0; i
< npath
; i
++) {
1330 PyObject
*copy
= NULL
;
1331 PyObject
*v
= PyList_GetItem(path
, i
);
1334 #ifdef Py_USING_UNICODE
1335 if (PyUnicode_Check(v
)) {
1336 copy
= PyUnicode_Encode(PyUnicode_AS_UNICODE(v
),
1337 PyUnicode_GET_SIZE(v
), Py_FileSystemDefaultEncoding
, NULL
);
1344 if (!PyString_Check(v
))
1346 len
= PyString_GET_SIZE(v
);
1347 if (len
+ 2 + namelen
+ MAXSUFFIXSIZE
>= buflen
) {
1349 continue; /* Too long */
1351 strcpy(buf
, PyString_AS_STRING(v
));
1352 if (strlen(buf
) != len
) {
1354 continue; /* v contains '\0' */
1357 /* sys.path_hooks import hook */
1358 if (p_loader
!= NULL
) {
1361 importer
= get_path_importer(path_importer_cache
,
1363 if (importer
== NULL
) {
1367 /* Note: importer is a borrowed reference */
1368 if (importer
!= Py_None
) {
1370 loader
= PyObject_CallMethod(importer
,
1375 return NULL
; /* error */
1376 if (loader
!= Py_None
) {
1377 /* a loader was found */
1379 return &importhookdescr
;
1385 /* no hook was found, use builtin import */
1387 if (len
> 0 && buf
[len
-1] != SEP
1389 && buf
[len
-1] != ALTSEP
1393 strcpy(buf
+len
, name
);
1396 /* Check for package import (buf holds a directory name,
1397 and there's an __init__ module in that directory */
1399 if (stat(buf
, &statbuf
) == 0 && /* it exists */
1400 S_ISDIR(statbuf
.st_mode
) && /* it's a directory */
1401 case_ok(buf
, len
, namelen
, name
)) { /* case matches */
1402 if (find_init_module(buf
)) { /* and has __init__.py */
1407 char warnstr
[MAXPATHLEN
+80];
1408 sprintf(warnstr
, "Not importing directory "
1409 "'%.*s': missing __init__.py",
1411 if (PyErr_Warn(PyExc_ImportWarning
,
1419 /* XXX How are you going to test for directories? */
1422 case_ok(buf
, len
, namelen
, name
)) {
1423 if (find_init_module(buf
)) {
1428 char warnstr
[MAXPATHLEN
+80];
1429 sprintf(warnstr
, "Not importing directory "
1430 "'%.*s': missing __init__.py",
1432 if (PyErr_Warn(PyExc_ImportWarning
,
1440 #if defined(PYOS_OS2)
1441 /* take a snapshot of the module spec for restoration
1442 * after the 8 character DLL hackery
1444 saved_buf
= strdup(buf
);
1446 saved_namelen
= namelen
;
1447 #endif /* PYOS_OS2 */
1448 for (fdp
= _PyImport_Filetab
; fdp
->suffix
!= NULL
; fdp
++) {
1449 #if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
1450 /* OS/2 limits DLLs to 8 character names (w/o
1452 * so if the name is longer than that and its a
1453 * dynamically loaded module we're going to try,
1454 * truncate the name before trying
1456 if (strlen(subname
) > 8) {
1457 /* is this an attempt to load a C extension? */
1458 const struct filedescr
*scan
;
1459 scan
= _PyImport_DynLoadFiletab
;
1460 while (scan
->suffix
!= NULL
) {
1461 if (!strcmp(scan
->suffix
, fdp
->suffix
))
1466 if (scan
->suffix
!= NULL
) {
1467 /* yes, so truncate the name */
1469 len
-= strlen(subname
) - namelen
;
1473 #endif /* PYOS_OS2 */
1474 strcpy(buf
+len
, fdp
->suffix
);
1475 if (Py_VerboseFlag
> 1)
1476 PySys_WriteStderr("# trying %s\n", buf
);
1477 filemode
= fdp
->mode
;
1478 if (filemode
[0] == 'U')
1479 filemode
= "r" PY_STDIOTEXTMODE
;
1480 fp
= fopen(buf
, filemode
);
1482 if (case_ok(buf
, len
, namelen
, name
))
1484 else { /* continue search */
1489 #if defined(PYOS_OS2)
1490 /* restore the saved snapshot */
1491 strcpy(buf
, saved_buf
);
1493 namelen
= saved_namelen
;
1496 #if defined(PYOS_OS2)
1497 /* don't need/want the module name snapshot anymore */
1509 PyErr_Format(PyExc_ImportError
,
1510 "No module named %.200s", name
);
1517 /* Helpers for main.c
1518 * Find the source file corresponding to a named module
1521 _PyImport_FindModule(const char *name
, PyObject
*path
, char *buf
,
1522 size_t buflen
, FILE **p_fp
, PyObject
**p_loader
)
1524 return find_module((char *) name
, (char *) name
, path
,
1525 buf
, buflen
, p_fp
, p_loader
);
1528 PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr
* fd
)
1530 return fd
->type
== PY_SOURCE
|| fd
->type
== PY_COMPILED
;
1533 /* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
1534 * The arguments here are tricky, best shown by example:
1535 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1537 * |--------------------- buf ---------------------|
1538 * |------------------- len ------------------|
1539 * |------ name -------|
1540 * |----- namelen -----|
1541 * buf is the full path, but len only counts up to (& exclusive of) the
1542 * extension. name is the module name, also exclusive of extension.
1544 * We've already done a successful stat() or fopen() on buf, so know that
1545 * there's some match, possibly case-insensitive.
1547 * case_ok() is to return 1 if there's a case-sensitive match for
1548 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1551 * case_ok() is used to implement case-sensitive import semantics even
1552 * on platforms with case-insensitive filesystems. It's trivial to implement
1553 * for case-sensitive filesystems. It's pretty much a cross-platform
1554 * nightmare for systems with case-insensitive filesystems.
1557 /* First we may need a pile of platform-specific header files; the sequence
1558 * of #if's here should match the sequence in the body of case_ok().
1560 #if defined(MS_WINDOWS)
1561 #include <windows.h>
1563 #elif defined(DJGPP)
1566 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1567 #include <sys/types.h>
1570 #elif defined(PYOS_OS2)
1572 #define INCL_DOSERRORS
1573 #define INCL_NOPMAPI
1576 #elif defined(RISCOS)
1577 #include "oslib/osfscontrol.h"
1581 case_ok(char *buf
, Py_ssize_t len
, Py_ssize_t namelen
, char *name
)
1583 /* Pick a platform-specific implementation; the sequence of #if's here should
1584 * match the sequence just above.
1588 #if defined(MS_WINDOWS)
1589 WIN32_FIND_DATA data
;
1592 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1595 h
= FindFirstFile(buf
, &data
);
1596 if (h
== INVALID_HANDLE_VALUE
) {
1597 PyErr_Format(PyExc_NameError
,
1598 "Can't find file for module %.100s\n(filename %.300s)",
1603 return strncmp(data
.cFileName
, name
, namelen
) == 0;
1606 #elif defined(DJGPP)
1610 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1613 done
= findfirst(buf
, &ffblk
, FA_ARCH
|FA_RDONLY
|FA_HIDDEN
|FA_DIREC
);
1615 PyErr_Format(PyExc_NameError
,
1616 "Can't find file for module %.100s\n(filename %.300s)",
1620 return strncmp(ffblk
.ff_name
, name
, namelen
) == 0;
1622 /* new-fangled macintosh (macosx) or Cygwin */
1623 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1626 char dirname
[MAXPATHLEN
+ 1];
1627 const int dirlen
= len
- namelen
- 1; /* don't want trailing SEP */
1629 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1632 /* Copy the dir component into dirname; substitute "." if empty */
1638 assert(dirlen
<= MAXPATHLEN
);
1639 memcpy(dirname
, buf
, dirlen
);
1640 dirname
[dirlen
] = '\0';
1642 /* Open the directory and search the entries for an exact match. */
1643 dirp
= opendir(dirname
);
1645 char *nameWithExt
= buf
+ len
- namelen
;
1646 while ((dp
= readdir(dirp
)) != NULL
) {
1648 #ifdef _DIRENT_HAVE_D_NAMELEN
1653 if (thislen
>= namelen
&&
1654 strcmp(dp
->d_name
, nameWithExt
) == 0) {
1655 (void)closedir(dirp
);
1656 return 1; /* Found */
1659 (void)closedir(dirp
);
1661 return 0 ; /* Not found */
1664 #elif defined(RISCOS)
1665 char canon
[MAXPATHLEN
+1]; /* buffer for the canonical form of the path */
1666 char buf2
[MAXPATHLEN
+2];
1667 char *nameWithExt
= buf
+len
-namelen
;
1671 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1675 append wildcard, otherwise case of filename wouldn't be touched */
1679 e
= xosfscontrol_canonicalise_path(buf2
,canon
,0,0,MAXPATHLEN
+1,&canonlen
);
1680 canonlen
= MAXPATHLEN
+1-canonlen
;
1681 if (e
|| canonlen
<=0 || canonlen
>(MAXPATHLEN
+1) )
1683 if (strcmp(nameWithExt
, canon
+canonlen
-strlen(nameWithExt
))==0)
1684 return 1; /* match */
1689 #elif defined(PYOS_OS2)
1695 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1698 rc
= DosFindFirst(buf
,
1700 FILE_READONLY
| FILE_HIDDEN
| FILE_SYSTEM
| FILE_DIRECTORY
,
1701 &ffbuf
, sizeof(ffbuf
),
1706 return strncmp(ffbuf
.achName
, name
, namelen
) == 0;
1708 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1717 /* Helper to look for __init__.py or __init__.py[co] in potential package */
1719 find_init_module(char *buf
)
1721 const size_t save_len
= strlen(buf
);
1722 size_t i
= save_len
;
1723 char *pname
; /* pointer to start of __init__ */
1724 struct stat statbuf
;
1726 /* For calling case_ok(buf, len, namelen, name):
1727 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1729 * |--------------------- buf ---------------------|
1730 * |------------------- len ------------------|
1731 * |------ name -------|
1732 * |----- namelen -----|
1734 if (save_len
+ 13 >= MAXPATHLEN
)
1738 strcpy(pname
, "__init__.py");
1739 if (stat(buf
, &statbuf
) == 0) {
1741 save_len
+ 9, /* len("/__init__") */
1742 8, /* len("__init__") */
1744 buf
[save_len
] = '\0';
1749 strcpy(buf
+i
, Py_OptimizeFlag
? "o" : "c");
1750 if (stat(buf
, &statbuf
) == 0) {
1752 save_len
+ 9, /* len("/__init__") */
1753 8, /* len("__init__") */
1755 buf
[save_len
] = '\0';
1759 buf
[save_len
] = '\0';
1767 find_init_module(buf
)
1770 int save_len
= strlen(buf
);
1773 if (save_len
+ 13 >= MAXPATHLEN
)
1776 strcpy(buf
+i
, "__init__/py");
1778 buf
[save_len
] = '\0';
1782 if (Py_OptimizeFlag
)
1787 buf
[save_len
] = '\0';
1790 buf
[save_len
] = '\0';
1795 #endif /* HAVE_STAT */
1798 static int init_builtin(char *); /* Forward */
1800 /* Load an external module using the default search path and return
1801 its module object WITH INCREMENTED REFERENCE COUNT */
1804 load_module(char *name
, FILE *fp
, char *pathname
, int type
, PyObject
*loader
)
1810 /* First check that there's an open file (if we need one) */
1815 PyErr_Format(PyExc_ValueError
,
1816 "file object required for import (type code %d)",
1825 m
= load_source_module(name
, pathname
, fp
);
1829 m
= load_compiled_module(name
, pathname
, fp
);
1832 #ifdef HAVE_DYNAMIC_LOADING
1834 m
= _PyImport_LoadDynamicModule(name
, pathname
, fp
);
1839 m
= load_package(name
, pathname
);
1844 if (pathname
!= NULL
&& pathname
[0] != '\0')
1846 if (type
== C_BUILTIN
)
1847 err
= init_builtin(name
);
1849 err
= PyImport_ImportFrozenModule(name
);
1853 PyErr_Format(PyExc_ImportError
,
1854 "Purported %s module %.200s not found",
1856 "builtin" : "frozen",
1860 modules
= PyImport_GetModuleDict();
1861 m
= PyDict_GetItemString(modules
, name
);
1865 "%s module %.200s not properly initialized",
1867 "builtin" : "frozen",
1875 if (loader
== NULL
) {
1876 PyErr_SetString(PyExc_ImportError
,
1877 "import hook without loader");
1880 m
= PyObject_CallMethod(loader
, "load_module", "s", name
);
1885 PyErr_Format(PyExc_ImportError
,
1886 "Don't know how to import %.200s (type code %d)",
1896 /* Initialize a built-in module.
1897 Return 1 for success, 0 if the module is not found, and -1 with
1898 an exception set if the initialization failed. */
1901 init_builtin(char *name
)
1905 if (_PyImport_FindExtension(name
, name
) != NULL
)
1908 for (p
= PyImport_Inittab
; p
->name
!= NULL
; p
++) {
1909 if (strcmp(name
, p
->name
) == 0) {
1910 if (p
->initfunc
== NULL
) {
1911 PyErr_Format(PyExc_ImportError
,
1912 "Cannot re-init internal module %.200s",
1917 PySys_WriteStderr("import %s # builtin\n", name
);
1919 if (PyErr_Occurred())
1921 if (_PyImport_FixupExtension(name
, name
) == NULL
)
1930 /* Frozen modules */
1932 static struct _frozen
*
1933 find_frozen(char *name
)
1937 for (p
= PyImport_FrozenModules
; ; p
++) {
1938 if (p
->name
== NULL
)
1940 if (strcmp(p
->name
, name
) == 0)
1947 get_frozen_object(char *name
)
1949 struct _frozen
*p
= find_frozen(name
);
1953 PyErr_Format(PyExc_ImportError
,
1954 "No such frozen object named %.200s",
1958 if (p
->code
== NULL
) {
1959 PyErr_Format(PyExc_ImportError
,
1960 "Excluded frozen object named %.200s",
1967 return PyMarshal_ReadObjectFromString((char *)p
->code
, size
);
1970 /* Initialize a frozen module.
1971 Return 1 for succes, 0 if the module is not found, and -1 with
1972 an exception set if the initialization failed.
1973 This function is also used from frozenmain.c */
1976 PyImport_ImportFrozenModule(char *name
)
1978 struct _frozen
*p
= find_frozen(name
);
1986 if (p
->code
== NULL
) {
1987 PyErr_Format(PyExc_ImportError
,
1988 "Excluded frozen object named %.200s",
1993 ispackage
= (size
< 0);
1997 PySys_WriteStderr("import %s # frozen%s\n",
1998 name
, ispackage
? " package" : "");
1999 co
= PyMarshal_ReadObjectFromString((char *)p
->code
, size
);
2002 if (!PyCode_Check(co
)) {
2003 PyErr_Format(PyExc_TypeError
,
2004 "frozen object %.200s is not a code object",
2009 /* Set __path__ to the package name */
2012 m
= PyImport_AddModule(name
);
2015 d
= PyModule_GetDict(m
);
2016 s
= PyString_InternFromString(name
);
2019 err
= PyDict_SetItemString(d
, "__path__", s
);
2024 m
= PyImport_ExecCodeModuleEx(name
, co
, "<frozen>");
2036 /* Import a module, either built-in, frozen, or external, and return
2037 its module object WITH INCREMENTED REFERENCE COUNT */
2040 PyImport_ImportModule(const char *name
)
2045 pname
= PyString_FromString(name
);
2048 result
= PyImport_Import(pname
);
2053 /* Import a module without blocking
2055 * At first it tries to fetch the module from sys.modules. If the module was
2056 * never loaded before it loads it with PyImport_ImportModule() unless another
2057 * thread holds the import lock. In the latter case the function raises an
2058 * ImportError instead of blocking.
2060 * Returns the module object with incremented ref count.
2063 PyImport_ImportModuleNoBlock(const char *name
)
2071 /* Try to get the module from sys.modules[name] */
2072 modules
= PyImport_GetModuleDict();
2073 if (modules
== NULL
)
2076 result
= PyDict_GetItemString(modules
, name
);
2077 if (result
!= NULL
) {
2085 /* check the import lock
2086 * me might be -1 but I ignore the error here, the lock function
2087 * takes care of the problem */
2088 me
= PyThread_get_thread_ident();
2089 if (import_lock_thread
== -1 || import_lock_thread
== me
) {
2090 /* no thread or me is holding the lock */
2091 return PyImport_ImportModule(name
);
2094 PyErr_Format(PyExc_ImportError
,
2095 "Failed to import %.200s because the import lock"
2096 "is held by another thread.",
2101 return PyImport_ImportModule(name
);
2105 /* Forward declarations for helper routines */
2106 static PyObject
*get_parent(PyObject
*globals
, char *buf
,
2107 Py_ssize_t
*p_buflen
, int level
);
2108 static PyObject
*load_next(PyObject
*mod
, PyObject
*altmod
,
2109 char **p_name
, char *buf
, Py_ssize_t
*p_buflen
);
2110 static int mark_miss(char *name
);
2111 static int ensure_fromlist(PyObject
*mod
, PyObject
*fromlist
,
2112 char *buf
, Py_ssize_t buflen
, int recursive
);
2113 static PyObject
* import_submodule(PyObject
*mod
, char *name
, char *fullname
);
2115 /* The Magnum Opus of dotted-name import :-) */
2118 import_module_level(char *name
, PyObject
*globals
, PyObject
*locals
,
2119 PyObject
*fromlist
, int level
)
2121 char buf
[MAXPATHLEN
+1];
2122 Py_ssize_t buflen
= 0;
2123 PyObject
*parent
, *head
, *next
, *tail
;
2125 if (strchr(name
, '/') != NULL
2127 || strchr(name
, '\\') != NULL
2130 PyErr_SetString(PyExc_ImportError
,
2131 "Import by filename is not supported.");
2135 parent
= get_parent(globals
, buf
, &buflen
, level
);
2139 head
= load_next(parent
, level
< 0 ? Py_None
: parent
, &name
, buf
,
2147 next
= load_next(tail
, tail
, &name
, buf
, &buflen
);
2155 if (tail
== Py_None
) {
2156 /* If tail is Py_None, both get_parent and load_next found
2157 an empty module name: someone called __import__("") or
2158 doctored faulty bytecode */
2161 PyErr_SetString(PyExc_ValueError
,
2162 "Empty module name");
2166 if (fromlist
!= NULL
) {
2167 if (fromlist
== Py_None
|| !PyObject_IsTrue(fromlist
))
2171 if (fromlist
== NULL
) {
2177 if (!ensure_fromlist(tail
, fromlist
, buf
, buflen
, 0)) {
2186 PyImport_ImportModuleLevel(char *name
, PyObject
*globals
, PyObject
*locals
,
2187 PyObject
*fromlist
, int level
)
2190 _PyImport_AcquireLock();
2191 result
= import_module_level(name
, globals
, locals
, fromlist
, level
);
2192 if (_PyImport_ReleaseLock() < 0) {
2194 PyErr_SetString(PyExc_RuntimeError
,
2195 "not holding the import lock");
2201 /* Return the package that an import is being performed in. If globals comes
2202 from the module foo.bar.bat (not itself a package), this returns the
2203 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2204 the package's entry in sys.modules is returned, as a borrowed reference.
2206 The *name* of the returned package is returned in buf, with the length of
2207 the name in *p_buflen.
2209 If globals doesn't come from a package or a module in a package, or a
2210 corresponding entry is not found in sys.modules, Py_None is returned.
2213 get_parent(PyObject
*globals
, char *buf
, Py_ssize_t
*p_buflen
, int level
)
2215 static PyObject
*namestr
= NULL
;
2216 static PyObject
*pathstr
= NULL
;
2217 static PyObject
*pkgstr
= NULL
;
2218 PyObject
*pkgname
, *modname
, *modpath
, *modules
, *parent
;
2219 int orig_level
= level
;
2221 if (globals
== NULL
|| !PyDict_Check(globals
) || !level
)
2224 if (namestr
== NULL
) {
2225 namestr
= PyString_InternFromString("__name__");
2226 if (namestr
== NULL
)
2229 if (pathstr
== NULL
) {
2230 pathstr
= PyString_InternFromString("__path__");
2231 if (pathstr
== NULL
)
2234 if (pkgstr
== NULL
) {
2235 pkgstr
= PyString_InternFromString("__package__");
2242 pkgname
= PyDict_GetItem(globals
, pkgstr
);
2244 if ((pkgname
!= NULL
) && (pkgname
!= Py_None
)) {
2245 /* __package__ is set, so use it */
2247 if (!PyString_Check(pkgname
)) {
2248 PyErr_SetString(PyExc_ValueError
,
2249 "__package__ set to non-string");
2252 len
= PyString_GET_SIZE(pkgname
);
2255 PyErr_SetString(PyExc_ValueError
,
2256 "Attempted relative import in non-package");
2261 if (len
> MAXPATHLEN
) {
2262 PyErr_SetString(PyExc_ValueError
,
2263 "Package name too long");
2266 strcpy(buf
, PyString_AS_STRING(pkgname
));
2268 /* __package__ not set, so figure it out and set it */
2269 modname
= PyDict_GetItem(globals
, namestr
);
2270 if (modname
== NULL
|| !PyString_Check(modname
))
2273 modpath
= PyDict_GetItem(globals
, pathstr
);
2274 if (modpath
!= NULL
) {
2275 /* __path__ is set, so modname is already the package name */
2276 Py_ssize_t len
= PyString_GET_SIZE(modname
);
2278 if (len
> MAXPATHLEN
) {
2279 PyErr_SetString(PyExc_ValueError
,
2280 "Module name too long");
2283 strcpy(buf
, PyString_AS_STRING(modname
));
2284 error
= PyDict_SetItem(globals
, pkgstr
, modname
);
2286 PyErr_SetString(PyExc_ValueError
,
2287 "Could not set __package__");
2291 /* Normal module, so work out the package name if any */
2292 char *start
= PyString_AS_STRING(modname
);
2293 char *lastdot
= strrchr(start
, '.');
2296 if (lastdot
== NULL
&& level
> 0) {
2297 PyErr_SetString(PyExc_ValueError
,
2298 "Attempted relative import in non-package");
2301 if (lastdot
== NULL
) {
2302 error
= PyDict_SetItem(globals
, pkgstr
, Py_None
);
2304 PyErr_SetString(PyExc_ValueError
,
2305 "Could not set __package__");
2310 len
= lastdot
- start
;
2311 if (len
>= MAXPATHLEN
) {
2312 PyErr_SetString(PyExc_ValueError
,
2313 "Module name too long");
2316 strncpy(buf
, start
, len
);
2318 pkgname
= PyString_FromString(buf
);
2319 if (pkgname
== NULL
) {
2322 error
= PyDict_SetItem(globals
, pkgstr
, pkgname
);
2325 PyErr_SetString(PyExc_ValueError
,
2326 "Could not set __package__");
2331 while (--level
> 0) {
2332 char *dot
= strrchr(buf
, '.');
2334 PyErr_SetString(PyExc_ValueError
,
2335 "Attempted relative import beyond "
2336 "toplevel package");
2341 *p_buflen
= strlen(buf
);
2343 modules
= PyImport_GetModuleDict();
2344 parent
= PyDict_GetItemString(modules
, buf
);
2345 if (parent
== NULL
) {
2346 if (orig_level
< 1) {
2347 PyObject
*err_msg
= PyString_FromFormat(
2348 "Parent module '%.200s' not found "
2349 "while handling absolute import", buf
);
2350 if (err_msg
== NULL
) {
2353 if (!PyErr_WarnEx(PyExc_RuntimeWarning
,
2354 PyString_AsString(err_msg
), 1)) {
2361 PyErr_Format(PyExc_SystemError
,
2362 "Parent module '%.200s' not loaded, "
2363 "cannot perform relative import", buf
);
2367 /* We expect, but can't guarantee, if parent != None, that:
2368 - parent.__name__ == buf
2369 - parent.__dict__ is globals
2370 If this is violated... Who cares? */
2373 /* altmod is either None or same as mod */
2375 load_next(PyObject
*mod
, PyObject
*altmod
, char **p_name
, char *buf
,
2376 Py_ssize_t
*p_buflen
)
2378 char *name
= *p_name
;
2379 char *dot
= strchr(name
, '.');
2384 if (strlen(name
) == 0) {
2385 /* completely empty module name should only happen in
2386 'from . import' (or '__import__("")')*/
2401 PyErr_SetString(PyExc_ValueError
,
2402 "Empty module name");
2406 p
= buf
+ *p_buflen
;
2409 if (p
+len
-buf
>= MAXPATHLEN
) {
2410 PyErr_SetString(PyExc_ValueError
,
2411 "Module name too long");
2414 strncpy(p
, name
, len
);
2416 *p_buflen
= p
+len
-buf
;
2418 result
= import_submodule(mod
, p
, buf
);
2419 if (result
== Py_None
&& altmod
!= mod
) {
2421 /* Here, altmod must be None and mod must not be None */
2422 result
= import_submodule(altmod
, p
, p
);
2423 if (result
!= NULL
&& result
!= Py_None
) {
2424 if (mark_miss(buf
) != 0) {
2428 strncpy(buf
, name
, len
);
2436 if (result
== Py_None
) {
2438 PyErr_Format(PyExc_ImportError
,
2439 "No module named %.200s", name
);
2447 mark_miss(char *name
)
2449 PyObject
*modules
= PyImport_GetModuleDict();
2450 return PyDict_SetItemString(modules
, name
, Py_None
);
2454 ensure_fromlist(PyObject
*mod
, PyObject
*fromlist
, char *buf
, Py_ssize_t buflen
,
2459 if (!PyObject_HasAttrString(mod
, "__path__"))
2462 for (i
= 0; ; i
++) {
2463 PyObject
*item
= PySequence_GetItem(fromlist
, i
);
2466 if (PyErr_ExceptionMatches(PyExc_IndexError
)) {
2472 if (!PyString_Check(item
)) {
2473 PyErr_SetString(PyExc_TypeError
,
2474 "Item in ``from list'' not a string");
2478 if (PyString_AS_STRING(item
)[0] == '*') {
2481 /* See if the package defines __all__ */
2483 continue; /* Avoid endless recursion */
2484 all
= PyObject_GetAttrString(mod
, "__all__");
2488 int ret
= ensure_fromlist(mod
, all
, buf
, buflen
, 1);
2495 hasit
= PyObject_HasAttr(mod
, item
);
2497 char *subname
= PyString_AS_STRING(item
);
2500 if (buflen
+ strlen(subname
) >= MAXPATHLEN
) {
2501 PyErr_SetString(PyExc_ValueError
,
2502 "Module name too long");
2509 submod
= import_submodule(mod
, subname
, buf
);
2511 if (submod
== NULL
) {
2523 add_submodule(PyObject
*mod
, PyObject
*submod
, char *fullname
, char *subname
,
2528 /* Irrespective of the success of this load, make a
2529 reference to it in the parent package module. A copy gets
2530 saved in the modules dictionary under the full name, so get a
2531 reference from there, if need be. (The exception is when the
2532 load failed with a SyntaxError -- then there's no trace in
2533 sys.modules. In that case, of course, do nothing extra.) */
2534 if (submod
== NULL
) {
2535 submod
= PyDict_GetItemString(modules
, fullname
);
2539 if (PyModule_Check(mod
)) {
2540 /* We can't use setattr here since it can give a
2541 * spurious warning if the submodule name shadows a
2543 PyObject
*dict
= PyModule_GetDict(mod
);
2546 if (PyDict_SetItemString(dict
, subname
, submod
) < 0)
2550 if (PyObject_SetAttrString(mod
, subname
, submod
) < 0)
2557 import_submodule(PyObject
*mod
, char *subname
, char *fullname
)
2559 PyObject
*modules
= PyImport_GetModuleDict();
2563 if mod == None: subname == fullname
2564 else: mod.__name__ + "." + subname == fullname
2567 if ((m
= PyDict_GetItemString(modules
, fullname
)) != NULL
) {
2571 PyObject
*path
, *loader
= NULL
;
2572 char buf
[MAXPATHLEN
+1];
2573 struct filedescr
*fdp
;
2579 path
= PyObject_GetAttrString(mod
, "__path__");
2588 fdp
= find_module(fullname
, subname
, path
, buf
, MAXPATHLEN
+1,
2592 if (!PyErr_ExceptionMatches(PyExc_ImportError
))
2598 m
= load_module(fullname
, fp
, buf
, fdp
->type
, loader
);
2602 if (!add_submodule(mod
, m
, fullname
, subname
, modules
)) {
2612 /* Re-import a module of any kind and return its module object, WITH
2613 INCREMENTED REFERENCE COUNT */
2616 PyImport_ReloadModule(PyObject
*m
)
2618 PyInterpreterState
*interp
= PyThreadState_Get()->interp
;
2619 PyObject
*modules_reloading
= interp
->modules_reloading
;
2620 PyObject
*modules
= PyImport_GetModuleDict();
2621 PyObject
*path
= NULL
, *loader
= NULL
, *existing_m
= NULL
;
2622 char *name
, *subname
;
2623 char buf
[MAXPATHLEN
+1];
2624 struct filedescr
*fdp
;
2628 if (modules_reloading
== NULL
) {
2629 Py_FatalError("PyImport_ReloadModule: "
2630 "no modules_reloading dictionary!");
2634 if (m
== NULL
|| !PyModule_Check(m
)) {
2635 PyErr_SetString(PyExc_TypeError
,
2636 "reload() argument must be module");
2639 name
= PyModule_GetName(m
);
2642 if (m
!= PyDict_GetItemString(modules
, name
)) {
2643 PyErr_Format(PyExc_ImportError
,
2644 "reload(): module %.200s not in sys.modules",
2648 existing_m
= PyDict_GetItemString(modules_reloading
, name
);
2649 if (existing_m
!= NULL
) {
2650 /* Due to a recursive reload, this module is already
2652 Py_INCREF(existing_m
);
2655 if (PyDict_SetItemString(modules_reloading
, name
, m
) < 0)
2658 subname
= strrchr(name
, '.');
2659 if (subname
== NULL
)
2662 PyObject
*parentname
, *parent
;
2663 parentname
= PyString_FromStringAndSize(name
, (subname
-name
));
2664 if (parentname
== NULL
) {
2665 imp_modules_reloading_clear();
2668 parent
= PyDict_GetItem(modules
, parentname
);
2669 if (parent
== NULL
) {
2670 PyErr_Format(PyExc_ImportError
,
2671 "reload(): parent %.200s not in sys.modules",
2672 PyString_AS_STRING(parentname
));
2673 Py_DECREF(parentname
);
2674 imp_modules_reloading_clear();
2677 Py_DECREF(parentname
);
2679 path
= PyObject_GetAttrString(parent
, "__path__");
2684 fdp
= find_module(name
, subname
, path
, buf
, MAXPATHLEN
+1, &fp
, &loader
);
2689 imp_modules_reloading_clear();
2693 newm
= load_module(name
, fp
, buf
, fdp
->type
, loader
);
2699 /* load_module probably removed name from modules because of
2700 * the error. Put back the original module object. We're
2701 * going to return NULL in this case regardless of whether
2702 * replacing name succeeds, so the return value is ignored.
2704 PyDict_SetItemString(modules
, name
, m
);
2706 imp_modules_reloading_clear();
2711 /* Higher-level import emulator which emulates the "import" statement
2712 more accurately -- it invokes the __import__() function from the
2713 builtins of the current globals. This means that the import is
2714 done using whatever import hooks are installed in the current
2715 environment, e.g. by "rexec".
2716 A dummy list ["__doc__"] is passed as the 4th argument so that
2717 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2718 will return <module "gencache"> instead of <module "win32com">. */
2721 PyImport_Import(PyObject
*module_name
)
2723 static PyObject
*silly_list
= NULL
;
2724 static PyObject
*builtins_str
= NULL
;
2725 static PyObject
*import_str
= NULL
;
2726 PyObject
*globals
= NULL
;
2727 PyObject
*import
= NULL
;
2728 PyObject
*builtins
= NULL
;
2731 /* Initialize constant string objects */
2732 if (silly_list
== NULL
) {
2733 import_str
= PyString_InternFromString("__import__");
2734 if (import_str
== NULL
)
2736 builtins_str
= PyString_InternFromString("__builtins__");
2737 if (builtins_str
== NULL
)
2739 silly_list
= Py_BuildValue("[s]", "__doc__");
2740 if (silly_list
== NULL
)
2744 /* Get the builtins from current globals */
2745 globals
= PyEval_GetGlobals();
2746 if (globals
!= NULL
) {
2748 builtins
= PyObject_GetItem(globals
, builtins_str
);
2749 if (builtins
== NULL
)
2753 /* No globals -- use standard builtins, and fake globals */
2754 builtins
= PyImport_ImportModuleLevel("__builtin__",
2755 NULL
, NULL
, NULL
, 0);
2756 if (builtins
== NULL
)
2758 globals
= Py_BuildValue("{OO}", builtins_str
, builtins
);
2759 if (globals
== NULL
)
2763 /* Get the __import__ function from the builtins */
2764 if (PyDict_Check(builtins
)) {
2765 import
= PyObject_GetItem(builtins
, import_str
);
2767 PyErr_SetObject(PyExc_KeyError
, import_str
);
2770 import
= PyObject_GetAttr(builtins
, import_str
);
2774 /* Call the __import__ function with the proper argument list
2775 * Always use absolute import here. */
2776 r
= PyObject_CallFunction(import
, "OOOOi", module_name
, globals
,
2777 globals
, silly_list
, 0, NULL
);
2780 Py_XDECREF(globals
);
2781 Py_XDECREF(builtins
);
2788 /* Module 'imp' provides Python access to the primitives used for
2793 imp_get_magic(PyObject
*self
, PyObject
*noargs
)
2797 buf
[0] = (char) ((pyc_magic
>> 0) & 0xff);
2798 buf
[1] = (char) ((pyc_magic
>> 8) & 0xff);
2799 buf
[2] = (char) ((pyc_magic
>> 16) & 0xff);
2800 buf
[3] = (char) ((pyc_magic
>> 24) & 0xff);
2802 return PyString_FromStringAndSize(buf
, 4);
2806 imp_get_suffixes(PyObject
*self
, PyObject
*noargs
)
2809 struct filedescr
*fdp
;
2811 list
= PyList_New(0);
2814 for (fdp
= _PyImport_Filetab
; fdp
->suffix
!= NULL
; fdp
++) {
2815 PyObject
*item
= Py_BuildValue("ssi",
2816 fdp
->suffix
, fdp
->mode
, fdp
->type
);
2821 if (PyList_Append(list
, item
) < 0) {
2832 call_find_module(char *name
, PyObject
*path
)
2834 extern int fclose(FILE *);
2835 PyObject
*fob
, *ret
;
2836 struct filedescr
*fdp
;
2837 char pathname
[MAXPATHLEN
+1];
2841 if (path
== Py_None
)
2843 fdp
= find_module(NULL
, name
, path
, pathname
, MAXPATHLEN
+1, &fp
, NULL
);
2847 fob
= PyFile_FromFile(fp
, pathname
, fdp
->mode
, fclose
);
2857 ret
= Py_BuildValue("Os(ssi)",
2858 fob
, pathname
, fdp
->suffix
, fdp
->mode
, fdp
->type
);
2864 imp_find_module(PyObject
*self
, PyObject
*args
)
2867 PyObject
*path
= NULL
;
2868 if (!PyArg_ParseTuple(args
, "s|O:find_module", &name
, &path
))
2870 return call_find_module(name
, path
);
2874 imp_init_builtin(PyObject
*self
, PyObject
*args
)
2879 if (!PyArg_ParseTuple(args
, "s:init_builtin", &name
))
2881 ret
= init_builtin(name
);
2888 m
= PyImport_AddModule(name
);
2894 imp_init_frozen(PyObject
*self
, PyObject
*args
)
2899 if (!PyArg_ParseTuple(args
, "s:init_frozen", &name
))
2901 ret
= PyImport_ImportFrozenModule(name
);
2908 m
= PyImport_AddModule(name
);
2914 imp_get_frozen_object(PyObject
*self
, PyObject
*args
)
2918 if (!PyArg_ParseTuple(args
, "s:get_frozen_object", &name
))
2920 return get_frozen_object(name
);
2924 imp_is_builtin(PyObject
*self
, PyObject
*args
)
2927 if (!PyArg_ParseTuple(args
, "s:is_builtin", &name
))
2929 return PyInt_FromLong(is_builtin(name
));
2933 imp_is_frozen(PyObject
*self
, PyObject
*args
)
2937 if (!PyArg_ParseTuple(args
, "s:is_frozen", &name
))
2939 p
= find_frozen(name
);
2940 return PyBool_FromLong((long) (p
== NULL
? 0 : p
->size
));
2944 get_file(char *pathname
, PyObject
*fob
, char *mode
)
2949 mode
= "r" PY_STDIOTEXTMODE
;
2950 fp
= fopen(pathname
, mode
);
2952 PyErr_SetFromErrno(PyExc_IOError
);
2955 fp
= PyFile_AsFile(fob
);
2957 PyErr_SetString(PyExc_ValueError
,
2958 "bad/closed file object");
2964 imp_load_compiled(PyObject
*self
, PyObject
*args
)
2968 PyObject
*fob
= NULL
;
2971 if (!PyArg_ParseTuple(args
, "ss|O!:load_compiled", &name
, &pathname
,
2972 &PyFile_Type
, &fob
))
2974 fp
= get_file(pathname
, fob
, "rb");
2977 m
= load_compiled_module(name
, pathname
, fp
);
2983 #ifdef HAVE_DYNAMIC_LOADING
2986 imp_load_dynamic(PyObject
*self
, PyObject
*args
)
2990 PyObject
*fob
= NULL
;
2993 if (!PyArg_ParseTuple(args
, "ss|O!:load_dynamic", &name
, &pathname
,
2994 &PyFile_Type
, &fob
))
2997 fp
= get_file(pathname
, fob
, "r");
3001 m
= _PyImport_LoadDynamicModule(name
, pathname
, fp
);
3005 #endif /* HAVE_DYNAMIC_LOADING */
3008 imp_load_source(PyObject
*self
, PyObject
*args
)
3012 PyObject
*fob
= NULL
;
3015 if (!PyArg_ParseTuple(args
, "ss|O!:load_source", &name
, &pathname
,
3016 &PyFile_Type
, &fob
))
3018 fp
= get_file(pathname
, fob
, "r");
3021 m
= load_source_module(name
, pathname
, fp
);
3028 imp_load_module(PyObject
*self
, PyObject
*args
)
3033 char *suffix
; /* Unused */
3038 if (!PyArg_ParseTuple(args
, "sOs(ssi):load_module",
3039 &name
, &fob
, &pathname
,
3040 &suffix
, &mode
, &type
))
3043 /* Mode must start with 'r' or 'U' and must not contain '+'.
3044 Implicit in this test is the assumption that the mode
3045 may contain other modifiers like 'b' or 't'. */
3047 if (!(*mode
== 'r' || *mode
== 'U') || strchr(mode
, '+')) {
3048 PyErr_Format(PyExc_ValueError
,
3049 "invalid file open mode %.200s", mode
);
3056 if (!PyFile_Check(fob
)) {
3057 PyErr_SetString(PyExc_ValueError
,
3058 "load_module arg#2 should be a file or None");
3061 fp
= get_file(pathname
, fob
, mode
);
3065 return load_module(name
, fp
, pathname
, type
, NULL
);
3069 imp_load_package(PyObject
*self
, PyObject
*args
)
3073 if (!PyArg_ParseTuple(args
, "ss:load_package", &name
, &pathname
))
3075 return load_package(name
, pathname
);
3079 imp_new_module(PyObject
*self
, PyObject
*args
)
3082 if (!PyArg_ParseTuple(args
, "s:new_module", &name
))
3084 return PyModule_New(name
);
3088 imp_reload(PyObject
*self
, PyObject
*v
)
3090 return PyImport_ReloadModule(v
);
3096 PyDoc_STRVAR(doc_imp
,
3097 "This module provides the components needed to build your own\n\
3098 __import__ function. Undocumented functions are obsolete.");
3100 PyDoc_STRVAR(doc_reload
,
3101 "reload(module) -> module\n\
3103 Reload the module. The module must have been successfully imported before.");
3105 PyDoc_STRVAR(doc_find_module
,
3106 "find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
3107 Search for a module. If path is omitted or None, search for a\n\
3108 built-in, frozen or special module and continue search in sys.path.\n\
3109 The module name cannot contain '.'; to search for a submodule of a\n\
3110 package, pass the submodule name and the package's __path__.");
3112 PyDoc_STRVAR(doc_load_module
,
3113 "load_module(name, file, filename, (suffix, mode, type)) -> module\n\
3114 Load a module, given information returned by find_module().\n\
3115 The module name must include the full package name, if any.");
3117 PyDoc_STRVAR(doc_get_magic
,
3118 "get_magic() -> string\n\
3119 Return the magic number for .pyc or .pyo files.");
3121 PyDoc_STRVAR(doc_get_suffixes
,
3122 "get_suffixes() -> [(suffix, mode, type), ...]\n\
3123 Return a list of (suffix, mode, type) tuples describing the files\n\
3124 that find_module() looks for.");
3126 PyDoc_STRVAR(doc_new_module
,
3127 "new_module(name) -> module\n\
3128 Create a new module. Do not enter it in sys.modules.\n\
3129 The module name must include the full package name, if any.");
3131 PyDoc_STRVAR(doc_lock_held
,
3132 "lock_held() -> boolean\n\
3133 Return True if the import lock is currently held, else False.\n\
3134 On platforms without threads, return False.");
3136 PyDoc_STRVAR(doc_acquire_lock
,
3137 "acquire_lock() -> None\n\
3138 Acquires the interpreter's import lock for the current thread.\n\
3139 This lock should be used by import hooks to ensure thread-safety\n\
3140 when importing modules.\n\
3141 On platforms without threads, this function does nothing.");
3143 PyDoc_STRVAR(doc_release_lock
,
3144 "release_lock() -> None\n\
3145 Release the interpreter's import lock.\n\
3146 On platforms without threads, this function does nothing.");
3148 static PyMethodDef imp_methods
[] = {
3149 {"reload", imp_reload
, METH_O
, doc_reload
},
3150 {"find_module", imp_find_module
, METH_VARARGS
, doc_find_module
},
3151 {"get_magic", imp_get_magic
, METH_NOARGS
, doc_get_magic
},
3152 {"get_suffixes", imp_get_suffixes
, METH_NOARGS
, doc_get_suffixes
},
3153 {"load_module", imp_load_module
, METH_VARARGS
, doc_load_module
},
3154 {"new_module", imp_new_module
, METH_VARARGS
, doc_new_module
},
3155 {"lock_held", imp_lock_held
, METH_NOARGS
, doc_lock_held
},
3156 {"acquire_lock", imp_acquire_lock
, METH_NOARGS
, doc_acquire_lock
},
3157 {"release_lock", imp_release_lock
, METH_NOARGS
, doc_release_lock
},
3158 /* The rest are obsolete */
3159 {"get_frozen_object", imp_get_frozen_object
, METH_VARARGS
},
3160 {"init_builtin", imp_init_builtin
, METH_VARARGS
},
3161 {"init_frozen", imp_init_frozen
, METH_VARARGS
},
3162 {"is_builtin", imp_is_builtin
, METH_VARARGS
},
3163 {"is_frozen", imp_is_frozen
, METH_VARARGS
},
3164 {"load_compiled", imp_load_compiled
, METH_VARARGS
},
3165 #ifdef HAVE_DYNAMIC_LOADING
3166 {"load_dynamic", imp_load_dynamic
, METH_VARARGS
},
3168 {"load_package", imp_load_package
, METH_VARARGS
},
3169 {"load_source", imp_load_source
, METH_VARARGS
},
3170 {NULL
, NULL
} /* sentinel */
3174 setint(PyObject
*d
, char *name
, int value
)
3179 v
= PyInt_FromLong((long)value
);
3180 err
= PyDict_SetItemString(d
, name
, v
);
3190 NullImporter_init(NullImporter
*self
, PyObject
*args
, PyObject
*kwds
)
3195 if (!_PyArg_NoKeywords("NullImporter()", kwds
))
3198 if (!PyArg_ParseTuple(args
, "s:NullImporter",
3202 pathlen
= strlen(path
);
3204 PyErr_SetString(PyExc_ImportError
, "empty pathname");
3209 struct stat statbuf
;
3212 rv
= stat(path
, &statbuf
);
3215 if (S_ISDIR(statbuf
.st_mode
)) {
3216 /* it's a directory */
3217 PyErr_SetString(PyExc_ImportError
,
3218 "existing directory");
3222 #else /* MS_WINDOWS */
3224 /* see issue1293 and issue3677:
3225 * stat() on Windows doesn't recognise paths like
3226 * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
3228 rv
= GetFileAttributesA(path
);
3229 if (rv
!= INVALID_FILE_ATTRIBUTES
) {
3231 if (rv
& FILE_ATTRIBUTE_DIRECTORY
) {
3232 /* it's a directory */
3233 PyErr_SetString(PyExc_ImportError
,
3234 "existing directory");
3240 if (object_exists(path
)) {
3243 /* it's a directory */
3244 PyErr_SetString(PyExc_ImportError
,
3245 "existing directory");
3255 NullImporter_find_module(NullImporter
*self
, PyObject
*args
)
3260 static PyMethodDef NullImporter_methods
[] = {
3261 {"find_module", (PyCFunction
)NullImporter_find_module
, METH_VARARGS
,
3262 "Always return None"
3264 {NULL
} /* Sentinel */
3268 PyTypeObject PyNullImporter_Type
= {
3269 PyVarObject_HEAD_INIT(NULL
, 0)
3270 "imp.NullImporter", /*tp_name*/
3271 sizeof(NullImporter
), /*tp_basicsize*/
3280 0, /*tp_as_sequence*/
3281 0, /*tp_as_mapping*/
3288 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
3289 "Null importer object", /* tp_doc */
3290 0, /* tp_traverse */
3292 0, /* tp_richcompare */
3293 0, /* tp_weaklistoffset */
3295 0, /* tp_iternext */
3296 NullImporter_methods
, /* tp_methods */
3301 0, /* tp_descr_get */
3302 0, /* tp_descr_set */
3303 0, /* tp_dictoffset */
3304 (initproc
)NullImporter_init
, /* tp_init */
3306 PyType_GenericNew
/* tp_new */
3315 if (PyType_Ready(&PyNullImporter_Type
) < 0)
3318 m
= Py_InitModule4("imp", imp_methods
, doc_imp
,
3319 NULL
, PYTHON_API_VERSION
);
3322 d
= PyModule_GetDict(m
);
3326 if (setint(d
, "SEARCH_ERROR", SEARCH_ERROR
) < 0) goto failure
;
3327 if (setint(d
, "PY_SOURCE", PY_SOURCE
) < 0) goto failure
;
3328 if (setint(d
, "PY_COMPILED", PY_COMPILED
) < 0) goto failure
;
3329 if (setint(d
, "C_EXTENSION", C_EXTENSION
) < 0) goto failure
;
3330 if (setint(d
, "PY_RESOURCE", PY_RESOURCE
) < 0) goto failure
;
3331 if (setint(d
, "PKG_DIRECTORY", PKG_DIRECTORY
) < 0) goto failure
;
3332 if (setint(d
, "C_BUILTIN", C_BUILTIN
) < 0) goto failure
;
3333 if (setint(d
, "PY_FROZEN", PY_FROZEN
) < 0) goto failure
;
3334 if (setint(d
, "PY_CODERESOURCE", PY_CODERESOURCE
) < 0) goto failure
;
3335 if (setint(d
, "IMP_HOOK", IMP_HOOK
) < 0) goto failure
;
3337 Py_INCREF(&PyNullImporter_Type
);
3338 PyModule_AddObject(m
, "NullImporter", (PyObject
*)&PyNullImporter_Type
);
3344 /* API for embedding applications that want to add their own entries
3345 to the table of built-in modules. This should normally be called
3346 *before* Py_Initialize(). When the table resize fails, -1 is
3347 returned and the existing table is unchanged.
3349 After a similar function by Just van Rossum. */
3352 PyImport_ExtendInittab(struct _inittab
*newtab
)
3354 static struct _inittab
*our_copy
= NULL
;
3358 /* Count the number of entries in both tables */
3359 for (n
= 0; newtab
[n
].name
!= NULL
; n
++)
3362 return 0; /* Nothing to do */
3363 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++)
3366 /* Allocate new memory for the combined table */
3368 PyMem_RESIZE(p
, struct _inittab
, i
+n
+1);
3372 /* Copy the tables into the new memory */
3373 if (our_copy
!= PyImport_Inittab
)
3374 memcpy(p
, PyImport_Inittab
, (i
+1) * sizeof(struct _inittab
));
3375 PyImport_Inittab
= our_copy
= p
;
3376 memcpy(p
+i
, newtab
, (n
+1) * sizeof(struct _inittab
));
3381 /* Shorthand to add a single entry given a name and a function */
3384 PyImport_AppendInittab(const char *name
, void (*initfunc
)(void))
3386 struct _inittab newtab
[2];
3388 memset(newtab
, '\0', sizeof newtab
);
3390 newtab
[0].name
= (char *)name
;
3391 newtab
[0].initfunc
= initfunc
;
3393 return PyImport_ExtendInittab(newtab
);