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)
80 #define MAGIC (62191 | ((long)'\r'<<16) | ((long)'\n'<<24))
82 /* Magic word as global; note that _PyImport_Init() can change the
83 value of this global to accommodate for alterations of how the
84 compiler works which are enabled by command line switches. */
85 static long pyc_magic
= MAGIC
;
87 /* See _PyImport_FixupExtension() below */
88 static PyObject
*extensions
= NULL
;
90 /* This table is defined in config.c: */
91 extern struct _inittab _PyImport_Inittab
[];
93 struct _inittab
*PyImport_Inittab
= _PyImport_Inittab
;
95 /* these tables define the module suffixes that Python recognizes */
96 struct filedescr
* _PyImport_Filetab
= NULL
;
99 static const struct filedescr _PyImport_StandardFiletab
[] = {
100 {"/py", "U", PY_SOURCE
},
101 {"/pyc", "rb", PY_COMPILED
},
105 static const struct filedescr _PyImport_StandardFiletab
[] = {
106 {".py", "U", PY_SOURCE
},
108 {".pyw", "U", PY_SOURCE
},
110 {".pyc", "rb", PY_COMPILED
},
116 /* Initialize things */
121 const struct filedescr
*scan
;
122 struct filedescr
*filetab
;
126 /* prepare _PyImport_Filetab: copy entries from
127 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
129 #ifdef HAVE_DYNAMIC_LOADING
130 for (scan
= _PyImport_DynLoadFiletab
; scan
->suffix
!= NULL
; ++scan
)
133 for (scan
= _PyImport_StandardFiletab
; scan
->suffix
!= NULL
; ++scan
)
135 filetab
= PyMem_NEW(struct filedescr
, countD
+ countS
+ 1);
137 Py_FatalError("Can't initialize import file table.");
138 #ifdef HAVE_DYNAMIC_LOADING
139 memcpy(filetab
, _PyImport_DynLoadFiletab
,
140 countD
* sizeof(struct filedescr
));
142 memcpy(filetab
+ countD
, _PyImport_StandardFiletab
,
143 countS
* sizeof(struct filedescr
));
144 filetab
[countD
+ countS
].suffix
= NULL
;
146 _PyImport_Filetab
= filetab
;
148 if (Py_OptimizeFlag
) {
149 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
150 for (; filetab
->suffix
!= NULL
; filetab
++) {
152 if (strcmp(filetab
->suffix
, ".pyc") == 0)
153 filetab
->suffix
= ".pyo";
155 if (strcmp(filetab
->suffix
, "/pyc") == 0)
156 filetab
->suffix
= "/pyo";
161 if (Py_UnicodeFlag
) {
162 /* Fix the pyc_magic so that byte compiled code created
163 using the all-Unicode method doesn't interfere with
164 code created in normal operation mode. */
165 pyc_magic
= MAGIC
+ 1;
170 _PyImportHooks_Init(void)
172 PyObject
*v
, *path_hooks
= NULL
, *zimpimport
;
175 /* adding sys.path_hooks and sys.path_importer_cache, setting up
177 if (PyType_Ready(&PyNullImporter_Type
) < 0)
181 PySys_WriteStderr("# installing zipimport hook\n");
186 err
= PySys_SetObject("meta_path", v
);
193 err
= PySys_SetObject("path_importer_cache", v
);
197 path_hooks
= PyList_New(0);
198 if (path_hooks
== NULL
)
200 err
= PySys_SetObject("path_hooks", path_hooks
);
204 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
205 "path_importer_cache, or NullImporter failed"
209 zimpimport
= PyImport_ImportModule("zipimport");
210 if (zimpimport
== NULL
) {
211 PyErr_Clear(); /* No zip import module -- okay */
213 PySys_WriteStderr("# can't import zipimport\n");
216 PyObject
*zipimporter
= PyObject_GetAttrString(zimpimport
,
218 Py_DECREF(zimpimport
);
219 if (zipimporter
== NULL
) {
220 PyErr_Clear(); /* No zipimporter object -- okay */
223 "# can't import zipimport.zipimporter\n");
226 /* sys.path_hooks.append(zipimporter) */
227 err
= PyList_Append(path_hooks
, zipimporter
);
228 Py_DECREF(zipimporter
);
233 "# installed zipimport hook\n");
236 Py_DECREF(path_hooks
);
242 Py_XDECREF(extensions
);
244 PyMem_DEL(_PyImport_Filetab
);
245 _PyImport_Filetab
= NULL
;
249 /* Locking primitives to prevent parallel imports of the same module
250 in different threads to return with a partially loaded module.
251 These calls are serialized by the global interpreter lock. */
255 #include "pythread.h"
257 static PyThread_type_lock import_lock
= 0;
258 static long import_lock_thread
= -1;
259 static int import_lock_level
= 0;
264 long me
= PyThread_get_thread_ident();
266 return; /* Too bad */
267 if (import_lock
== NULL
) {
268 import_lock
= PyThread_allocate_lock();
269 if (import_lock
== NULL
)
270 return; /* Nothing much we can do. */
272 if (import_lock_thread
== me
) {
276 if (import_lock_thread
!= -1 || !PyThread_acquire_lock(import_lock
, 0))
278 PyThreadState
*tstate
= PyEval_SaveThread();
279 PyThread_acquire_lock(import_lock
, 1);
280 PyEval_RestoreThread(tstate
);
282 import_lock_thread
= me
;
283 import_lock_level
= 1;
289 long me
= PyThread_get_thread_ident();
290 if (me
== -1 || import_lock
== NULL
)
291 return 0; /* Too bad */
292 if (import_lock_thread
!= me
)
295 if (import_lock_level
== 0) {
296 import_lock_thread
= -1;
297 PyThread_release_lock(import_lock
);
302 /* This function is called from PyOS_AfterFork to ensure that newly
303 created child processes do not share locks with the parent. */
306 _PyImport_ReInitLock(void)
309 if (import_lock
!= NULL
)
310 import_lock
= PyThread_allocate_lock();
316 #define lock_import()
317 #define unlock_import() 0
322 imp_lock_held(PyObject
*self
, PyObject
*noargs
)
325 return PyBool_FromLong(import_lock_thread
!= -1);
327 return PyBool_FromLong(0);
332 imp_acquire_lock(PyObject
*self
, PyObject
*noargs
)
342 imp_release_lock(PyObject
*self
, PyObject
*noargs
)
345 if (unlock_import() < 0) {
346 PyErr_SetString(PyExc_RuntimeError
,
347 "not holding the import lock");
356 imp_modules_reloading_clear(void)
358 PyInterpreterState
*interp
= PyThreadState_Get()->interp
;
359 if (interp
->modules_reloading
!= NULL
)
360 PyDict_Clear(interp
->modules_reloading
);
366 PyImport_GetModuleDict(void)
368 PyInterpreterState
*interp
= PyThreadState_GET()->interp
;
369 if (interp
->modules
== NULL
)
370 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
371 return interp
->modules
;
375 /* List of names to clear in sys */
376 static char* sys_deletes
[] = {
377 "path", "argv", "ps1", "ps2", "exitfunc",
378 "exc_type", "exc_value", "exc_traceback",
379 "last_type", "last_value", "last_traceback",
380 "path_hooks", "path_importer_cache", "meta_path",
382 "flags", "float_info",
386 static char* sys_files
[] = {
387 "stdin", "__stdin__",
388 "stdout", "__stdout__",
389 "stderr", "__stderr__",
394 /* Un-initialize things, as good as we can */
397 PyImport_Cleanup(void)
399 Py_ssize_t pos
, ndone
;
401 PyObject
*key
, *value
, *dict
;
402 PyInterpreterState
*interp
= PyThreadState_GET()->interp
;
403 PyObject
*modules
= interp
->modules
;
406 return; /* Already done */
408 /* Delete some special variables first. These are common
409 places where user values hide and people complain when their
410 destructors fail. Since the modules containing them are
411 deleted *last* of all, they would come too late in the normal
412 destruction order. Sigh. */
414 value
= PyDict_GetItemString(modules
, "__builtin__");
415 if (value
!= NULL
&& PyModule_Check(value
)) {
416 dict
= PyModule_GetDict(value
);
418 PySys_WriteStderr("# clear __builtin__._\n");
419 PyDict_SetItemString(dict
, "_", Py_None
);
421 value
= PyDict_GetItemString(modules
, "sys");
422 if (value
!= NULL
&& PyModule_Check(value
)) {
425 dict
= PyModule_GetDict(value
);
426 for (p
= sys_deletes
; *p
!= NULL
; p
++) {
428 PySys_WriteStderr("# clear sys.%s\n", *p
);
429 PyDict_SetItemString(dict
, *p
, Py_None
);
431 for (p
= sys_files
; *p
!= NULL
; p
+=2) {
433 PySys_WriteStderr("# restore sys.%s\n", *p
);
434 v
= PyDict_GetItemString(dict
, *(p
+1));
437 PyDict_SetItemString(dict
, *p
, v
);
441 /* First, delete __main__ */
442 value
= PyDict_GetItemString(modules
, "__main__");
443 if (value
!= NULL
&& PyModule_Check(value
)) {
445 PySys_WriteStderr("# cleanup __main__\n");
446 _PyModule_Clear(value
);
447 PyDict_SetItemString(modules
, "__main__", Py_None
);
450 /* The special treatment of __builtin__ here is because even
451 when it's not referenced as a module, its dictionary is
452 referenced by almost every module's __builtins__. Since
453 deleting a module clears its dictionary (even if there are
454 references left to it), we need to delete the __builtin__
455 module last. Likewise, we don't delete sys until the very
456 end because it is implicitly referenced (e.g. by print).
458 Also note that we 'delete' modules by replacing their entry
459 in the modules dict with None, rather than really deleting
460 them; this avoids a rehash of the modules dictionary and
461 also marks them as "non existent" so they won't be
464 /* Next, repeatedly delete modules with a reference count of
465 one (skipping __builtin__ and sys) and delete them */
469 while (PyDict_Next(modules
, &pos
, &key
, &value
)) {
470 if (value
->ob_refcnt
!= 1)
472 if (PyString_Check(key
) && PyModule_Check(value
)) {
473 name
= PyString_AS_STRING(key
);
474 if (strcmp(name
, "__builtin__") == 0)
476 if (strcmp(name
, "sys") == 0)
480 "# cleanup[1] %s\n", name
);
481 _PyModule_Clear(value
);
482 PyDict_SetItem(modules
, key
, Py_None
);
488 /* Next, delete all modules (still skipping __builtin__ and sys) */
490 while (PyDict_Next(modules
, &pos
, &key
, &value
)) {
491 if (PyString_Check(key
) && PyModule_Check(value
)) {
492 name
= PyString_AS_STRING(key
);
493 if (strcmp(name
, "__builtin__") == 0)
495 if (strcmp(name
, "sys") == 0)
498 PySys_WriteStderr("# cleanup[2] %s\n", name
);
499 _PyModule_Clear(value
);
500 PyDict_SetItem(modules
, key
, Py_None
);
504 /* Next, delete sys and __builtin__ (in that order) */
505 value
= PyDict_GetItemString(modules
, "sys");
506 if (value
!= NULL
&& PyModule_Check(value
)) {
508 PySys_WriteStderr("# cleanup sys\n");
509 _PyModule_Clear(value
);
510 PyDict_SetItemString(modules
, "sys", Py_None
);
512 value
= PyDict_GetItemString(modules
, "__builtin__");
513 if (value
!= NULL
&& PyModule_Check(value
)) {
515 PySys_WriteStderr("# cleanup __builtin__\n");
516 _PyModule_Clear(value
);
517 PyDict_SetItemString(modules
, "__builtin__", Py_None
);
520 /* Finally, clear and delete the modules directory */
521 PyDict_Clear(modules
);
522 interp
->modules
= NULL
;
524 Py_CLEAR(interp
->modules_reloading
);
528 /* Helper for pythonrun.c -- return magic number */
531 PyImport_GetMagicNumber(void)
537 /* Magic for extension modules (built-in as well as dynamically
538 loaded). To prevent initializing an extension module more than
539 once, we keep a static dictionary 'extensions' keyed by module name
540 (for built-in modules) or by filename (for dynamically loaded
541 modules), containing these modules. A copy of the module's
542 dictionary is stored by calling _PyImport_FixupExtension()
543 immediately after the module initialization function succeeds. A
544 copy can be retrieved from there by calling
545 _PyImport_FindExtension(). */
548 _PyImport_FixupExtension(char *name
, char *filename
)
550 PyObject
*modules
, *mod
, *dict
, *copy
;
551 if (extensions
== NULL
) {
552 extensions
= PyDict_New();
553 if (extensions
== NULL
)
556 modules
= PyImport_GetModuleDict();
557 mod
= PyDict_GetItemString(modules
, name
);
558 if (mod
== NULL
|| !PyModule_Check(mod
)) {
559 PyErr_Format(PyExc_SystemError
,
560 "_PyImport_FixupExtension: module %.200s not loaded", name
);
563 dict
= PyModule_GetDict(mod
);
566 copy
= PyDict_Copy(dict
);
569 PyDict_SetItemString(extensions
, filename
, copy
);
575 _PyImport_FindExtension(char *name
, char *filename
)
577 PyObject
*dict
, *mod
, *mdict
;
578 if (extensions
== NULL
)
580 dict
= PyDict_GetItemString(extensions
, filename
);
583 mod
= PyImport_AddModule(name
);
586 mdict
= PyModule_GetDict(mod
);
589 if (PyDict_Update(mdict
, dict
))
592 PySys_WriteStderr("import %s # previously loaded (%s)\n",
598 /* Get the module object corresponding to a module name.
599 First check the modules dictionary if there's one there,
600 if not, create a new one and insert it in the modules dictionary.
601 Because the former action is most common, THIS DOES NOT RETURN A
605 PyImport_AddModule(const char *name
)
607 PyObject
*modules
= PyImport_GetModuleDict();
610 if ((m
= PyDict_GetItemString(modules
, name
)) != NULL
&&
613 m
= PyModule_New(name
);
616 if (PyDict_SetItemString(modules
, name
, m
) != 0) {
620 Py_DECREF(m
); /* Yes, it still exists, in modules! */
625 /* Remove name from sys.modules, if it's there. */
627 _RemoveModule(const char *name
)
629 PyObject
*modules
= PyImport_GetModuleDict();
630 if (PyDict_GetItemString(modules
, name
) == NULL
)
632 if (PyDict_DelItemString(modules
, name
) < 0)
633 Py_FatalError("import: deleting existing key in"
634 "sys.modules failed");
637 /* Execute a code object in a module and return the module object
638 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
639 * removed from sys.modules, to avoid leaving damaged module objects
640 * in sys.modules. The caller may wish to restore the original
641 * module object (if any) in this case; PyImport_ReloadModule is an
645 PyImport_ExecCodeModule(char *name
, PyObject
*co
)
647 return PyImport_ExecCodeModuleEx(name
, co
, (char *)NULL
);
651 PyImport_ExecCodeModuleEx(char *name
, PyObject
*co
, char *pathname
)
653 PyObject
*modules
= PyImport_GetModuleDict();
656 m
= PyImport_AddModule(name
);
659 /* If the module is being reloaded, we get the old module back
660 and re-use its dict to exec the new code. */
661 d
= PyModule_GetDict(m
);
662 if (PyDict_GetItemString(d
, "__builtins__") == NULL
) {
663 if (PyDict_SetItemString(d
, "__builtins__",
664 PyEval_GetBuiltins()) != 0)
667 /* Remember the filename as the __file__ attribute */
669 if (pathname
!= NULL
) {
670 v
= PyString_FromString(pathname
);
675 v
= ((PyCodeObject
*)co
)->co_filename
;
678 if (PyDict_SetItemString(d
, "__file__", v
) != 0)
679 PyErr_Clear(); /* Not important enough to report */
682 v
= PyEval_EvalCode((PyCodeObject
*)co
, d
, d
);
687 if ((m
= PyDict_GetItemString(modules
, name
)) == NULL
) {
688 PyErr_Format(PyExc_ImportError
,
689 "Loaded module %.200s not found in sys.modules",
704 /* Given a pathname for a Python source file, fill a buffer with the
705 pathname for the corresponding compiled file. Return the pathname
706 for the compiled file, or NULL if there's no space in the buffer.
707 Doesn't set an exception. */
710 make_compiled_pathname(char *pathname
, char *buf
, size_t buflen
)
712 size_t len
= strlen(pathname
);
717 /* Treat .pyw as if it were .py. The case of ".pyw" must match
718 that used in _PyImport_StandardFiletab. */
719 if (len
>= 4 && strcmp(&pathname
[len
-4], ".pyw") == 0)
720 --len
; /* pretend 'w' isn't there */
722 memcpy(buf
, pathname
, len
);
723 buf
[len
] = Py_OptimizeFlag
? 'o' : 'c';
730 /* Given a pathname for a Python source file, its time of last
731 modification, and a pathname for a compiled file, check whether the
732 compiled file represents the same version of the source. If so,
733 return a FILE pointer for the compiled file, positioned just after
734 the header; if not, return NULL.
735 Doesn't set an exception. */
738 check_compiled_module(char *pathname
, time_t mtime
, char *cpathname
)
744 fp
= fopen(cpathname
, "rb");
747 magic
= PyMarshal_ReadLongFromFile(fp
);
748 if (magic
!= pyc_magic
) {
750 PySys_WriteStderr("# %s has bad magic\n", cpathname
);
754 pyc_mtime
= PyMarshal_ReadLongFromFile(fp
);
755 if (pyc_mtime
!= mtime
) {
757 PySys_WriteStderr("# %s has bad mtime\n", cpathname
);
762 PySys_WriteStderr("# %s matches %s\n", cpathname
, pathname
);
767 /* Read a code object from a file and check it for validity */
769 static PyCodeObject
*
770 read_compiled_module(char *cpathname
, FILE *fp
)
774 co
= PyMarshal_ReadLastObjectFromFile(fp
);
777 if (!PyCode_Check(co
)) {
778 PyErr_Format(PyExc_ImportError
,
779 "Non-code object in %.200s", cpathname
);
783 return (PyCodeObject
*)co
;
787 /* Load a module from a compiled file, execute it, and return its
788 module object WITH INCREMENTED REFERENCE COUNT */
791 load_compiled_module(char *name
, char *cpathname
, FILE *fp
)
797 magic
= PyMarshal_ReadLongFromFile(fp
);
798 if (magic
!= pyc_magic
) {
799 PyErr_Format(PyExc_ImportError
,
800 "Bad magic number in %.200s", cpathname
);
803 (void) PyMarshal_ReadLongFromFile(fp
);
804 co
= read_compiled_module(cpathname
, fp
);
808 PySys_WriteStderr("import %s # precompiled from %s\n",
810 m
= PyImport_ExecCodeModuleEx(name
, (PyObject
*)co
, cpathname
);
816 /* Parse a source file and return the corresponding code object */
818 static PyCodeObject
*
819 parse_source_module(const char *pathname
, FILE *fp
)
821 PyCodeObject
*co
= NULL
;
823 PyCompilerFlags flags
;
824 PyArena
*arena
= PyArena_New();
830 mod
= PyParser_ASTFromFile(fp
, pathname
, Py_file_input
, 0, 0, &flags
,
833 co
= PyAST_Compile(mod
, pathname
, NULL
, arena
);
840 /* Helper to open a bytecode file for writing in exclusive mode */
843 open_exclusive(char *filename
, mode_t mode
)
845 #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
846 /* Use O_EXCL to avoid a race condition when another process tries to
847 write the same file. When that happens, our open() call fails,
848 which is just fine (since it's only a cache).
849 XXX If the file exists and is writable but the directory is not
850 writable, the file will never be written. Oh well.
853 (void) unlink(filename
);
854 fd
= open(filename
, O_EXCL
|O_CREAT
|O_WRONLY
|O_TRUNC
856 |O_BINARY
/* necessary for Windows */
859 , mode
, "ctxt=bin", "shr=nil"
866 return fdopen(fd
, "wb");
868 /* Best we can do -- on Windows this can't happen anyway */
869 return fopen(filename
, "wb");
874 /* Write a compiled module to a file, placing the time of last
875 modification of its source into the header.
876 Errors are ignored, if a write error occurs an attempt is made to
880 write_compiled_module(PyCodeObject
*co
, char *cpathname
, struct stat
*srcstat
)
883 time_t mtime
= srcstat
->st_mtime
;
884 #ifdef MS_WINDOWS /* since Windows uses different permissions */
885 mode_t mode
= srcstat
->st_mode
& ~S_IEXEC
;
887 mode_t mode
= srcstat
->st_mode
& ~S_IXUSR
& ~S_IXGRP
& ~S_IXOTH
;
890 fp
= open_exclusive(cpathname
, mode
);
894 "# can't create %s\n", cpathname
);
897 PyMarshal_WriteLongToFile(pyc_magic
, fp
, Py_MARSHAL_VERSION
);
898 /* First write a 0 for mtime */
899 PyMarshal_WriteLongToFile(0L, fp
, Py_MARSHAL_VERSION
);
900 PyMarshal_WriteObjectToFile((PyObject
*)co
, fp
, Py_MARSHAL_VERSION
);
901 if (fflush(fp
) != 0 || ferror(fp
)) {
903 PySys_WriteStderr("# can't write %s\n", cpathname
);
904 /* Don't keep partial file */
906 (void) unlink(cpathname
);
909 /* Now write the true mtime */
911 assert(mtime
< LONG_MAX
);
912 PyMarshal_WriteLongToFile((long)mtime
, fp
, Py_MARSHAL_VERSION
);
916 PySys_WriteStderr("# wrote %s\n", cpathname
);
920 update_code_filenames(PyCodeObject
*co
, PyObject
*oldname
, PyObject
*newname
)
922 PyObject
*constants
, *tmp
;
925 if (!_PyString_Eq(co
->co_filename
, oldname
))
928 tmp
= co
->co_filename
;
929 co
->co_filename
= newname
;
930 Py_INCREF(co
->co_filename
);
933 constants
= co
->co_consts
;
934 n
= PyTuple_GET_SIZE(constants
);
935 for (i
= 0; i
< n
; i
++) {
936 tmp
= PyTuple_GET_ITEM(constants
, i
);
937 if (PyCode_Check(tmp
))
938 update_code_filenames((PyCodeObject
*)tmp
,
944 update_compiled_module(PyCodeObject
*co
, char *pathname
)
946 PyObject
*oldname
, *newname
;
948 if (strcmp(PyString_AsString(co
->co_filename
), pathname
) == 0)
951 newname
= PyString_FromString(pathname
);
955 oldname
= co
->co_filename
;
957 update_code_filenames(co
, oldname
, newname
);
963 /* Load a source module from a given file and return its module
964 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
965 byte-compiled file, use that instead. */
968 load_source_module(char *name
, char *pathname
, FILE *fp
)
972 char buf
[MAXPATHLEN
+1];
977 if (fstat(fileno(fp
), &st
) != 0) {
978 PyErr_Format(PyExc_RuntimeError
,
979 "unable to get file status from '%s'",
983 #if SIZEOF_TIME_T > 4
984 /* Python's .pyc timestamp handling presumes that the timestamp fits
985 in 4 bytes. This will be fine until sometime in the year 2038,
986 when a 4-byte signed time_t will overflow.
988 if (st
.st_mtime
>> 32) {
989 PyErr_SetString(PyExc_OverflowError
,
990 "modification time overflows a 4 byte field");
994 cpathname
= make_compiled_pathname(pathname
, buf
,
995 (size_t)MAXPATHLEN
+ 1);
996 if (cpathname
!= NULL
&&
997 (fpc
= check_compiled_module(pathname
, st
.st_mtime
, cpathname
))) {
998 co
= read_compiled_module(cpathname
, fpc
);
1002 if (update_compiled_module(co
, pathname
) < 0)
1005 PySys_WriteStderr("import %s # precompiled from %s\n",
1007 pathname
= cpathname
;
1010 co
= parse_source_module(pathname
, fp
);
1014 PySys_WriteStderr("import %s # from %s\n",
1017 PyObject
*ro
= PySys_GetObject("dont_write_bytecode");
1018 if (ro
== NULL
|| !PyObject_IsTrue(ro
))
1019 write_compiled_module(co
, cpathname
, &st
);
1022 m
= PyImport_ExecCodeModuleEx(name
, (PyObject
*)co
, pathname
);
1030 static PyObject
*load_module(char *, FILE *, char *, int, PyObject
*);
1031 static struct filedescr
*find_module(char *, char *, PyObject
*,
1032 char *, size_t, FILE **, PyObject
**);
1033 static struct _frozen
*find_frozen(char *name
);
1035 /* Load a package and return its module object WITH INCREMENTED
1039 load_package(char *name
, char *pathname
)
1042 PyObject
*file
= NULL
;
1043 PyObject
*path
= NULL
;
1045 char buf
[MAXPATHLEN
+1];
1047 struct filedescr
*fdp
;
1049 m
= PyImport_AddModule(name
);
1053 PySys_WriteStderr("import %s # directory %s\n",
1055 d
= PyModule_GetDict(m
);
1056 file
= PyString_FromString(pathname
);
1059 path
= Py_BuildValue("[O]", file
);
1062 err
= PyDict_SetItemString(d
, "__file__", file
);
1064 err
= PyDict_SetItemString(d
, "__path__", path
);
1068 fdp
= find_module(name
, "__init__", path
, buf
, sizeof(buf
), &fp
, NULL
);
1070 if (PyErr_ExceptionMatches(PyExc_ImportError
)) {
1078 m
= load_module(name
, fp
, buf
, fdp
->type
, NULL
);
1092 /* Helper to test for built-in module */
1095 is_builtin(char *name
)
1098 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++) {
1099 if (strcmp(name
, PyImport_Inittab
[i
].name
) == 0) {
1100 if (PyImport_Inittab
[i
].initfunc
== NULL
)
1110 /* Return an importer object for a sys.path/pkg.__path__ item 'p',
1111 possibly by fetching it from the path_importer_cache dict. If it
1112 wasn't yet cached, traverse path_hooks until a hook is found
1113 that can handle the path item. Return None if no hook could;
1114 this tells our caller it should fall back to the builtin
1115 import mechanism. Cache the result in path_importer_cache.
1116 Returns a borrowed reference. */
1119 get_path_importer(PyObject
*path_importer_cache
, PyObject
*path_hooks
,
1123 Py_ssize_t j
, nhooks
;
1125 /* These conditions are the caller's responsibility: */
1126 assert(PyList_Check(path_hooks
));
1127 assert(PyDict_Check(path_importer_cache
));
1129 nhooks
= PyList_Size(path_hooks
);
1131 return NULL
; /* Shouldn't happen */
1133 importer
= PyDict_GetItem(path_importer_cache
, p
);
1134 if (importer
!= NULL
)
1137 /* set path_importer_cache[p] to None to avoid recursion */
1138 if (PyDict_SetItem(path_importer_cache
, p
, Py_None
) != 0)
1141 for (j
= 0; j
< nhooks
; j
++) {
1142 PyObject
*hook
= PyList_GetItem(path_hooks
, j
);
1145 importer
= PyObject_CallFunctionObjArgs(hook
, p
, NULL
);
1146 if (importer
!= NULL
)
1149 if (!PyErr_ExceptionMatches(PyExc_ImportError
)) {
1154 if (importer
== NULL
) {
1155 importer
= PyObject_CallFunctionObjArgs(
1156 (PyObject
*)&PyNullImporter_Type
, p
, NULL
1158 if (importer
== NULL
) {
1159 if (PyErr_ExceptionMatches(PyExc_ImportError
)) {
1165 if (importer
!= NULL
) {
1166 int err
= PyDict_SetItem(path_importer_cache
, p
, importer
);
1167 Py_DECREF(importer
);
1174 PyAPI_FUNC(PyObject
*)
1175 PyImport_GetImporter(PyObject
*path
) {
1176 PyObject
*importer
=NULL
, *path_importer_cache
=NULL
, *path_hooks
=NULL
;
1178 if ((path_importer_cache
= PySys_GetObject("path_importer_cache"))) {
1179 if ((path_hooks
= PySys_GetObject("path_hooks"))) {
1180 importer
= get_path_importer(path_importer_cache
,
1184 Py_XINCREF(importer
); /* get_path_importer returns a borrowed reference */
1188 /* Search the path (default sys.path) for a module. Return the
1189 corresponding filedescr struct, and (via return arguments) the
1190 pathname and an open file. Return NULL if the module is not found. */
1193 extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr
**,
1194 char *, Py_ssize_t
);
1197 static int case_ok(char *, Py_ssize_t
, Py_ssize_t
, char *);
1198 static int find_init_module(char *); /* Forward */
1199 static struct filedescr importhookdescr
= {"", "", IMP_HOOK
};
1201 static struct filedescr
*
1202 find_module(char *fullname
, char *subname
, PyObject
*path
, char *buf
,
1203 size_t buflen
, FILE **p_fp
, PyObject
**p_loader
)
1205 Py_ssize_t i
, npath
;
1206 size_t len
, namelen
;
1207 struct filedescr
*fdp
= NULL
;
1210 PyObject
*path_hooks
, *path_importer_cache
;
1212 struct stat statbuf
;
1214 static struct filedescr fd_frozen
= {"", "", PY_FROZEN
};
1215 static struct filedescr fd_builtin
= {"", "", C_BUILTIN
};
1216 static struct filedescr fd_package
= {"", "", PKG_DIRECTORY
};
1217 char name
[MAXPATHLEN
+1];
1218 #if defined(PYOS_OS2)
1220 size_t saved_namelen
;
1221 char *saved_buf
= NULL
;
1223 if (p_loader
!= NULL
)
1226 if (strlen(subname
) > MAXPATHLEN
) {
1227 PyErr_SetString(PyExc_OverflowError
,
1228 "module name is too long");
1231 strcpy(name
, subname
);
1233 /* sys.meta_path import hook */
1234 if (p_loader
!= NULL
) {
1235 PyObject
*meta_path
;
1237 meta_path
= PySys_GetObject("meta_path");
1238 if (meta_path
== NULL
|| !PyList_Check(meta_path
)) {
1239 PyErr_SetString(PyExc_ImportError
,
1240 "sys.meta_path must be a list of "
1244 Py_INCREF(meta_path
); /* zap guard */
1245 npath
= PyList_Size(meta_path
);
1246 for (i
= 0; i
< npath
; i
++) {
1248 PyObject
*hook
= PyList_GetItem(meta_path
, i
);
1249 loader
= PyObject_CallMethod(hook
, "find_module",
1253 if (loader
== NULL
) {
1254 Py_DECREF(meta_path
);
1255 return NULL
; /* true error */
1257 if (loader
!= Py_None
) {
1258 /* a loader was found */
1260 Py_DECREF(meta_path
);
1261 return &importhookdescr
;
1265 Py_DECREF(meta_path
);
1268 if (path
!= NULL
&& PyString_Check(path
)) {
1269 /* The only type of submodule allowed inside a "frozen"
1270 package are other frozen modules or packages. */
1271 if (PyString_Size(path
) + 1 + strlen(name
) >= (size_t)buflen
) {
1272 PyErr_SetString(PyExc_ImportError
,
1273 "full frozen module name too long");
1276 strcpy(buf
, PyString_AsString(path
));
1280 if (find_frozen(name
) != NULL
) {
1284 PyErr_Format(PyExc_ImportError
,
1285 "No frozen submodule named %.200s", name
);
1289 if (is_builtin(name
)) {
1293 if ((find_frozen(name
)) != NULL
) {
1299 fp
= PyWin_FindRegisteredModule(name
, &fdp
, buf
, buflen
);
1305 path
= PySys_GetObject("path");
1307 if (path
== NULL
|| !PyList_Check(path
)) {
1308 PyErr_SetString(PyExc_ImportError
,
1309 "sys.path must be a list of directory names");
1313 path_hooks
= PySys_GetObject("path_hooks");
1314 if (path_hooks
== NULL
|| !PyList_Check(path_hooks
)) {
1315 PyErr_SetString(PyExc_ImportError
,
1316 "sys.path_hooks must be a list of "
1320 path_importer_cache
= PySys_GetObject("path_importer_cache");
1321 if (path_importer_cache
== NULL
||
1322 !PyDict_Check(path_importer_cache
)) {
1323 PyErr_SetString(PyExc_ImportError
,
1324 "sys.path_importer_cache must be a dict");
1328 npath
= PyList_Size(path
);
1329 namelen
= strlen(name
);
1330 for (i
= 0; i
< npath
; i
++) {
1331 PyObject
*copy
= NULL
;
1332 PyObject
*v
= PyList_GetItem(path
, i
);
1335 #ifdef Py_USING_UNICODE
1336 if (PyUnicode_Check(v
)) {
1337 copy
= PyUnicode_Encode(PyUnicode_AS_UNICODE(v
),
1338 PyUnicode_GET_SIZE(v
), Py_FileSystemDefaultEncoding
, NULL
);
1345 if (!PyString_Check(v
))
1347 len
= PyString_GET_SIZE(v
);
1348 if (len
+ 2 + namelen
+ MAXSUFFIXSIZE
>= buflen
) {
1350 continue; /* Too long */
1352 strcpy(buf
, PyString_AS_STRING(v
));
1353 if (strlen(buf
) != len
) {
1355 continue; /* v contains '\0' */
1358 /* sys.path_hooks import hook */
1359 if (p_loader
!= NULL
) {
1362 importer
= get_path_importer(path_importer_cache
,
1364 if (importer
== NULL
) {
1368 /* Note: importer is a borrowed reference */
1369 if (importer
!= Py_None
) {
1371 loader
= PyObject_CallMethod(importer
,
1376 return NULL
; /* error */
1377 if (loader
!= Py_None
) {
1378 /* a loader was found */
1380 return &importhookdescr
;
1386 /* no hook was found, use builtin import */
1388 if (len
> 0 && buf
[len
-1] != SEP
1390 && buf
[len
-1] != ALTSEP
1394 strcpy(buf
+len
, name
);
1397 /* Check for package import (buf holds a directory name,
1398 and there's an __init__ module in that directory */
1400 if (stat(buf
, &statbuf
) == 0 && /* it exists */
1401 S_ISDIR(statbuf
.st_mode
) && /* it's a directory */
1402 case_ok(buf
, len
, namelen
, name
)) { /* case matches */
1403 if (find_init_module(buf
)) { /* and has __init__.py */
1408 char warnstr
[MAXPATHLEN
+80];
1409 sprintf(warnstr
, "Not importing directory "
1410 "'%.*s': missing __init__.py",
1412 if (PyErr_Warn(PyExc_ImportWarning
,
1420 /* XXX How are you going to test for directories? */
1423 case_ok(buf
, len
, namelen
, name
)) {
1424 if (find_init_module(buf
)) {
1429 char warnstr
[MAXPATHLEN
+80];
1430 sprintf(warnstr
, "Not importing directory "
1431 "'%.*s': missing __init__.py",
1433 if (PyErr_Warn(PyExc_ImportWarning
,
1441 #if defined(PYOS_OS2)
1442 /* take a snapshot of the module spec for restoration
1443 * after the 8 character DLL hackery
1445 saved_buf
= strdup(buf
);
1447 saved_namelen
= namelen
;
1448 #endif /* PYOS_OS2 */
1449 for (fdp
= _PyImport_Filetab
; fdp
->suffix
!= NULL
; fdp
++) {
1450 #if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
1451 /* OS/2 limits DLLs to 8 character names (w/o
1453 * so if the name is longer than that and its a
1454 * dynamically loaded module we're going to try,
1455 * truncate the name before trying
1457 if (strlen(subname
) > 8) {
1458 /* is this an attempt to load a C extension? */
1459 const struct filedescr
*scan
;
1460 scan
= _PyImport_DynLoadFiletab
;
1461 while (scan
->suffix
!= NULL
) {
1462 if (!strcmp(scan
->suffix
, fdp
->suffix
))
1467 if (scan
->suffix
!= NULL
) {
1468 /* yes, so truncate the name */
1470 len
-= strlen(subname
) - namelen
;
1474 #endif /* PYOS_OS2 */
1475 strcpy(buf
+len
, fdp
->suffix
);
1476 if (Py_VerboseFlag
> 1)
1477 PySys_WriteStderr("# trying %s\n", buf
);
1478 filemode
= fdp
->mode
;
1479 if (filemode
[0] == 'U')
1480 filemode
= "r" PY_STDIOTEXTMODE
;
1481 fp
= fopen(buf
, filemode
);
1483 if (case_ok(buf
, len
, namelen
, name
))
1485 else { /* continue search */
1490 #if defined(PYOS_OS2)
1491 /* restore the saved snapshot */
1492 strcpy(buf
, saved_buf
);
1494 namelen
= saved_namelen
;
1497 #if defined(PYOS_OS2)
1498 /* don't need/want the module name snapshot anymore */
1510 PyErr_Format(PyExc_ImportError
,
1511 "No module named %.200s", name
);
1518 /* Helpers for main.c
1519 * Find the source file corresponding to a named module
1522 _PyImport_FindModule(const char *name
, PyObject
*path
, char *buf
,
1523 size_t buflen
, FILE **p_fp
, PyObject
**p_loader
)
1525 return find_module((char *) name
, (char *) name
, path
,
1526 buf
, buflen
, p_fp
, p_loader
);
1529 PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr
* fd
)
1531 return fd
->type
== PY_SOURCE
|| fd
->type
== PY_COMPILED
;
1534 /* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
1535 * The arguments here are tricky, best shown by example:
1536 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1538 * |--------------------- buf ---------------------|
1539 * |------------------- len ------------------|
1540 * |------ name -------|
1541 * |----- namelen -----|
1542 * buf is the full path, but len only counts up to (& exclusive of) the
1543 * extension. name is the module name, also exclusive of extension.
1545 * We've already done a successful stat() or fopen() on buf, so know that
1546 * there's some match, possibly case-insensitive.
1548 * case_ok() is to return 1 if there's a case-sensitive match for
1549 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1552 * case_ok() is used to implement case-sensitive import semantics even
1553 * on platforms with case-insensitive filesystems. It's trivial to implement
1554 * for case-sensitive filesystems. It's pretty much a cross-platform
1555 * nightmare for systems with case-insensitive filesystems.
1558 /* First we may need a pile of platform-specific header files; the sequence
1559 * of #if's here should match the sequence in the body of case_ok().
1561 #if defined(MS_WINDOWS)
1562 #include <windows.h>
1564 #elif defined(DJGPP)
1567 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1568 #include <sys/types.h>
1571 #elif defined(PYOS_OS2)
1573 #define INCL_DOSERRORS
1574 #define INCL_NOPMAPI
1577 #elif defined(RISCOS)
1578 #include "oslib/osfscontrol.h"
1582 case_ok(char *buf
, Py_ssize_t len
, Py_ssize_t namelen
, char *name
)
1584 /* Pick a platform-specific implementation; the sequence of #if's here should
1585 * match the sequence just above.
1589 #if defined(MS_WINDOWS)
1590 WIN32_FIND_DATA data
;
1593 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1596 h
= FindFirstFile(buf
, &data
);
1597 if (h
== INVALID_HANDLE_VALUE
) {
1598 PyErr_Format(PyExc_NameError
,
1599 "Can't find file for module %.100s\n(filename %.300s)",
1604 return strncmp(data
.cFileName
, name
, namelen
) == 0;
1607 #elif defined(DJGPP)
1611 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1614 done
= findfirst(buf
, &ffblk
, FA_ARCH
|FA_RDONLY
|FA_HIDDEN
|FA_DIREC
);
1616 PyErr_Format(PyExc_NameError
,
1617 "Can't find file for module %.100s\n(filename %.300s)",
1621 return strncmp(ffblk
.ff_name
, name
, namelen
) == 0;
1623 /* new-fangled macintosh (macosx) or Cygwin */
1624 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1627 char dirname
[MAXPATHLEN
+ 1];
1628 const int dirlen
= len
- namelen
- 1; /* don't want trailing SEP */
1630 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1633 /* Copy the dir component into dirname; substitute "." if empty */
1639 assert(dirlen
<= MAXPATHLEN
);
1640 memcpy(dirname
, buf
, dirlen
);
1641 dirname
[dirlen
] = '\0';
1643 /* Open the directory and search the entries for an exact match. */
1644 dirp
= opendir(dirname
);
1646 char *nameWithExt
= buf
+ len
- namelen
;
1647 while ((dp
= readdir(dirp
)) != NULL
) {
1649 #ifdef _DIRENT_HAVE_D_NAMELEN
1654 if (thislen
>= namelen
&&
1655 strcmp(dp
->d_name
, nameWithExt
) == 0) {
1656 (void)closedir(dirp
);
1657 return 1; /* Found */
1660 (void)closedir(dirp
);
1662 return 0 ; /* Not found */
1665 #elif defined(RISCOS)
1666 char canon
[MAXPATHLEN
+1]; /* buffer for the canonical form of the path */
1667 char buf2
[MAXPATHLEN
+2];
1668 char *nameWithExt
= buf
+len
-namelen
;
1672 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1676 append wildcard, otherwise case of filename wouldn't be touched */
1680 e
= xosfscontrol_canonicalise_path(buf2
,canon
,0,0,MAXPATHLEN
+1,&canonlen
);
1681 canonlen
= MAXPATHLEN
+1-canonlen
;
1682 if (e
|| canonlen
<=0 || canonlen
>(MAXPATHLEN
+1) )
1684 if (strcmp(nameWithExt
, canon
+canonlen
-strlen(nameWithExt
))==0)
1685 return 1; /* match */
1690 #elif defined(PYOS_OS2)
1696 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1699 rc
= DosFindFirst(buf
,
1701 FILE_READONLY
| FILE_HIDDEN
| FILE_SYSTEM
| FILE_DIRECTORY
,
1702 &ffbuf
, sizeof(ffbuf
),
1707 return strncmp(ffbuf
.achName
, name
, namelen
) == 0;
1709 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1718 /* Helper to look for __init__.py or __init__.py[co] in potential package */
1720 find_init_module(char *buf
)
1722 const size_t save_len
= strlen(buf
);
1723 size_t i
= save_len
;
1724 char *pname
; /* pointer to start of __init__ */
1725 struct stat statbuf
;
1727 /* For calling case_ok(buf, len, namelen, name):
1728 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1730 * |--------------------- buf ---------------------|
1731 * |------------------- len ------------------|
1732 * |------ name -------|
1733 * |----- namelen -----|
1735 if (save_len
+ 13 >= MAXPATHLEN
)
1739 strcpy(pname
, "__init__.py");
1740 if (stat(buf
, &statbuf
) == 0) {
1742 save_len
+ 9, /* len("/__init__") */
1743 8, /* len("__init__") */
1745 buf
[save_len
] = '\0';
1750 strcpy(buf
+i
, Py_OptimizeFlag
? "o" : "c");
1751 if (stat(buf
, &statbuf
) == 0) {
1753 save_len
+ 9, /* len("/__init__") */
1754 8, /* len("__init__") */
1756 buf
[save_len
] = '\0';
1760 buf
[save_len
] = '\0';
1768 find_init_module(buf
)
1771 int save_len
= strlen(buf
);
1774 if (save_len
+ 13 >= MAXPATHLEN
)
1777 strcpy(buf
+i
, "__init__/py");
1779 buf
[save_len
] = '\0';
1783 if (Py_OptimizeFlag
)
1788 buf
[save_len
] = '\0';
1791 buf
[save_len
] = '\0';
1796 #endif /* HAVE_STAT */
1799 static int init_builtin(char *); /* Forward */
1801 /* Load an external module using the default search path and return
1802 its module object WITH INCREMENTED REFERENCE COUNT */
1805 load_module(char *name
, FILE *fp
, char *pathname
, int type
, PyObject
*loader
)
1811 /* First check that there's an open file (if we need one) */
1816 PyErr_Format(PyExc_ValueError
,
1817 "file object required for import (type code %d)",
1826 m
= load_source_module(name
, pathname
, fp
);
1830 m
= load_compiled_module(name
, pathname
, fp
);
1833 #ifdef HAVE_DYNAMIC_LOADING
1835 m
= _PyImport_LoadDynamicModule(name
, pathname
, fp
);
1840 m
= load_package(name
, pathname
);
1845 if (pathname
!= NULL
&& pathname
[0] != '\0')
1847 if (type
== C_BUILTIN
)
1848 err
= init_builtin(name
);
1850 err
= PyImport_ImportFrozenModule(name
);
1854 PyErr_Format(PyExc_ImportError
,
1855 "Purported %s module %.200s not found",
1857 "builtin" : "frozen",
1861 modules
= PyImport_GetModuleDict();
1862 m
= PyDict_GetItemString(modules
, name
);
1866 "%s module %.200s not properly initialized",
1868 "builtin" : "frozen",
1876 if (loader
== NULL
) {
1877 PyErr_SetString(PyExc_ImportError
,
1878 "import hook without loader");
1881 m
= PyObject_CallMethod(loader
, "load_module", "s", name
);
1886 PyErr_Format(PyExc_ImportError
,
1887 "Don't know how to import %.200s (type code %d)",
1897 /* Initialize a built-in module.
1898 Return 1 for success, 0 if the module is not found, and -1 with
1899 an exception set if the initialization failed. */
1902 init_builtin(char *name
)
1906 if (_PyImport_FindExtension(name
, name
) != NULL
)
1909 for (p
= PyImport_Inittab
; p
->name
!= NULL
; p
++) {
1910 if (strcmp(name
, p
->name
) == 0) {
1911 if (p
->initfunc
== NULL
) {
1912 PyErr_Format(PyExc_ImportError
,
1913 "Cannot re-init internal module %.200s",
1918 PySys_WriteStderr("import %s # builtin\n", name
);
1920 if (PyErr_Occurred())
1922 if (_PyImport_FixupExtension(name
, name
) == NULL
)
1931 /* Frozen modules */
1933 static struct _frozen
*
1934 find_frozen(char *name
)
1938 for (p
= PyImport_FrozenModules
; ; p
++) {
1939 if (p
->name
== NULL
)
1941 if (strcmp(p
->name
, name
) == 0)
1948 get_frozen_object(char *name
)
1950 struct _frozen
*p
= find_frozen(name
);
1954 PyErr_Format(PyExc_ImportError
,
1955 "No such frozen object named %.200s",
1959 if (p
->code
== NULL
) {
1960 PyErr_Format(PyExc_ImportError
,
1961 "Excluded frozen object named %.200s",
1968 return PyMarshal_ReadObjectFromString((char *)p
->code
, size
);
1971 /* Initialize a frozen module.
1972 Return 1 for succes, 0 if the module is not found, and -1 with
1973 an exception set if the initialization failed.
1974 This function is also used from frozenmain.c */
1977 PyImport_ImportFrozenModule(char *name
)
1979 struct _frozen
*p
= find_frozen(name
);
1987 if (p
->code
== NULL
) {
1988 PyErr_Format(PyExc_ImportError
,
1989 "Excluded frozen object named %.200s",
1994 ispackage
= (size
< 0);
1998 PySys_WriteStderr("import %s # frozen%s\n",
1999 name
, ispackage
? " package" : "");
2000 co
= PyMarshal_ReadObjectFromString((char *)p
->code
, size
);
2003 if (!PyCode_Check(co
)) {
2004 PyErr_Format(PyExc_TypeError
,
2005 "frozen object %.200s is not a code object",
2010 /* Set __path__ to the package name */
2013 m
= PyImport_AddModule(name
);
2016 d
= PyModule_GetDict(m
);
2017 s
= PyString_InternFromString(name
);
2020 err
= PyDict_SetItemString(d
, "__path__", s
);
2025 m
= PyImport_ExecCodeModuleEx(name
, co
, "<frozen>");
2037 /* Import a module, either built-in, frozen, or external, and return
2038 its module object WITH INCREMENTED REFERENCE COUNT */
2041 PyImport_ImportModule(const char *name
)
2046 pname
= PyString_FromString(name
);
2049 result
= PyImport_Import(pname
);
2054 /* Import a module without blocking
2056 * At first it tries to fetch the module from sys.modules. If the module was
2057 * never loaded before it loads it with PyImport_ImportModule() unless another
2058 * thread holds the import lock. In the latter case the function raises an
2059 * ImportError instead of blocking.
2061 * Returns the module object with incremented ref count.
2064 PyImport_ImportModuleNoBlock(const char *name
)
2070 /* Try to get the module from sys.modules[name] */
2071 modules
= PyImport_GetModuleDict();
2072 if (modules
== NULL
)
2075 result
= PyDict_GetItemString(modules
, name
);
2076 if (result
!= NULL
) {
2084 /* check the import lock
2085 * me might be -1 but I ignore the error here, the lock function
2086 * takes care of the problem */
2087 me
= PyThread_get_thread_ident();
2088 if (import_lock_thread
== -1 || import_lock_thread
== me
) {
2089 /* no thread or me is holding the lock */
2090 return PyImport_ImportModule(name
);
2093 PyErr_Format(PyExc_ImportError
,
2094 "Failed to import %.200s because the import lock"
2095 "is held by another thread.",
2100 return PyImport_ImportModule(name
);
2104 /* Forward declarations for helper routines */
2105 static PyObject
*get_parent(PyObject
*globals
, char *buf
,
2106 Py_ssize_t
*p_buflen
, int level
);
2107 static PyObject
*load_next(PyObject
*mod
, PyObject
*altmod
,
2108 char **p_name
, char *buf
, Py_ssize_t
*p_buflen
);
2109 static int mark_miss(char *name
);
2110 static int ensure_fromlist(PyObject
*mod
, PyObject
*fromlist
,
2111 char *buf
, Py_ssize_t buflen
, int recursive
);
2112 static PyObject
* import_submodule(PyObject
*mod
, char *name
, char *fullname
);
2114 /* The Magnum Opus of dotted-name import :-) */
2117 import_module_level(char *name
, PyObject
*globals
, PyObject
*locals
,
2118 PyObject
*fromlist
, int level
)
2120 char buf
[MAXPATHLEN
+1];
2121 Py_ssize_t buflen
= 0;
2122 PyObject
*parent
, *head
, *next
, *tail
;
2124 if (strchr(name
, '/') != NULL
2126 || strchr(name
, '\\') != NULL
2129 PyErr_SetString(PyExc_ImportError
,
2130 "Import by filename is not supported.");
2134 parent
= get_parent(globals
, buf
, &buflen
, level
);
2138 head
= load_next(parent
, Py_None
, &name
, buf
, &buflen
);
2145 next
= load_next(tail
, tail
, &name
, buf
, &buflen
);
2153 if (tail
== Py_None
) {
2154 /* If tail is Py_None, both get_parent and load_next found
2155 an empty module name: someone called __import__("") or
2156 doctored faulty bytecode */
2159 PyErr_SetString(PyExc_ValueError
,
2160 "Empty module name");
2164 if (fromlist
!= NULL
) {
2165 if (fromlist
== Py_None
|| !PyObject_IsTrue(fromlist
))
2169 if (fromlist
== NULL
) {
2175 if (!ensure_fromlist(tail
, fromlist
, buf
, buflen
, 0)) {
2184 PyImport_ImportModuleLevel(char *name
, PyObject
*globals
, PyObject
*locals
,
2185 PyObject
*fromlist
, int level
)
2189 result
= import_module_level(name
, globals
, locals
, fromlist
, level
);
2190 if (unlock_import() < 0) {
2192 PyErr_SetString(PyExc_RuntimeError
,
2193 "not holding the import lock");
2199 /* Return the package that an import is being performed in. If globals comes
2200 from the module foo.bar.bat (not itself a package), this returns the
2201 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2202 the package's entry in sys.modules is returned, as a borrowed reference.
2204 The *name* of the returned package is returned in buf, with the length of
2205 the name in *p_buflen.
2207 If globals doesn't come from a package or a module in a package, or a
2208 corresponding entry is not found in sys.modules, Py_None is returned.
2211 get_parent(PyObject
*globals
, char *buf
, Py_ssize_t
*p_buflen
, int level
)
2213 static PyObject
*namestr
= NULL
;
2214 static PyObject
*pathstr
= NULL
;
2215 static PyObject
*pkgstr
= NULL
;
2216 PyObject
*pkgname
, *modname
, *modpath
, *modules
, *parent
;
2217 int orig_level
= level
;
2219 if (globals
== NULL
|| !PyDict_Check(globals
) || !level
)
2222 if (namestr
== NULL
) {
2223 namestr
= PyString_InternFromString("__name__");
2224 if (namestr
== NULL
)
2227 if (pathstr
== NULL
) {
2228 pathstr
= PyString_InternFromString("__path__");
2229 if (pathstr
== NULL
)
2232 if (pkgstr
== NULL
) {
2233 pkgstr
= PyString_InternFromString("__package__");
2240 pkgname
= PyDict_GetItem(globals
, pkgstr
);
2242 if ((pkgname
!= NULL
) && (pkgname
!= Py_None
)) {
2243 /* __package__ is set, so use it */
2245 if (!PyString_Check(pkgname
)) {
2246 PyErr_SetString(PyExc_ValueError
,
2247 "__package__ set to non-string");
2250 len
= PyString_GET_SIZE(pkgname
);
2253 PyErr_SetString(PyExc_ValueError
,
2254 "Attempted relative import in non-package");
2259 if (len
> MAXPATHLEN
) {
2260 PyErr_SetString(PyExc_ValueError
,
2261 "Package name too long");
2264 strcpy(buf
, PyString_AS_STRING(pkgname
));
2266 /* __package__ not set, so figure it out and set it */
2267 modname
= PyDict_GetItem(globals
, namestr
);
2268 if (modname
== NULL
|| !PyString_Check(modname
))
2271 modpath
= PyDict_GetItem(globals
, pathstr
);
2272 if (modpath
!= NULL
) {
2273 /* __path__ is set, so modname is already the package name */
2274 Py_ssize_t len
= PyString_GET_SIZE(modname
);
2276 if (len
> MAXPATHLEN
) {
2277 PyErr_SetString(PyExc_ValueError
,
2278 "Module name too long");
2281 strcpy(buf
, PyString_AS_STRING(modname
));
2282 error
= PyDict_SetItem(globals
, pkgstr
, modname
);
2284 PyErr_SetString(PyExc_ValueError
,
2285 "Could not set __package__");
2289 /* Normal module, so work out the package name if any */
2290 char *start
= PyString_AS_STRING(modname
);
2291 char *lastdot
= strrchr(start
, '.');
2294 if (lastdot
== NULL
&& level
> 0) {
2295 PyErr_SetString(PyExc_ValueError
,
2296 "Attempted relative import in non-package");
2299 if (lastdot
== NULL
) {
2300 error
= PyDict_SetItem(globals
, pkgstr
, Py_None
);
2302 PyErr_SetString(PyExc_ValueError
,
2303 "Could not set __package__");
2308 len
= lastdot
- start
;
2309 if (len
>= MAXPATHLEN
) {
2310 PyErr_SetString(PyExc_ValueError
,
2311 "Module name too long");
2314 strncpy(buf
, start
, len
);
2316 pkgname
= PyString_FromString(buf
);
2317 if (pkgname
== NULL
) {
2320 error
= PyDict_SetItem(globals
, pkgstr
, pkgname
);
2323 PyErr_SetString(PyExc_ValueError
,
2324 "Could not set __package__");
2329 while (--level
> 0) {
2330 char *dot
= strrchr(buf
, '.');
2332 PyErr_SetString(PyExc_ValueError
,
2333 "Attempted relative import beyond "
2334 "toplevel package");
2339 *p_buflen
= strlen(buf
);
2341 modules
= PyImport_GetModuleDict();
2342 parent
= PyDict_GetItemString(modules
, buf
);
2343 if (parent
== NULL
) {
2344 if (orig_level
< 1) {
2345 PyObject
*err_msg
= PyString_FromFormat(
2346 "Parent module '%.200s' not found "
2347 "while handling absolute import", buf
);
2348 if (err_msg
== NULL
) {
2351 if (!PyErr_WarnEx(PyExc_RuntimeWarning
,
2352 PyString_AsString(err_msg
), 1)) {
2359 PyErr_Format(PyExc_SystemError
,
2360 "Parent module '%.200s' not loaded, "
2361 "cannot perform relative import", buf
);
2365 /* We expect, but can't guarantee, if parent != None, that:
2366 - parent.__name__ == buf
2367 - parent.__dict__ is globals
2368 If this is violated... Who cares? */
2371 /* altmod is either None or same as mod */
2373 load_next(PyObject
*mod
, PyObject
*altmod
, char **p_name
, char *buf
,
2374 Py_ssize_t
*p_buflen
)
2376 char *name
= *p_name
;
2377 char *dot
= strchr(name
, '.');
2382 if (strlen(name
) == 0) {
2383 /* completely empty module name should only happen in
2384 'from . import' (or '__import__("")')*/
2399 PyErr_SetString(PyExc_ValueError
,
2400 "Empty module name");
2404 p
= buf
+ *p_buflen
;
2407 if (p
+len
-buf
>= MAXPATHLEN
) {
2408 PyErr_SetString(PyExc_ValueError
,
2409 "Module name too long");
2412 strncpy(p
, name
, len
);
2414 *p_buflen
= p
+len
-buf
;
2416 result
= import_submodule(mod
, p
, buf
);
2417 if (result
== Py_None
&& altmod
!= mod
) {
2419 /* Here, altmod must be None and mod must not be None */
2420 result
= import_submodule(altmod
, p
, p
);
2421 if (result
!= NULL
&& result
!= Py_None
) {
2422 if (mark_miss(buf
) != 0) {
2426 strncpy(buf
, name
, len
);
2434 if (result
== Py_None
) {
2436 PyErr_Format(PyExc_ImportError
,
2437 "No module named %.200s", name
);
2445 mark_miss(char *name
)
2447 PyObject
*modules
= PyImport_GetModuleDict();
2448 return PyDict_SetItemString(modules
, name
, Py_None
);
2452 ensure_fromlist(PyObject
*mod
, PyObject
*fromlist
, char *buf
, Py_ssize_t buflen
,
2457 if (!PyObject_HasAttrString(mod
, "__path__"))
2460 for (i
= 0; ; i
++) {
2461 PyObject
*item
= PySequence_GetItem(fromlist
, i
);
2464 if (PyErr_ExceptionMatches(PyExc_IndexError
)) {
2470 if (!PyString_Check(item
)) {
2471 PyErr_SetString(PyExc_TypeError
,
2472 "Item in ``from list'' not a string");
2476 if (PyString_AS_STRING(item
)[0] == '*') {
2479 /* See if the package defines __all__ */
2481 continue; /* Avoid endless recursion */
2482 all
= PyObject_GetAttrString(mod
, "__all__");
2486 int ret
= ensure_fromlist(mod
, all
, buf
, buflen
, 1);
2493 hasit
= PyObject_HasAttr(mod
, item
);
2495 char *subname
= PyString_AS_STRING(item
);
2498 if (buflen
+ strlen(subname
) >= MAXPATHLEN
) {
2499 PyErr_SetString(PyExc_ValueError
,
2500 "Module name too long");
2507 submod
= import_submodule(mod
, subname
, buf
);
2509 if (submod
== NULL
) {
2521 add_submodule(PyObject
*mod
, PyObject
*submod
, char *fullname
, char *subname
,
2526 /* Irrespective of the success of this load, make a
2527 reference to it in the parent package module. A copy gets
2528 saved in the modules dictionary under the full name, so get a
2529 reference from there, if need be. (The exception is when the
2530 load failed with a SyntaxError -- then there's no trace in
2531 sys.modules. In that case, of course, do nothing extra.) */
2532 if (submod
== NULL
) {
2533 submod
= PyDict_GetItemString(modules
, fullname
);
2537 if (PyModule_Check(mod
)) {
2538 /* We can't use setattr here since it can give a
2539 * spurious warning if the submodule name shadows a
2541 PyObject
*dict
= PyModule_GetDict(mod
);
2544 if (PyDict_SetItemString(dict
, subname
, submod
) < 0)
2548 if (PyObject_SetAttrString(mod
, subname
, submod
) < 0)
2555 import_submodule(PyObject
*mod
, char *subname
, char *fullname
)
2557 PyObject
*modules
= PyImport_GetModuleDict();
2561 if mod == None: subname == fullname
2562 else: mod.__name__ + "." + subname == fullname
2565 if ((m
= PyDict_GetItemString(modules
, fullname
)) != NULL
) {
2569 PyObject
*path
, *loader
= NULL
;
2570 char buf
[MAXPATHLEN
+1];
2571 struct filedescr
*fdp
;
2577 path
= PyObject_GetAttrString(mod
, "__path__");
2586 fdp
= find_module(fullname
, subname
, path
, buf
, MAXPATHLEN
+1,
2590 if (!PyErr_ExceptionMatches(PyExc_ImportError
))
2596 m
= load_module(fullname
, fp
, buf
, fdp
->type
, loader
);
2600 if (!add_submodule(mod
, m
, fullname
, subname
, modules
)) {
2610 /* Re-import a module of any kind and return its module object, WITH
2611 INCREMENTED REFERENCE COUNT */
2614 PyImport_ReloadModule(PyObject
*m
)
2616 PyInterpreterState
*interp
= PyThreadState_Get()->interp
;
2617 PyObject
*modules_reloading
= interp
->modules_reloading
;
2618 PyObject
*modules
= PyImport_GetModuleDict();
2619 PyObject
*path
= NULL
, *loader
= NULL
, *existing_m
= NULL
;
2620 char *name
, *subname
;
2621 char buf
[MAXPATHLEN
+1];
2622 struct filedescr
*fdp
;
2626 if (modules_reloading
== NULL
) {
2627 Py_FatalError("PyImport_ReloadModule: "
2628 "no modules_reloading dictionary!");
2632 if (m
== NULL
|| !PyModule_Check(m
)) {
2633 PyErr_SetString(PyExc_TypeError
,
2634 "reload() argument must be module");
2637 name
= PyModule_GetName(m
);
2640 if (m
!= PyDict_GetItemString(modules
, name
)) {
2641 PyErr_Format(PyExc_ImportError
,
2642 "reload(): module %.200s not in sys.modules",
2646 existing_m
= PyDict_GetItemString(modules_reloading
, name
);
2647 if (existing_m
!= NULL
) {
2648 /* Due to a recursive reload, this module is already
2650 Py_INCREF(existing_m
);
2653 if (PyDict_SetItemString(modules_reloading
, name
, m
) < 0)
2656 subname
= strrchr(name
, '.');
2657 if (subname
== NULL
)
2660 PyObject
*parentname
, *parent
;
2661 parentname
= PyString_FromStringAndSize(name
, (subname
-name
));
2662 if (parentname
== NULL
) {
2663 imp_modules_reloading_clear();
2666 parent
= PyDict_GetItem(modules
, parentname
);
2667 if (parent
== NULL
) {
2668 PyErr_Format(PyExc_ImportError
,
2669 "reload(): parent %.200s not in sys.modules",
2670 PyString_AS_STRING(parentname
));
2671 Py_DECREF(parentname
);
2672 imp_modules_reloading_clear();
2675 Py_DECREF(parentname
);
2677 path
= PyObject_GetAttrString(parent
, "__path__");
2682 fdp
= find_module(name
, subname
, path
, buf
, MAXPATHLEN
+1, &fp
, &loader
);
2687 imp_modules_reloading_clear();
2691 newm
= load_module(name
, fp
, buf
, fdp
->type
, loader
);
2697 /* load_module probably removed name from modules because of
2698 * the error. Put back the original module object. We're
2699 * going to return NULL in this case regardless of whether
2700 * replacing name succeeds, so the return value is ignored.
2702 PyDict_SetItemString(modules
, name
, m
);
2704 imp_modules_reloading_clear();
2709 /* Higher-level import emulator which emulates the "import" statement
2710 more accurately -- it invokes the __import__() function from the
2711 builtins of the current globals. This means that the import is
2712 done using whatever import hooks are installed in the current
2713 environment, e.g. by "rexec".
2714 A dummy list ["__doc__"] is passed as the 4th argument so that
2715 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2716 will return <module "gencache"> instead of <module "win32com">. */
2719 PyImport_Import(PyObject
*module_name
)
2721 static PyObject
*silly_list
= NULL
;
2722 static PyObject
*builtins_str
= NULL
;
2723 static PyObject
*import_str
= NULL
;
2724 PyObject
*globals
= NULL
;
2725 PyObject
*import
= NULL
;
2726 PyObject
*builtins
= NULL
;
2729 /* Initialize constant string objects */
2730 if (silly_list
== NULL
) {
2731 import_str
= PyString_InternFromString("__import__");
2732 if (import_str
== NULL
)
2734 builtins_str
= PyString_InternFromString("__builtins__");
2735 if (builtins_str
== NULL
)
2737 silly_list
= Py_BuildValue("[s]", "__doc__");
2738 if (silly_list
== NULL
)
2742 /* Get the builtins from current globals */
2743 globals
= PyEval_GetGlobals();
2744 if (globals
!= NULL
) {
2746 builtins
= PyObject_GetItem(globals
, builtins_str
);
2747 if (builtins
== NULL
)
2751 /* 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
);