2 /* Module definition and import implementation */
6 #include "Python-ast.h"
24 extern time_t PyOS_GetLastModificationTime(char *, FILE *);
27 /* Magic word to reject .pyc files generated by other Python versions.
28 It should change for each incompatible change to the bytecode.
30 The value of CR and LF is incorporated so if you ever read or write
31 a .pyc file in text mode the magic number will be wrong; also, the
32 Apple MPW compiler swaps their values, botching string constants.
34 The magic numbers must be spaced apart atleast 2 values, as the
35 -U interpeter flag will cause MAGIC+1 being used. They have been
36 odd numbers for some time now.
38 There were a variety of old schemes for setting the magic number.
39 The current working scheme is to increment the previous value by
55 Python 2.3a0: 62011 (!)
60 Python 2.5a0: 62081 (ast-branch)
61 Python 2.5a0: 62091 (with)
62 Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)
63 Python 2.5b3: 62101 (fix wrong code: for x, in ...)
64 Python 2.5b3: 62111 (fix wrong code: x += yield)
65 Python 2.5c1: 62121 (fix wrong lnotab with for loops and
66 storing constants that should have been removed)
67 Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)
70 #define MAGIC (62131 | ((long)'\r'<<16) | ((long)'\n'<<24))
72 /* Magic word as global; note that _PyImport_Init() can change the
73 value of this global to accommodate for alterations of how the
74 compiler works which are enabled by command line switches. */
75 static long pyc_magic
= MAGIC
;
77 /* See _PyImport_FixupExtension() below */
78 static PyObject
*extensions
= NULL
;
80 /* This table is defined in config.c: */
81 extern struct _inittab _PyImport_Inittab
[];
83 struct _inittab
*PyImport_Inittab
= _PyImport_Inittab
;
85 /* these tables define the module suffixes that Python recognizes */
86 struct filedescr
* _PyImport_Filetab
= NULL
;
89 static const struct filedescr _PyImport_StandardFiletab
[] = {
90 {"/py", "U", PY_SOURCE
},
91 {"/pyc", "rb", PY_COMPILED
},
95 static const struct filedescr _PyImport_StandardFiletab
[] = {
96 {".py", "U", PY_SOURCE
},
98 {".pyw", "U", PY_SOURCE
},
100 {".pyc", "rb", PY_COMPILED
},
105 static PyTypeObject NullImporterType
; /* Forward reference */
107 /* Initialize things */
112 const struct filedescr
*scan
;
113 struct filedescr
*filetab
;
117 /* prepare _PyImport_Filetab: copy entries from
118 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
120 for (scan
= _PyImport_DynLoadFiletab
; scan
->suffix
!= NULL
; ++scan
)
122 for (scan
= _PyImport_StandardFiletab
; scan
->suffix
!= NULL
; ++scan
)
124 filetab
= PyMem_NEW(struct filedescr
, countD
+ countS
+ 1);
126 Py_FatalError("Can't initialize import file table.");
127 memcpy(filetab
, _PyImport_DynLoadFiletab
,
128 countD
* sizeof(struct filedescr
));
129 memcpy(filetab
+ countD
, _PyImport_StandardFiletab
,
130 countS
* sizeof(struct filedescr
));
131 filetab
[countD
+ countS
].suffix
= NULL
;
133 _PyImport_Filetab
= filetab
;
135 if (Py_OptimizeFlag
) {
136 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
137 for (; filetab
->suffix
!= NULL
; filetab
++) {
139 if (strcmp(filetab
->suffix
, ".pyc") == 0)
140 filetab
->suffix
= ".pyo";
142 if (strcmp(filetab
->suffix
, "/pyc") == 0)
143 filetab
->suffix
= "/pyo";
148 if (Py_UnicodeFlag
) {
149 /* Fix the pyc_magic so that byte compiled code created
150 using the all-Unicode method doesn't interfere with
151 code created in normal operation mode. */
152 pyc_magic
= MAGIC
+ 1;
157 _PyImportHooks_Init(void)
159 PyObject
*v
, *path_hooks
= NULL
, *zimpimport
;
162 /* adding sys.path_hooks and sys.path_importer_cache, setting up
164 if (PyType_Ready(&NullImporterType
) < 0)
168 PySys_WriteStderr("# installing zipimport hook\n");
173 err
= PySys_SetObject("meta_path", v
);
180 err
= PySys_SetObject("path_importer_cache", v
);
184 path_hooks
= PyList_New(0);
185 if (path_hooks
== NULL
)
187 err
= PySys_SetObject("path_hooks", path_hooks
);
191 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
192 "path_importer_cache, or NullImporter failed"
196 zimpimport
= PyImport_ImportModule("zipimport");
197 if (zimpimport
== NULL
) {
198 PyErr_Clear(); /* No zip import module -- okay */
200 PySys_WriteStderr("# can't import zipimport\n");
203 PyObject
*zipimporter
= PyObject_GetAttrString(zimpimport
,
205 Py_DECREF(zimpimport
);
206 if (zipimporter
== NULL
) {
207 PyErr_Clear(); /* No zipimporter object -- okay */
210 "# can't import zipimport.zipimporter\n");
213 /* sys.path_hooks.append(zipimporter) */
214 err
= PyList_Append(path_hooks
, zipimporter
);
215 Py_DECREF(zipimporter
);
220 "# installed zipimport hook\n");
223 Py_DECREF(path_hooks
);
229 Py_XDECREF(extensions
);
231 PyMem_DEL(_PyImport_Filetab
);
232 _PyImport_Filetab
= NULL
;
236 /* Locking primitives to prevent parallel imports of the same module
237 in different threads to return with a partially loaded module.
238 These calls are serialized by the global interpreter lock. */
242 #include "pythread.h"
244 static PyThread_type_lock import_lock
= 0;
245 static long import_lock_thread
= -1;
246 static int import_lock_level
= 0;
251 long me
= PyThread_get_thread_ident();
253 return; /* Too bad */
254 if (import_lock
== NULL
) {
255 import_lock
= PyThread_allocate_lock();
256 if (import_lock
== NULL
)
257 return; /* Nothing much we can do. */
259 if (import_lock_thread
== me
) {
263 if (import_lock_thread
!= -1 || !PyThread_acquire_lock(import_lock
, 0))
265 PyThreadState
*tstate
= PyEval_SaveThread();
266 PyThread_acquire_lock(import_lock
, 1);
267 PyEval_RestoreThread(tstate
);
269 import_lock_thread
= me
;
270 import_lock_level
= 1;
276 long me
= PyThread_get_thread_ident();
277 if (me
== -1 || import_lock
== NULL
)
278 return 0; /* Too bad */
279 if (import_lock_thread
!= me
)
282 if (import_lock_level
== 0) {
283 import_lock_thread
= -1;
284 PyThread_release_lock(import_lock
);
289 /* This function is called from PyOS_AfterFork to ensure that newly
290 created child processes do not share locks with the parent. */
293 _PyImport_ReInitLock(void)
296 if (import_lock
!= NULL
)
297 import_lock
= PyThread_allocate_lock();
303 #define lock_import()
304 #define unlock_import() 0
309 imp_lock_held(PyObject
*self
, PyObject
*noargs
)
312 return PyBool_FromLong(import_lock_thread
!= -1);
314 return PyBool_FromLong(0);
319 imp_acquire_lock(PyObject
*self
, PyObject
*noargs
)
329 imp_release_lock(PyObject
*self
, PyObject
*noargs
)
332 if (unlock_import() < 0) {
333 PyErr_SetString(PyExc_RuntimeError
,
334 "not holding the import lock");
345 PyImport_GetModuleDict(void)
347 PyInterpreterState
*interp
= PyThreadState_GET()->interp
;
348 if (interp
->modules
== NULL
)
349 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
350 return interp
->modules
;
354 /* List of names to clear in sys */
355 static char* sys_deletes
[] = {
356 "path", "argv", "ps1", "ps2", "exitfunc",
357 "exc_type", "exc_value", "exc_traceback",
358 "last_type", "last_value", "last_traceback",
359 "path_hooks", "path_importer_cache", "meta_path",
363 static char* sys_files
[] = {
364 "stdin", "__stdin__",
365 "stdout", "__stdout__",
366 "stderr", "__stderr__",
371 /* Un-initialize things, as good as we can */
374 PyImport_Cleanup(void)
376 Py_ssize_t pos
, ndone
;
378 PyObject
*key
, *value
, *dict
;
379 PyInterpreterState
*interp
= PyThreadState_GET()->interp
;
380 PyObject
*modules
= interp
->modules
;
383 return; /* Already done */
385 /* Delete some special variables first. These are common
386 places where user values hide and people complain when their
387 destructors fail. Since the modules containing them are
388 deleted *last* of all, they would come too late in the normal
389 destruction order. Sigh. */
391 value
= PyDict_GetItemString(modules
, "__builtin__");
392 if (value
!= NULL
&& PyModule_Check(value
)) {
393 dict
= PyModule_GetDict(value
);
395 PySys_WriteStderr("# clear __builtin__._\n");
396 PyDict_SetItemString(dict
, "_", Py_None
);
398 value
= PyDict_GetItemString(modules
, "sys");
399 if (value
!= NULL
&& PyModule_Check(value
)) {
402 dict
= PyModule_GetDict(value
);
403 for (p
= sys_deletes
; *p
!= NULL
; p
++) {
405 PySys_WriteStderr("# clear sys.%s\n", *p
);
406 PyDict_SetItemString(dict
, *p
, Py_None
);
408 for (p
= sys_files
; *p
!= NULL
; p
+=2) {
410 PySys_WriteStderr("# restore sys.%s\n", *p
);
411 v
= PyDict_GetItemString(dict
, *(p
+1));
414 PyDict_SetItemString(dict
, *p
, v
);
418 /* First, delete __main__ */
419 value
= PyDict_GetItemString(modules
, "__main__");
420 if (value
!= NULL
&& PyModule_Check(value
)) {
422 PySys_WriteStderr("# cleanup __main__\n");
423 _PyModule_Clear(value
);
424 PyDict_SetItemString(modules
, "__main__", Py_None
);
427 /* The special treatment of __builtin__ here is because even
428 when it's not referenced as a module, its dictionary is
429 referenced by almost every module's __builtins__. Since
430 deleting a module clears its dictionary (even if there are
431 references left to it), we need to delete the __builtin__
432 module last. Likewise, we don't delete sys until the very
433 end because it is implicitly referenced (e.g. by print).
435 Also note that we 'delete' modules by replacing their entry
436 in the modules dict with None, rather than really deleting
437 them; this avoids a rehash of the modules dictionary and
438 also marks them as "non existent" so they won't be
441 /* Next, repeatedly delete modules with a reference count of
442 one (skipping __builtin__ and sys) and delete them */
446 while (PyDict_Next(modules
, &pos
, &key
, &value
)) {
447 if (value
->ob_refcnt
!= 1)
449 if (PyString_Check(key
) && PyModule_Check(value
)) {
450 name
= PyString_AS_STRING(key
);
451 if (strcmp(name
, "__builtin__") == 0)
453 if (strcmp(name
, "sys") == 0)
457 "# cleanup[1] %s\n", name
);
458 _PyModule_Clear(value
);
459 PyDict_SetItem(modules
, key
, Py_None
);
465 /* Next, delete all modules (still skipping __builtin__ and sys) */
467 while (PyDict_Next(modules
, &pos
, &key
, &value
)) {
468 if (PyString_Check(key
) && PyModule_Check(value
)) {
469 name
= PyString_AS_STRING(key
);
470 if (strcmp(name
, "__builtin__") == 0)
472 if (strcmp(name
, "sys") == 0)
475 PySys_WriteStderr("# cleanup[2] %s\n", name
);
476 _PyModule_Clear(value
);
477 PyDict_SetItem(modules
, key
, Py_None
);
481 /* Next, delete sys and __builtin__ (in that order) */
482 value
= PyDict_GetItemString(modules
, "sys");
483 if (value
!= NULL
&& PyModule_Check(value
)) {
485 PySys_WriteStderr("# cleanup sys\n");
486 _PyModule_Clear(value
);
487 PyDict_SetItemString(modules
, "sys", Py_None
);
489 value
= PyDict_GetItemString(modules
, "__builtin__");
490 if (value
!= NULL
&& PyModule_Check(value
)) {
492 PySys_WriteStderr("# cleanup __builtin__\n");
493 _PyModule_Clear(value
);
494 PyDict_SetItemString(modules
, "__builtin__", Py_None
);
497 /* Finally, clear and delete the modules directory */
498 PyDict_Clear(modules
);
499 interp
->modules
= NULL
;
504 /* Helper for pythonrun.c -- return magic number */
507 PyImport_GetMagicNumber(void)
513 /* Magic for extension modules (built-in as well as dynamically
514 loaded). To prevent initializing an extension module more than
515 once, we keep a static dictionary 'extensions' keyed by module name
516 (for built-in modules) or by filename (for dynamically loaded
517 modules), containing these modules. A copy of the module's
518 dictionary is stored by calling _PyImport_FixupExtension()
519 immediately after the module initialization function succeeds. A
520 copy can be retrieved from there by calling
521 _PyImport_FindExtension(). */
524 _PyImport_FixupExtension(char *name
, char *filename
)
526 PyObject
*modules
, *mod
, *dict
, *copy
;
527 if (extensions
== NULL
) {
528 extensions
= PyDict_New();
529 if (extensions
== NULL
)
532 modules
= PyImport_GetModuleDict();
533 mod
= PyDict_GetItemString(modules
, name
);
534 if (mod
== NULL
|| !PyModule_Check(mod
)) {
535 PyErr_Format(PyExc_SystemError
,
536 "_PyImport_FixupExtension: module %.200s not loaded", name
);
539 dict
= PyModule_GetDict(mod
);
542 copy
= PyDict_Copy(dict
);
545 PyDict_SetItemString(extensions
, filename
, copy
);
551 _PyImport_FindExtension(char *name
, char *filename
)
553 PyObject
*dict
, *mod
, *mdict
;
554 if (extensions
== NULL
)
556 dict
= PyDict_GetItemString(extensions
, filename
);
559 mod
= PyImport_AddModule(name
);
562 mdict
= PyModule_GetDict(mod
);
565 if (PyDict_Update(mdict
, dict
))
568 PySys_WriteStderr("import %s # previously loaded (%s)\n",
574 /* Get the module object corresponding to a module name.
575 First check the modules dictionary if there's one there,
576 if not, create a new one and insert it in the modules dictionary.
577 Because the former action is most common, THIS DOES NOT RETURN A
581 PyImport_AddModule(const char *name
)
583 PyObject
*modules
= PyImport_GetModuleDict();
586 if ((m
= PyDict_GetItemString(modules
, name
)) != NULL
&&
589 m
= PyModule_New(name
);
592 if (PyDict_SetItemString(modules
, name
, m
) != 0) {
596 Py_DECREF(m
); /* Yes, it still exists, in modules! */
601 /* Remove name from sys.modules, if it's there. */
603 _RemoveModule(const char *name
)
605 PyObject
*modules
= PyImport_GetModuleDict();
606 if (PyDict_GetItemString(modules
, name
) == NULL
)
608 if (PyDict_DelItemString(modules
, name
) < 0)
609 Py_FatalError("import: deleting existing key in"
610 "sys.modules failed");
613 /* Execute a code object in a module and return the module object
614 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
615 * removed from sys.modules, to avoid leaving damaged module objects
616 * in sys.modules. The caller may wish to restore the original
617 * module object (if any) in this case; PyImport_ReloadModule is an
621 PyImport_ExecCodeModule(char *name
, PyObject
*co
)
623 return PyImport_ExecCodeModuleEx(name
, co
, (char *)NULL
);
627 PyImport_ExecCodeModuleEx(char *name
, PyObject
*co
, char *pathname
)
629 PyObject
*modules
= PyImport_GetModuleDict();
632 m
= PyImport_AddModule(name
);
635 /* If the module is being reloaded, we get the old module back
636 and re-use its dict to exec the new code. */
637 d
= PyModule_GetDict(m
);
638 if (PyDict_GetItemString(d
, "__builtins__") == NULL
) {
639 if (PyDict_SetItemString(d
, "__builtins__",
640 PyEval_GetBuiltins()) != 0)
643 /* Remember the filename as the __file__ attribute */
645 if (pathname
!= NULL
) {
646 v
= PyString_FromString(pathname
);
651 v
= ((PyCodeObject
*)co
)->co_filename
;
654 if (PyDict_SetItemString(d
, "__file__", v
) != 0)
655 PyErr_Clear(); /* Not important enough to report */
658 v
= PyEval_EvalCode((PyCodeObject
*)co
, d
, d
);
663 if ((m
= PyDict_GetItemString(modules
, name
)) == NULL
) {
664 PyErr_Format(PyExc_ImportError
,
665 "Loaded module %.200s not found in sys.modules",
680 /* Given a pathname for a Python source file, fill a buffer with the
681 pathname for the corresponding compiled file. Return the pathname
682 for the compiled file, or NULL if there's no space in the buffer.
683 Doesn't set an exception. */
686 make_compiled_pathname(char *pathname
, char *buf
, size_t buflen
)
688 size_t len
= strlen(pathname
);
693 /* Treat .pyw as if it were .py. The case of ".pyw" must match
694 that used in _PyImport_StandardFiletab. */
695 if (len
>= 4 && strcmp(&pathname
[len
-4], ".pyw") == 0)
696 --len
; /* pretend 'w' isn't there */
698 memcpy(buf
, pathname
, len
);
699 buf
[len
] = Py_OptimizeFlag
? 'o' : 'c';
706 /* Given a pathname for a Python source file, its time of last
707 modification, and a pathname for a compiled file, check whether the
708 compiled file represents the same version of the source. If so,
709 return a FILE pointer for the compiled file, positioned just after
710 the header; if not, return NULL.
711 Doesn't set an exception. */
714 check_compiled_module(char *pathname
, time_t mtime
, char *cpathname
)
720 fp
= fopen(cpathname
, "rb");
723 magic
= PyMarshal_ReadLongFromFile(fp
);
724 if (magic
!= pyc_magic
) {
726 PySys_WriteStderr("# %s has bad magic\n", cpathname
);
730 pyc_mtime
= PyMarshal_ReadLongFromFile(fp
);
731 if (pyc_mtime
!= mtime
) {
733 PySys_WriteStderr("# %s has bad mtime\n", cpathname
);
738 PySys_WriteStderr("# %s matches %s\n", cpathname
, pathname
);
743 /* Read a code object from a file and check it for validity */
745 static PyCodeObject
*
746 read_compiled_module(char *cpathname
, FILE *fp
)
750 co
= PyMarshal_ReadLastObjectFromFile(fp
);
753 if (!PyCode_Check(co
)) {
754 PyErr_Format(PyExc_ImportError
,
755 "Non-code object in %.200s", cpathname
);
759 return (PyCodeObject
*)co
;
763 /* Load a module from a compiled file, execute it, and return its
764 module object WITH INCREMENTED REFERENCE COUNT */
767 load_compiled_module(char *name
, char *cpathname
, FILE *fp
)
773 magic
= PyMarshal_ReadLongFromFile(fp
);
774 if (magic
!= pyc_magic
) {
775 PyErr_Format(PyExc_ImportError
,
776 "Bad magic number in %.200s", cpathname
);
779 (void) PyMarshal_ReadLongFromFile(fp
);
780 co
= read_compiled_module(cpathname
, fp
);
784 PySys_WriteStderr("import %s # precompiled from %s\n",
786 m
= PyImport_ExecCodeModuleEx(name
, (PyObject
*)co
, cpathname
);
792 /* Parse a source file and return the corresponding code object */
794 static PyCodeObject
*
795 parse_source_module(const char *pathname
, FILE *fp
)
797 PyCodeObject
*co
= NULL
;
799 PyArena
*arena
= PyArena_New();
803 mod
= PyParser_ASTFromFile(fp
, pathname
, Py_file_input
, 0, 0, 0,
806 co
= PyAST_Compile(mod
, pathname
, NULL
, arena
);
813 /* Helper to open a bytecode file for writing in exclusive mode */
816 open_exclusive(char *filename
)
818 #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
819 /* Use O_EXCL to avoid a race condition when another process tries to
820 write the same file. When that happens, our open() call fails,
821 which is just fine (since it's only a cache).
822 XXX If the file exists and is writable but the directory is not
823 writable, the file will never be written. Oh well.
826 (void) unlink(filename
);
827 fd
= open(filename
, O_EXCL
|O_CREAT
|O_WRONLY
|O_TRUNC
829 |O_BINARY
/* necessary for Windows */
832 , 0666, "ctxt=bin", "shr=nil"
839 return fdopen(fd
, "wb");
841 /* Best we can do -- on Windows this can't happen anyway */
842 return fopen(filename
, "wb");
847 /* Write a compiled module to a file, placing the time of last
848 modification of its source into the header.
849 Errors are ignored, if a write error occurs an attempt is made to
853 write_compiled_module(PyCodeObject
*co
, char *cpathname
, time_t mtime
)
857 fp
= open_exclusive(cpathname
);
861 "# can't create %s\n", cpathname
);
864 PyMarshal_WriteLongToFile(pyc_magic
, fp
, Py_MARSHAL_VERSION
);
865 /* First write a 0 for mtime */
866 PyMarshal_WriteLongToFile(0L, fp
, Py_MARSHAL_VERSION
);
867 PyMarshal_WriteObjectToFile((PyObject
*)co
, fp
, Py_MARSHAL_VERSION
);
868 if (fflush(fp
) != 0 || ferror(fp
)) {
870 PySys_WriteStderr("# can't write %s\n", cpathname
);
871 /* Don't keep partial file */
873 (void) unlink(cpathname
);
876 /* Now write the true mtime */
878 assert(mtime
< LONG_MAX
);
879 PyMarshal_WriteLongToFile((long)mtime
, fp
, Py_MARSHAL_VERSION
);
883 PySys_WriteStderr("# wrote %s\n", cpathname
);
887 /* Load a source module from a given file and return its module
888 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
889 byte-compiled file, use that instead. */
892 load_source_module(char *name
, char *pathname
, FILE *fp
)
896 char buf
[MAXPATHLEN
+1];
901 mtime
= PyOS_GetLastModificationTime(pathname
, fp
);
902 if (mtime
== (time_t)(-1)) {
903 PyErr_Format(PyExc_RuntimeError
,
904 "unable to get modification time from '%s'",
908 #if SIZEOF_TIME_T > 4
909 /* Python's .pyc timestamp handling presumes that the timestamp fits
910 in 4 bytes. This will be fine until sometime in the year 2038,
911 when a 4-byte signed time_t will overflow.
914 PyErr_SetString(PyExc_OverflowError
,
915 "modification time overflows a 4 byte field");
919 cpathname
= make_compiled_pathname(pathname
, buf
,
920 (size_t)MAXPATHLEN
+ 1);
921 if (cpathname
!= NULL
&&
922 (fpc
= check_compiled_module(pathname
, mtime
, cpathname
))) {
923 co
= read_compiled_module(cpathname
, fpc
);
928 PySys_WriteStderr("import %s # precompiled from %s\n",
930 pathname
= cpathname
;
933 co
= parse_source_module(pathname
, fp
);
937 PySys_WriteStderr("import %s # from %s\n",
940 write_compiled_module(co
, cpathname
, mtime
);
942 m
= PyImport_ExecCodeModuleEx(name
, (PyObject
*)co
, pathname
);
950 static PyObject
*load_module(char *, FILE *, char *, int, PyObject
*);
951 static struct filedescr
*find_module(char *, char *, PyObject
*,
952 char *, size_t, FILE **, PyObject
**);
953 static struct _frozen
*find_frozen(char *name
);
955 /* Load a package and return its module object WITH INCREMENTED
959 load_package(char *name
, char *pathname
)
962 PyObject
*file
= NULL
;
963 PyObject
*path
= NULL
;
965 char buf
[MAXPATHLEN
+1];
967 struct filedescr
*fdp
;
969 m
= PyImport_AddModule(name
);
973 PySys_WriteStderr("import %s # directory %s\n",
975 d
= PyModule_GetDict(m
);
976 file
= PyString_FromString(pathname
);
979 path
= Py_BuildValue("[O]", file
);
982 err
= PyDict_SetItemString(d
, "__file__", file
);
984 err
= PyDict_SetItemString(d
, "__path__", path
);
988 fdp
= find_module(name
, "__init__", path
, buf
, sizeof(buf
), &fp
, NULL
);
990 if (PyErr_ExceptionMatches(PyExc_ImportError
)) {
998 m
= load_module(name
, fp
, buf
, fdp
->type
, NULL
);
1012 /* Helper to test for built-in module */
1015 is_builtin(char *name
)
1018 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++) {
1019 if (strcmp(name
, PyImport_Inittab
[i
].name
) == 0) {
1020 if (PyImport_Inittab
[i
].initfunc
== NULL
)
1030 /* Return an importer object for a sys.path/pkg.__path__ item 'p',
1031 possibly by fetching it from the path_importer_cache dict. If it
1032 wasn't yet cached, traverse path_hooks until it a hook is found
1033 that can handle the path item. Return None if no hook could;
1034 this tells our caller it should fall back to the builtin
1035 import mechanism. Cache the result in path_importer_cache.
1036 Returns a borrowed reference. */
1039 get_path_importer(PyObject
*path_importer_cache
, PyObject
*path_hooks
,
1043 Py_ssize_t j
, nhooks
;
1045 /* These conditions are the caller's responsibility: */
1046 assert(PyList_Check(path_hooks
));
1047 assert(PyDict_Check(path_importer_cache
));
1049 nhooks
= PyList_Size(path_hooks
);
1051 return NULL
; /* Shouldn't happen */
1053 importer
= PyDict_GetItem(path_importer_cache
, p
);
1054 if (importer
!= NULL
)
1057 /* set path_importer_cache[p] to None to avoid recursion */
1058 if (PyDict_SetItem(path_importer_cache
, p
, Py_None
) != 0)
1061 for (j
= 0; j
< nhooks
; j
++) {
1062 PyObject
*hook
= PyList_GetItem(path_hooks
, j
);
1065 importer
= PyObject_CallFunctionObjArgs(hook
, p
, NULL
);
1066 if (importer
!= NULL
)
1069 if (!PyErr_ExceptionMatches(PyExc_ImportError
)) {
1074 if (importer
== NULL
) {
1075 importer
= PyObject_CallFunctionObjArgs(
1076 (PyObject
*)&NullImporterType
, p
, NULL
1078 if (importer
== NULL
) {
1079 if (PyErr_ExceptionMatches(PyExc_ImportError
)) {
1085 if (importer
!= NULL
) {
1086 int err
= PyDict_SetItem(path_importer_cache
, p
, importer
);
1087 Py_DECREF(importer
);
1094 /* Search the path (default sys.path) for a module. Return the
1095 corresponding filedescr struct, and (via return arguments) the
1096 pathname and an open file. Return NULL if the module is not found. */
1099 extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr
**,
1100 char *, Py_ssize_t
);
1103 static int case_ok(char *, Py_ssize_t
, Py_ssize_t
, char *);
1104 static int find_init_module(char *); /* Forward */
1105 static struct filedescr importhookdescr
= {"", "", IMP_HOOK
};
1107 static struct filedescr
*
1108 find_module(char *fullname
, char *subname
, PyObject
*path
, char *buf
,
1109 size_t buflen
, FILE **p_fp
, PyObject
**p_loader
)
1111 Py_ssize_t i
, npath
;
1112 size_t len
, namelen
;
1113 struct filedescr
*fdp
= NULL
;
1116 PyObject
*path_hooks
, *path_importer_cache
;
1118 struct stat statbuf
;
1120 static struct filedescr fd_frozen
= {"", "", PY_FROZEN
};
1121 static struct filedescr fd_builtin
= {"", "", C_BUILTIN
};
1122 static struct filedescr fd_package
= {"", "", PKG_DIRECTORY
};
1123 char name
[MAXPATHLEN
+1];
1124 #if defined(PYOS_OS2)
1126 size_t saved_namelen
;
1127 char *saved_buf
= NULL
;
1129 if (p_loader
!= NULL
)
1132 if (strlen(subname
) > MAXPATHLEN
) {
1133 PyErr_SetString(PyExc_OverflowError
,
1134 "module name is too long");
1137 strcpy(name
, subname
);
1139 /* sys.meta_path import hook */
1140 if (p_loader
!= NULL
) {
1141 PyObject
*meta_path
;
1143 meta_path
= PySys_GetObject("meta_path");
1144 if (meta_path
== NULL
|| !PyList_Check(meta_path
)) {
1145 PyErr_SetString(PyExc_ImportError
,
1146 "sys.meta_path must be a list of "
1150 Py_INCREF(meta_path
); /* zap guard */
1151 npath
= PyList_Size(meta_path
);
1152 for (i
= 0; i
< npath
; i
++) {
1154 PyObject
*hook
= PyList_GetItem(meta_path
, i
);
1155 loader
= PyObject_CallMethod(hook
, "find_module",
1159 if (loader
== NULL
) {
1160 Py_DECREF(meta_path
);
1161 return NULL
; /* true error */
1163 if (loader
!= Py_None
) {
1164 /* a loader was found */
1166 Py_DECREF(meta_path
);
1167 return &importhookdescr
;
1171 Py_DECREF(meta_path
);
1174 if (path
!= NULL
&& PyString_Check(path
)) {
1175 /* The only type of submodule allowed inside a "frozen"
1176 package are other frozen modules or packages. */
1177 if (PyString_Size(path
) + 1 + strlen(name
) >= (size_t)buflen
) {
1178 PyErr_SetString(PyExc_ImportError
,
1179 "full frozen module name too long");
1182 strcpy(buf
, PyString_AsString(path
));
1186 if (find_frozen(name
) != NULL
) {
1190 PyErr_Format(PyExc_ImportError
,
1191 "No frozen submodule named %.200s", name
);
1195 if (is_builtin(name
)) {
1199 if ((find_frozen(name
)) != NULL
) {
1205 fp
= PyWin_FindRegisteredModule(name
, &fdp
, buf
, buflen
);
1211 path
= PySys_GetObject("path");
1213 if (path
== NULL
|| !PyList_Check(path
)) {
1214 PyErr_SetString(PyExc_ImportError
,
1215 "sys.path must be a list of directory names");
1219 path_hooks
= PySys_GetObject("path_hooks");
1220 if (path_hooks
== NULL
|| !PyList_Check(path_hooks
)) {
1221 PyErr_SetString(PyExc_ImportError
,
1222 "sys.path_hooks must be a list of "
1226 path_importer_cache
= PySys_GetObject("path_importer_cache");
1227 if (path_importer_cache
== NULL
||
1228 !PyDict_Check(path_importer_cache
)) {
1229 PyErr_SetString(PyExc_ImportError
,
1230 "sys.path_importer_cache must be a dict");
1234 npath
= PyList_Size(path
);
1235 namelen
= strlen(name
);
1236 for (i
= 0; i
< npath
; i
++) {
1237 PyObject
*copy
= NULL
;
1238 PyObject
*v
= PyList_GetItem(path
, i
);
1241 #ifdef Py_USING_UNICODE
1242 if (PyUnicode_Check(v
)) {
1243 copy
= PyUnicode_Encode(PyUnicode_AS_UNICODE(v
),
1244 PyUnicode_GET_SIZE(v
), Py_FileSystemDefaultEncoding
, NULL
);
1251 if (!PyString_Check(v
))
1253 len
= PyString_GET_SIZE(v
);
1254 if (len
+ 2 + namelen
+ MAXSUFFIXSIZE
>= buflen
) {
1256 continue; /* Too long */
1258 strcpy(buf
, PyString_AS_STRING(v
));
1259 if (strlen(buf
) != len
) {
1261 continue; /* v contains '\0' */
1264 /* sys.path_hooks import hook */
1265 if (p_loader
!= NULL
) {
1268 importer
= get_path_importer(path_importer_cache
,
1270 if (importer
== NULL
) {
1274 /* Note: importer is a borrowed reference */
1275 if (importer
!= Py_None
) {
1277 loader
= PyObject_CallMethod(importer
,
1282 return NULL
; /* error */
1283 if (loader
!= Py_None
) {
1284 /* a loader was found */
1286 return &importhookdescr
;
1292 /* no hook was found, use builtin import */
1294 if (len
> 0 && buf
[len
-1] != SEP
1296 && buf
[len
-1] != ALTSEP
1300 strcpy(buf
+len
, name
);
1303 /* Check for package import (buf holds a directory name,
1304 and there's an __init__ module in that directory */
1306 if (stat(buf
, &statbuf
) == 0 && /* it exists */
1307 S_ISDIR(statbuf
.st_mode
) && /* it's a directory */
1308 case_ok(buf
, len
, namelen
, name
)) { /* case matches */
1309 if (find_init_module(buf
)) { /* and has __init__.py */
1314 char warnstr
[MAXPATHLEN
+80];
1315 sprintf(warnstr
, "Not importing directory "
1316 "'%.*s': missing __init__.py",
1318 if (PyErr_Warn(PyExc_ImportWarning
,
1326 /* XXX How are you going to test for directories? */
1329 case_ok(buf
, len
, namelen
, name
)) {
1330 if (find_init_module(buf
)) {
1335 char warnstr
[MAXPATHLEN
+80];
1336 sprintf(warnstr
, "Not importing directory "
1337 "'%.*s': missing __init__.py",
1339 if (PyErr_Warn(PyExc_ImportWarning
,
1347 #if defined(PYOS_OS2)
1348 /* take a snapshot of the module spec for restoration
1349 * after the 8 character DLL hackery
1351 saved_buf
= strdup(buf
);
1353 saved_namelen
= namelen
;
1354 #endif /* PYOS_OS2 */
1355 for (fdp
= _PyImport_Filetab
; fdp
->suffix
!= NULL
; fdp
++) {
1356 #if defined(PYOS_OS2)
1357 /* OS/2 limits DLLs to 8 character names (w/o
1359 * so if the name is longer than that and its a
1360 * dynamically loaded module we're going to try,
1361 * truncate the name before trying
1363 if (strlen(subname
) > 8) {
1364 /* is this an attempt to load a C extension? */
1365 const struct filedescr
*scan
;
1366 scan
= _PyImport_DynLoadFiletab
;
1367 while (scan
->suffix
!= NULL
) {
1368 if (!strcmp(scan
->suffix
, fdp
->suffix
))
1373 if (scan
->suffix
!= NULL
) {
1374 /* yes, so truncate the name */
1376 len
-= strlen(subname
) - namelen
;
1380 #endif /* PYOS_OS2 */
1381 strcpy(buf
+len
, fdp
->suffix
);
1382 if (Py_VerboseFlag
> 1)
1383 PySys_WriteStderr("# trying %s\n", buf
);
1384 filemode
= fdp
->mode
;
1385 if (filemode
[0] == 'U')
1386 filemode
= "r" PY_STDIOTEXTMODE
;
1387 fp
= fopen(buf
, filemode
);
1389 if (case_ok(buf
, len
, namelen
, name
))
1391 else { /* continue search */
1396 #if defined(PYOS_OS2)
1397 /* restore the saved snapshot */
1398 strcpy(buf
, saved_buf
);
1400 namelen
= saved_namelen
;
1403 #if defined(PYOS_OS2)
1404 /* don't need/want the module name snapshot anymore */
1416 PyErr_Format(PyExc_ImportError
,
1417 "No module named %.200s", name
);
1424 /* Helpers for main.c
1425 * Find the source file corresponding to a named module
1428 _PyImport_FindModule(const char *name
, PyObject
*path
, char *buf
,
1429 size_t buflen
, FILE **p_fp
, PyObject
**p_loader
)
1431 return find_module((char *) name
, (char *) name
, path
,
1432 buf
, buflen
, p_fp
, p_loader
);
1435 PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr
* fd
)
1437 return fd
->type
== PY_SOURCE
|| fd
->type
== PY_COMPILED
;
1440 /* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
1441 * The arguments here are tricky, best shown by example:
1442 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1444 * |--------------------- buf ---------------------|
1445 * |------------------- len ------------------|
1446 * |------ name -------|
1447 * |----- namelen -----|
1448 * buf is the full path, but len only counts up to (& exclusive of) the
1449 * extension. name is the module name, also exclusive of extension.
1451 * We've already done a successful stat() or fopen() on buf, so know that
1452 * there's some match, possibly case-insensitive.
1454 * case_ok() is to return 1 if there's a case-sensitive match for
1455 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1458 * case_ok() is used to implement case-sensitive import semantics even
1459 * on platforms with case-insensitive filesystems. It's trivial to implement
1460 * for case-sensitive filesystems. It's pretty much a cross-platform
1461 * nightmare for systems with case-insensitive filesystems.
1464 /* First we may need a pile of platform-specific header files; the sequence
1465 * of #if's here should match the sequence in the body of case_ok().
1467 #if defined(MS_WINDOWS)
1468 #include <windows.h>
1470 #elif defined(DJGPP)
1473 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1474 #include <sys/types.h>
1477 #elif defined(PYOS_OS2)
1479 #define INCL_DOSERRORS
1480 #define INCL_NOPMAPI
1483 #elif defined(RISCOS)
1484 #include "oslib/osfscontrol.h"
1488 case_ok(char *buf
, Py_ssize_t len
, Py_ssize_t namelen
, char *name
)
1490 /* Pick a platform-specific implementation; the sequence of #if's here should
1491 * match the sequence just above.
1495 #if defined(MS_WINDOWS)
1496 WIN32_FIND_DATA data
;
1499 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1502 h
= FindFirstFile(buf
, &data
);
1503 if (h
== INVALID_HANDLE_VALUE
) {
1504 PyErr_Format(PyExc_NameError
,
1505 "Can't find file for module %.100s\n(filename %.300s)",
1510 return strncmp(data
.cFileName
, name
, namelen
) == 0;
1513 #elif defined(DJGPP)
1517 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1520 done
= findfirst(buf
, &ffblk
, FA_ARCH
|FA_RDONLY
|FA_HIDDEN
|FA_DIREC
);
1522 PyErr_Format(PyExc_NameError
,
1523 "Can't find file for module %.100s\n(filename %.300s)",
1527 return strncmp(ffblk
.ff_name
, name
, namelen
) == 0;
1529 /* new-fangled macintosh (macosx) or Cygwin */
1530 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1533 char dirname
[MAXPATHLEN
+ 1];
1534 const int dirlen
= len
- namelen
- 1; /* don't want trailing SEP */
1536 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1539 /* Copy the dir component into dirname; substitute "." if empty */
1545 assert(dirlen
<= MAXPATHLEN
);
1546 memcpy(dirname
, buf
, dirlen
);
1547 dirname
[dirlen
] = '\0';
1549 /* Open the directory and search the entries for an exact match. */
1550 dirp
= opendir(dirname
);
1552 char *nameWithExt
= buf
+ len
- namelen
;
1553 while ((dp
= readdir(dirp
)) != NULL
) {
1555 #ifdef _DIRENT_HAVE_D_NAMELEN
1560 if (thislen
>= namelen
&&
1561 strcmp(dp
->d_name
, nameWithExt
) == 0) {
1562 (void)closedir(dirp
);
1563 return 1; /* Found */
1566 (void)closedir(dirp
);
1568 return 0 ; /* Not found */
1571 #elif defined(RISCOS)
1572 char canon
[MAXPATHLEN
+1]; /* buffer for the canonical form of the path */
1573 char buf2
[MAXPATHLEN
+2];
1574 char *nameWithExt
= buf
+len
-namelen
;
1578 if (Py_GETENV("PYTHONCASEOK") != NULL
)
1582 append wildcard, otherwise case of filename wouldn't be touched */
1586 e
= xosfscontrol_canonicalise_path(buf2
,canon
,0,0,MAXPATHLEN
+1,&canonlen
);
1587 canonlen
= MAXPATHLEN
+1-canonlen
;
1588 if (e
|| canonlen
<=0 || canonlen
>(MAXPATHLEN
+1) )
1590 if (strcmp(nameWithExt
, canon
+canonlen
-strlen(nameWithExt
))==0)
1591 return 1; /* match */
1596 #elif defined(PYOS_OS2)
1602 if (getenv("PYTHONCASEOK") != NULL
)
1605 rc
= DosFindFirst(buf
,
1607 FILE_READONLY
| FILE_HIDDEN
| FILE_SYSTEM
| FILE_DIRECTORY
,
1608 &ffbuf
, sizeof(ffbuf
),
1613 return strncmp(ffbuf
.achName
, name
, namelen
) == 0;
1615 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1624 /* Helper to look for __init__.py or __init__.py[co] in potential package */
1626 find_init_module(char *buf
)
1628 const size_t save_len
= strlen(buf
);
1629 size_t i
= save_len
;
1630 char *pname
; /* pointer to start of __init__ */
1631 struct stat statbuf
;
1633 /* For calling case_ok(buf, len, namelen, name):
1634 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1636 * |--------------------- buf ---------------------|
1637 * |------------------- len ------------------|
1638 * |------ name -------|
1639 * |----- namelen -----|
1641 if (save_len
+ 13 >= MAXPATHLEN
)
1645 strcpy(pname
, "__init__.py");
1646 if (stat(buf
, &statbuf
) == 0) {
1648 save_len
+ 9, /* len("/__init__") */
1649 8, /* len("__init__") */
1651 buf
[save_len
] = '\0';
1656 strcpy(buf
+i
, Py_OptimizeFlag
? "o" : "c");
1657 if (stat(buf
, &statbuf
) == 0) {
1659 save_len
+ 9, /* len("/__init__") */
1660 8, /* len("__init__") */
1662 buf
[save_len
] = '\0';
1666 buf
[save_len
] = '\0';
1674 find_init_module(buf
)
1677 int save_len
= strlen(buf
);
1680 if (save_len
+ 13 >= MAXPATHLEN
)
1683 strcpy(buf
+i
, "__init__/py");
1685 buf
[save_len
] = '\0';
1689 if (Py_OptimizeFlag
)
1694 buf
[save_len
] = '\0';
1697 buf
[save_len
] = '\0';
1702 #endif /* HAVE_STAT */
1705 static int init_builtin(char *); /* Forward */
1707 /* Load an external module using the default search path and return
1708 its module object WITH INCREMENTED REFERENCE COUNT */
1711 load_module(char *name
, FILE *fp
, char *buf
, int type
, PyObject
*loader
)
1717 /* First check that there's an open file (if we need one) */
1722 PyErr_Format(PyExc_ValueError
,
1723 "file object required for import (type code %d)",
1732 m
= load_source_module(name
, buf
, fp
);
1736 m
= load_compiled_module(name
, buf
, fp
);
1739 #ifdef HAVE_DYNAMIC_LOADING
1741 m
= _PyImport_LoadDynamicModule(name
, buf
, fp
);
1746 m
= load_package(name
, buf
);
1751 if (buf
!= NULL
&& buf
[0] != '\0')
1753 if (type
== C_BUILTIN
)
1754 err
= init_builtin(name
);
1756 err
= PyImport_ImportFrozenModule(name
);
1760 PyErr_Format(PyExc_ImportError
,
1761 "Purported %s module %.200s not found",
1763 "builtin" : "frozen",
1767 modules
= PyImport_GetModuleDict();
1768 m
= PyDict_GetItemString(modules
, name
);
1772 "%s module %.200s not properly initialized",
1774 "builtin" : "frozen",
1782 if (loader
== NULL
) {
1783 PyErr_SetString(PyExc_ImportError
,
1784 "import hook without loader");
1787 m
= PyObject_CallMethod(loader
, "load_module", "s", name
);
1792 PyErr_Format(PyExc_ImportError
,
1793 "Don't know how to import %.200s (type code %d)",
1803 /* Initialize a built-in module.
1804 Return 1 for succes, 0 if the module is not found, and -1 with
1805 an exception set if the initialization failed. */
1808 init_builtin(char *name
)
1812 if (_PyImport_FindExtension(name
, name
) != NULL
)
1815 for (p
= PyImport_Inittab
; p
->name
!= NULL
; p
++) {
1816 if (strcmp(name
, p
->name
) == 0) {
1817 if (p
->initfunc
== NULL
) {
1818 PyErr_Format(PyExc_ImportError
,
1819 "Cannot re-init internal module %.200s",
1824 PySys_WriteStderr("import %s # builtin\n", name
);
1826 if (PyErr_Occurred())
1828 if (_PyImport_FixupExtension(name
, name
) == NULL
)
1837 /* Frozen modules */
1839 static struct _frozen
*
1840 find_frozen(char *name
)
1844 for (p
= PyImport_FrozenModules
; ; p
++) {
1845 if (p
->name
== NULL
)
1847 if (strcmp(p
->name
, name
) == 0)
1854 get_frozen_object(char *name
)
1856 struct _frozen
*p
= find_frozen(name
);
1860 PyErr_Format(PyExc_ImportError
,
1861 "No such frozen object named %.200s",
1865 if (p
->code
== NULL
) {
1866 PyErr_Format(PyExc_ImportError
,
1867 "Excluded frozen object named %.200s",
1874 return PyMarshal_ReadObjectFromString((char *)p
->code
, size
);
1877 /* Initialize a frozen module.
1878 Return 1 for succes, 0 if the module is not found, and -1 with
1879 an exception set if the initialization failed.
1880 This function is also used from frozenmain.c */
1883 PyImport_ImportFrozenModule(char *name
)
1885 struct _frozen
*p
= find_frozen(name
);
1893 if (p
->code
== NULL
) {
1894 PyErr_Format(PyExc_ImportError
,
1895 "Excluded frozen object named %.200s",
1900 ispackage
= (size
< 0);
1904 PySys_WriteStderr("import %s # frozen%s\n",
1905 name
, ispackage
? " package" : "");
1906 co
= PyMarshal_ReadObjectFromString((char *)p
->code
, size
);
1909 if (!PyCode_Check(co
)) {
1910 PyErr_Format(PyExc_TypeError
,
1911 "frozen object %.200s is not a code object",
1916 /* Set __path__ to the package name */
1919 m
= PyImport_AddModule(name
);
1922 d
= PyModule_GetDict(m
);
1923 s
= PyString_InternFromString(name
);
1926 err
= PyDict_SetItemString(d
, "__path__", s
);
1931 m
= PyImport_ExecCodeModuleEx(name
, co
, "<frozen>");
1943 /* Import a module, either built-in, frozen, or external, and return
1944 its module object WITH INCREMENTED REFERENCE COUNT */
1947 PyImport_ImportModule(const char *name
)
1952 pname
= PyString_FromString(name
);
1955 result
= PyImport_Import(pname
);
1960 /* Forward declarations for helper routines */
1961 static PyObject
*get_parent(PyObject
*globals
, char *buf
,
1962 Py_ssize_t
*p_buflen
, int level
);
1963 static PyObject
*load_next(PyObject
*mod
, PyObject
*altmod
,
1964 char **p_name
, char *buf
, Py_ssize_t
*p_buflen
);
1965 static int mark_miss(char *name
);
1966 static int ensure_fromlist(PyObject
*mod
, PyObject
*fromlist
,
1967 char *buf
, Py_ssize_t buflen
, int recursive
);
1968 static PyObject
* import_submodule(PyObject
*mod
, char *name
, char *fullname
);
1970 /* The Magnum Opus of dotted-name import :-) */
1973 import_module_level(char *name
, PyObject
*globals
, PyObject
*locals
,
1974 PyObject
*fromlist
, int level
)
1976 char buf
[MAXPATHLEN
+1];
1977 Py_ssize_t buflen
= 0;
1978 PyObject
*parent
, *head
, *next
, *tail
;
1980 parent
= get_parent(globals
, buf
, &buflen
, level
);
1984 head
= load_next(parent
, Py_None
, &name
, buf
, &buflen
);
1991 next
= load_next(tail
, tail
, &name
, buf
, &buflen
);
1999 if (tail
== Py_None
) {
2000 /* If tail is Py_None, both get_parent and load_next found
2001 an empty module name: someone called __import__("") or
2002 doctored faulty bytecode */
2005 PyErr_SetString(PyExc_ValueError
,
2006 "Empty module name");
2010 if (fromlist
!= NULL
) {
2011 if (fromlist
== Py_None
|| !PyObject_IsTrue(fromlist
))
2015 if (fromlist
== NULL
) {
2021 if (!ensure_fromlist(tail
, fromlist
, buf
, buflen
, 0)) {
2029 /* For DLL compatibility */
2030 #undef PyImport_ImportModuleEx
2032 PyImport_ImportModuleEx(char *name
, PyObject
*globals
, PyObject
*locals
,
2037 result
= import_module_level(name
, globals
, locals
, fromlist
, -1);
2038 if (unlock_import() < 0) {
2040 PyErr_SetString(PyExc_RuntimeError
,
2041 "not holding the import lock");
2046 #define PyImport_ImportModuleEx(n, g, l, f) \
2047 PyImport_ImportModuleLevel(n, g, l, f, -1);
2050 PyImport_ImportModuleLevel(char *name
, PyObject
*globals
, PyObject
*locals
,
2051 PyObject
*fromlist
, int level
)
2055 result
= import_module_level(name
, globals
, locals
, fromlist
, level
);
2056 if (unlock_import() < 0) {
2058 PyErr_SetString(PyExc_RuntimeError
,
2059 "not holding the import lock");
2065 /* Return the package that an import is being performed in. If globals comes
2066 from the module foo.bar.bat (not itself a package), this returns the
2067 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2068 the package's entry in sys.modules is returned, as a borrowed reference.
2070 The *name* of the returned package is returned in buf, with the length of
2071 the name in *p_buflen.
2073 If globals doesn't come from a package or a module in a package, or a
2074 corresponding entry is not found in sys.modules, Py_None is returned.
2077 get_parent(PyObject
*globals
, char *buf
, Py_ssize_t
*p_buflen
, int level
)
2079 static PyObject
*namestr
= NULL
;
2080 static PyObject
*pathstr
= NULL
;
2081 PyObject
*modname
, *modpath
, *modules
, *parent
;
2083 if (globals
== NULL
|| !PyDict_Check(globals
) || !level
)
2086 if (namestr
== NULL
) {
2087 namestr
= PyString_InternFromString("__name__");
2088 if (namestr
== NULL
)
2091 if (pathstr
== NULL
) {
2092 pathstr
= PyString_InternFromString("__path__");
2093 if (pathstr
== NULL
)
2099 modname
= PyDict_GetItem(globals
, namestr
);
2100 if (modname
== NULL
|| !PyString_Check(modname
))
2103 modpath
= PyDict_GetItem(globals
, pathstr
);
2104 if (modpath
!= NULL
) {
2105 Py_ssize_t len
= PyString_GET_SIZE(modname
);
2106 if (len
> MAXPATHLEN
) {
2107 PyErr_SetString(PyExc_ValueError
,
2108 "Module name too long");
2111 strcpy(buf
, PyString_AS_STRING(modname
));
2114 char *start
= PyString_AS_STRING(modname
);
2115 char *lastdot
= strrchr(start
, '.');
2117 if (lastdot
== NULL
&& level
> 0) {
2118 PyErr_SetString(PyExc_ValueError
,
2119 "Attempted relative import in non-package");
2122 if (lastdot
== NULL
)
2124 len
= lastdot
- start
;
2125 if (len
>= MAXPATHLEN
) {
2126 PyErr_SetString(PyExc_ValueError
,
2127 "Module name too long");
2130 strncpy(buf
, start
, len
);
2134 while (--level
> 0) {
2135 char *dot
= strrchr(buf
, '.');
2137 PyErr_SetString(PyExc_ValueError
,
2138 "Attempted relative import beyond "
2139 "toplevel package");
2144 *p_buflen
= strlen(buf
);
2146 modules
= PyImport_GetModuleDict();
2147 parent
= PyDict_GetItemString(modules
, buf
);
2149 PyErr_Format(PyExc_SystemError
,
2150 "Parent module '%.200s' not loaded", buf
);
2152 /* We expect, but can't guarantee, if parent != None, that:
2153 - parent.__name__ == buf
2154 - parent.__dict__ is globals
2155 If this is violated... Who cares? */
2158 /* altmod is either None or same as mod */
2160 load_next(PyObject
*mod
, PyObject
*altmod
, char **p_name
, char *buf
,
2161 Py_ssize_t
*p_buflen
)
2163 char *name
= *p_name
;
2164 char *dot
= strchr(name
, '.');
2169 if (strlen(name
) == 0) {
2170 /* completely empty module name should only happen in
2171 'from . import' (or '__import__("")')*/
2186 PyErr_SetString(PyExc_ValueError
,
2187 "Empty module name");
2191 p
= buf
+ *p_buflen
;
2194 if (p
+len
-buf
>= MAXPATHLEN
) {
2195 PyErr_SetString(PyExc_ValueError
,
2196 "Module name too long");
2199 strncpy(p
, name
, len
);
2201 *p_buflen
= p
+len
-buf
;
2203 result
= import_submodule(mod
, p
, buf
);
2204 if (result
== Py_None
&& altmod
!= mod
) {
2206 /* Here, altmod must be None and mod must not be None */
2207 result
= import_submodule(altmod
, p
, p
);
2208 if (result
!= NULL
&& result
!= Py_None
) {
2209 if (mark_miss(buf
) != 0) {
2213 strncpy(buf
, name
, len
);
2221 if (result
== Py_None
) {
2223 PyErr_Format(PyExc_ImportError
,
2224 "No module named %.200s", name
);
2232 mark_miss(char *name
)
2234 PyObject
*modules
= PyImport_GetModuleDict();
2235 return PyDict_SetItemString(modules
, name
, Py_None
);
2239 ensure_fromlist(PyObject
*mod
, PyObject
*fromlist
, char *buf
, Py_ssize_t buflen
,
2244 if (!PyObject_HasAttrString(mod
, "__path__"))
2247 for (i
= 0; ; i
++) {
2248 PyObject
*item
= PySequence_GetItem(fromlist
, i
);
2251 if (PyErr_ExceptionMatches(PyExc_IndexError
)) {
2257 if (!PyString_Check(item
)) {
2258 PyErr_SetString(PyExc_TypeError
,
2259 "Item in ``from list'' not a string");
2263 if (PyString_AS_STRING(item
)[0] == '*') {
2266 /* See if the package defines __all__ */
2268 continue; /* Avoid endless recursion */
2269 all
= PyObject_GetAttrString(mod
, "__all__");
2273 int ret
= ensure_fromlist(mod
, all
, buf
, buflen
, 1);
2280 hasit
= PyObject_HasAttr(mod
, item
);
2282 char *subname
= PyString_AS_STRING(item
);
2285 if (buflen
+ strlen(subname
) >= MAXPATHLEN
) {
2286 PyErr_SetString(PyExc_ValueError
,
2287 "Module name too long");
2294 submod
= import_submodule(mod
, subname
, buf
);
2296 if (submod
== NULL
) {
2308 add_submodule(PyObject
*mod
, PyObject
*submod
, char *fullname
, char *subname
,
2313 /* Irrespective of the success of this load, make a
2314 reference to it in the parent package module. A copy gets
2315 saved in the modules dictionary under the full name, so get a
2316 reference from there, if need be. (The exception is when the
2317 load failed with a SyntaxError -- then there's no trace in
2318 sys.modules. In that case, of course, do nothing extra.) */
2319 if (submod
== NULL
) {
2320 submod
= PyDict_GetItemString(modules
, fullname
);
2324 if (PyModule_Check(mod
)) {
2325 /* We can't use setattr here since it can give a
2326 * spurious warning if the submodule name shadows a
2328 PyObject
*dict
= PyModule_GetDict(mod
);
2331 if (PyDict_SetItemString(dict
, subname
, submod
) < 0)
2335 if (PyObject_SetAttrString(mod
, subname
, submod
) < 0)
2342 import_submodule(PyObject
*mod
, char *subname
, char *fullname
)
2344 PyObject
*modules
= PyImport_GetModuleDict();
2348 if mod == None: subname == fullname
2349 else: mod.__name__ + "." + subname == fullname
2352 if ((m
= PyDict_GetItemString(modules
, fullname
)) != NULL
) {
2356 PyObject
*path
, *loader
= NULL
;
2357 char buf
[MAXPATHLEN
+1];
2358 struct filedescr
*fdp
;
2364 path
= PyObject_GetAttrString(mod
, "__path__");
2373 fdp
= find_module(fullname
, subname
, path
, buf
, MAXPATHLEN
+1,
2377 if (!PyErr_ExceptionMatches(PyExc_ImportError
))
2383 m
= load_module(fullname
, fp
, buf
, fdp
->type
, loader
);
2387 if (!add_submodule(mod
, m
, fullname
, subname
, modules
)) {
2397 /* Re-import a module of any kind and return its module object, WITH
2398 INCREMENTED REFERENCE COUNT */
2401 PyImport_ReloadModule(PyObject
*m
)
2403 PyObject
*modules
= PyImport_GetModuleDict();
2404 PyObject
*path
= NULL
, *loader
= NULL
;
2405 char *name
, *subname
;
2406 char buf
[MAXPATHLEN
+1];
2407 struct filedescr
*fdp
;
2411 if (m
== NULL
|| !PyModule_Check(m
)) {
2412 PyErr_SetString(PyExc_TypeError
,
2413 "reload() argument must be module");
2416 name
= PyModule_GetName(m
);
2419 if (m
!= PyDict_GetItemString(modules
, name
)) {
2420 PyErr_Format(PyExc_ImportError
,
2421 "reload(): module %.200s not in sys.modules",
2425 subname
= strrchr(name
, '.');
2426 if (subname
== NULL
)
2429 PyObject
*parentname
, *parent
;
2430 parentname
= PyString_FromStringAndSize(name
, (subname
-name
));
2431 if (parentname
== NULL
)
2433 parent
= PyDict_GetItem(modules
, parentname
);
2434 if (parent
== NULL
) {
2435 PyErr_Format(PyExc_ImportError
,
2436 "reload(): parent %.200s not in sys.modules",
2437 PyString_AS_STRING(parentname
));
2438 Py_DECREF(parentname
);
2441 Py_DECREF(parentname
);
2443 path
= PyObject_GetAttrString(parent
, "__path__");
2448 fdp
= find_module(name
, subname
, path
, buf
, MAXPATHLEN
+1, &fp
, &loader
);
2456 newm
= load_module(name
, fp
, buf
, fdp
->type
, loader
);
2462 /* load_module probably removed name from modules because of
2463 * the error. Put back the original module object. We're
2464 * going to return NULL in this case regardless of whether
2465 * replacing name succeeds, so the return value is ignored.
2467 PyDict_SetItemString(modules
, name
, m
);
2473 /* Higher-level import emulator which emulates the "import" statement
2474 more accurately -- it invokes the __import__() function from the
2475 builtins of the current globals. This means that the import is
2476 done using whatever import hooks are installed in the current
2477 environment, e.g. by "rexec".
2478 A dummy list ["__doc__"] is passed as the 4th argument so that
2479 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2480 will return <module "gencache"> instead of <module "win32com">. */
2483 PyImport_Import(PyObject
*module_name
)
2485 static PyObject
*silly_list
= NULL
;
2486 static PyObject
*builtins_str
= NULL
;
2487 static PyObject
*import_str
= NULL
;
2488 PyObject
*globals
= NULL
;
2489 PyObject
*import
= NULL
;
2490 PyObject
*builtins
= NULL
;
2493 /* Initialize constant string objects */
2494 if (silly_list
== NULL
) {
2495 import_str
= PyString_InternFromString("__import__");
2496 if (import_str
== NULL
)
2498 builtins_str
= PyString_InternFromString("__builtins__");
2499 if (builtins_str
== NULL
)
2501 silly_list
= Py_BuildValue("[s]", "__doc__");
2502 if (silly_list
== NULL
)
2506 /* Get the builtins from current globals */
2507 globals
= PyEval_GetGlobals();
2508 if (globals
!= NULL
) {
2510 builtins
= PyObject_GetItem(globals
, builtins_str
);
2511 if (builtins
== NULL
)
2515 /* No globals -- use standard builtins, and fake globals */
2518 builtins
= PyImport_ImportModuleLevel("__builtin__",
2519 NULL
, NULL
, NULL
, 0);
2520 if (builtins
== NULL
)
2522 globals
= Py_BuildValue("{OO}", builtins_str
, builtins
);
2523 if (globals
== NULL
)
2527 /* Get the __import__ function from the builtins */
2528 if (PyDict_Check(builtins
)) {
2529 import
= PyObject_GetItem(builtins
, import_str
);
2531 PyErr_SetObject(PyExc_KeyError
, import_str
);
2534 import
= PyObject_GetAttr(builtins
, import_str
);
2538 /* Call the _import__ function with the proper argument list */
2539 r
= PyObject_CallFunctionObjArgs(import
, module_name
, globals
,
2540 globals
, silly_list
, NULL
);
2543 Py_XDECREF(globals
);
2544 Py_XDECREF(builtins
);
2551 /* Module 'imp' provides Python access to the primitives used for
2556 imp_get_magic(PyObject
*self
, PyObject
*noargs
)
2560 buf
[0] = (char) ((pyc_magic
>> 0) & 0xff);
2561 buf
[1] = (char) ((pyc_magic
>> 8) & 0xff);
2562 buf
[2] = (char) ((pyc_magic
>> 16) & 0xff);
2563 buf
[3] = (char) ((pyc_magic
>> 24) & 0xff);
2565 return PyString_FromStringAndSize(buf
, 4);
2569 imp_get_suffixes(PyObject
*self
, PyObject
*noargs
)
2572 struct filedescr
*fdp
;
2574 list
= PyList_New(0);
2577 for (fdp
= _PyImport_Filetab
; fdp
->suffix
!= NULL
; fdp
++) {
2578 PyObject
*item
= Py_BuildValue("ssi",
2579 fdp
->suffix
, fdp
->mode
, fdp
->type
);
2584 if (PyList_Append(list
, item
) < 0) {
2595 call_find_module(char *name
, PyObject
*path
)
2597 extern int fclose(FILE *);
2598 PyObject
*fob
, *ret
;
2599 struct filedescr
*fdp
;
2600 char pathname
[MAXPATHLEN
+1];
2604 if (path
== Py_None
)
2606 fdp
= find_module(NULL
, name
, path
, pathname
, MAXPATHLEN
+1, &fp
, NULL
);
2610 fob
= PyFile_FromFile(fp
, pathname
, fdp
->mode
, fclose
);
2620 ret
= Py_BuildValue("Os(ssi)",
2621 fob
, pathname
, fdp
->suffix
, fdp
->mode
, fdp
->type
);
2627 imp_find_module(PyObject
*self
, PyObject
*args
)
2630 PyObject
*path
= NULL
;
2631 if (!PyArg_ParseTuple(args
, "s|O:find_module", &name
, &path
))
2633 return call_find_module(name
, path
);
2637 imp_init_builtin(PyObject
*self
, PyObject
*args
)
2642 if (!PyArg_ParseTuple(args
, "s:init_builtin", &name
))
2644 ret
= init_builtin(name
);
2651 m
= PyImport_AddModule(name
);
2657 imp_init_frozen(PyObject
*self
, PyObject
*args
)
2662 if (!PyArg_ParseTuple(args
, "s:init_frozen", &name
))
2664 ret
= PyImport_ImportFrozenModule(name
);
2671 m
= PyImport_AddModule(name
);
2677 imp_get_frozen_object(PyObject
*self
, PyObject
*args
)
2681 if (!PyArg_ParseTuple(args
, "s:get_frozen_object", &name
))
2683 return get_frozen_object(name
);
2687 imp_is_builtin(PyObject
*self
, PyObject
*args
)
2690 if (!PyArg_ParseTuple(args
, "s:is_builtin", &name
))
2692 return PyInt_FromLong(is_builtin(name
));
2696 imp_is_frozen(PyObject
*self
, PyObject
*args
)
2700 if (!PyArg_ParseTuple(args
, "s:is_frozen", &name
))
2702 p
= find_frozen(name
);
2703 return PyBool_FromLong((long) (p
== NULL
? 0 : p
->size
));
2707 get_file(char *pathname
, PyObject
*fob
, char *mode
)
2712 mode
= "r" PY_STDIOTEXTMODE
;
2713 fp
= fopen(pathname
, mode
);
2715 PyErr_SetFromErrno(PyExc_IOError
);
2718 fp
= PyFile_AsFile(fob
);
2720 PyErr_SetString(PyExc_ValueError
,
2721 "bad/closed file object");
2727 imp_load_compiled(PyObject
*self
, PyObject
*args
)
2731 PyObject
*fob
= NULL
;
2734 if (!PyArg_ParseTuple(args
, "ss|O!:load_compiled", &name
, &pathname
,
2735 &PyFile_Type
, &fob
))
2737 fp
= get_file(pathname
, fob
, "rb");
2740 m
= load_compiled_module(name
, pathname
, fp
);
2746 #ifdef HAVE_DYNAMIC_LOADING
2749 imp_load_dynamic(PyObject
*self
, PyObject
*args
)
2753 PyObject
*fob
= NULL
;
2756 if (!PyArg_ParseTuple(args
, "ss|O!:load_dynamic", &name
, &pathname
,
2757 &PyFile_Type
, &fob
))
2760 fp
= get_file(pathname
, fob
, "r");
2764 m
= _PyImport_LoadDynamicModule(name
, pathname
, fp
);
2768 #endif /* HAVE_DYNAMIC_LOADING */
2771 imp_load_source(PyObject
*self
, PyObject
*args
)
2775 PyObject
*fob
= NULL
;
2778 if (!PyArg_ParseTuple(args
, "ss|O!:load_source", &name
, &pathname
,
2779 &PyFile_Type
, &fob
))
2781 fp
= get_file(pathname
, fob
, "r");
2784 m
= load_source_module(name
, pathname
, fp
);
2791 imp_load_module(PyObject
*self
, PyObject
*args
)
2796 char *suffix
; /* Unused */
2801 if (!PyArg_ParseTuple(args
, "sOs(ssi):load_module",
2802 &name
, &fob
, &pathname
,
2803 &suffix
, &mode
, &type
))
2806 /* Mode must start with 'r' or 'U' and must not contain '+'.
2807 Implicit in this test is the assumption that the mode
2808 may contain other modifiers like 'b' or 't'. */
2810 if (!(*mode
== 'r' || *mode
== 'U') || strchr(mode
, '+')) {
2811 PyErr_Format(PyExc_ValueError
,
2812 "invalid file open mode %.200s", mode
);
2819 if (!PyFile_Check(fob
)) {
2820 PyErr_SetString(PyExc_ValueError
,
2821 "load_module arg#2 should be a file or None");
2824 fp
= get_file(pathname
, fob
, mode
);
2828 return load_module(name
, fp
, pathname
, type
, NULL
);
2832 imp_load_package(PyObject
*self
, PyObject
*args
)
2836 if (!PyArg_ParseTuple(args
, "ss:load_package", &name
, &pathname
))
2838 return load_package(name
, pathname
);
2842 imp_new_module(PyObject
*self
, PyObject
*args
)
2845 if (!PyArg_ParseTuple(args
, "s:new_module", &name
))
2847 return PyModule_New(name
);
2852 PyDoc_STRVAR(doc_imp
,
2853 "This module provides the components needed to build your own\n\
2854 __import__ function. Undocumented functions are obsolete.");
2856 PyDoc_STRVAR(doc_find_module
,
2857 "find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
2858 Search for a module. If path is omitted or None, search for a\n\
2859 built-in, frozen or special module and continue search in sys.path.\n\
2860 The module name cannot contain '.'; to search for a submodule of a\n\
2861 package, pass the submodule name and the package's __path__.");
2863 PyDoc_STRVAR(doc_load_module
,
2864 "load_module(name, file, filename, (suffix, mode, type)) -> module\n\
2865 Load a module, given information returned by find_module().\n\
2866 The module name must include the full package name, if any.");
2868 PyDoc_STRVAR(doc_get_magic
,
2869 "get_magic() -> string\n\
2870 Return the magic number for .pyc or .pyo files.");
2872 PyDoc_STRVAR(doc_get_suffixes
,
2873 "get_suffixes() -> [(suffix, mode, type), ...]\n\
2874 Return a list of (suffix, mode, type) tuples describing the files\n\
2875 that find_module() looks for.");
2877 PyDoc_STRVAR(doc_new_module
,
2878 "new_module(name) -> module\n\
2879 Create a new module. Do not enter it in sys.modules.\n\
2880 The module name must include the full package name, if any.");
2882 PyDoc_STRVAR(doc_lock_held
,
2883 "lock_held() -> boolean\n\
2884 Return True if the import lock is currently held, else False.\n\
2885 On platforms without threads, return False.");
2887 PyDoc_STRVAR(doc_acquire_lock
,
2888 "acquire_lock() -> None\n\
2889 Acquires the interpreter's import lock for the current thread.\n\
2890 This lock should be used by import hooks to ensure thread-safety\n\
2891 when importing modules.\n\
2892 On platforms without threads, this function does nothing.");
2894 PyDoc_STRVAR(doc_release_lock
,
2895 "release_lock() -> None\n\
2896 Release the interpreter's import lock.\n\
2897 On platforms without threads, this function does nothing.");
2899 static PyMethodDef imp_methods
[] = {
2900 {"find_module", imp_find_module
, METH_VARARGS
, doc_find_module
},
2901 {"get_magic", imp_get_magic
, METH_NOARGS
, doc_get_magic
},
2902 {"get_suffixes", imp_get_suffixes
, METH_NOARGS
, doc_get_suffixes
},
2903 {"load_module", imp_load_module
, METH_VARARGS
, doc_load_module
},
2904 {"new_module", imp_new_module
, METH_VARARGS
, doc_new_module
},
2905 {"lock_held", imp_lock_held
, METH_NOARGS
, doc_lock_held
},
2906 {"acquire_lock", imp_acquire_lock
, METH_NOARGS
, doc_acquire_lock
},
2907 {"release_lock", imp_release_lock
, METH_NOARGS
, doc_release_lock
},
2908 /* The rest are obsolete */
2909 {"get_frozen_object", imp_get_frozen_object
, METH_VARARGS
},
2910 {"init_builtin", imp_init_builtin
, METH_VARARGS
},
2911 {"init_frozen", imp_init_frozen
, METH_VARARGS
},
2912 {"is_builtin", imp_is_builtin
, METH_VARARGS
},
2913 {"is_frozen", imp_is_frozen
, METH_VARARGS
},
2914 {"load_compiled", imp_load_compiled
, METH_VARARGS
},
2915 #ifdef HAVE_DYNAMIC_LOADING
2916 {"load_dynamic", imp_load_dynamic
, METH_VARARGS
},
2918 {"load_package", imp_load_package
, METH_VARARGS
},
2919 {"load_source", imp_load_source
, METH_VARARGS
},
2920 {NULL
, NULL
} /* sentinel */
2924 setint(PyObject
*d
, char *name
, int value
)
2929 v
= PyInt_FromLong((long)value
);
2930 err
= PyDict_SetItemString(d
, name
, v
);
2940 NullImporter_init(NullImporter
*self
, PyObject
*args
, PyObject
*kwds
)
2944 if (!_PyArg_NoKeywords("NullImporter()", kwds
))
2947 if (!PyArg_ParseTuple(args
, "s:NullImporter",
2951 if (strlen(path
) == 0) {
2952 PyErr_SetString(PyExc_ImportError
, "empty pathname");
2956 struct stat statbuf
;
2959 rv
= stat(path
, &statbuf
);
2962 if (S_ISDIR(statbuf
.st_mode
)) {
2963 /* it's a directory */
2964 PyErr_SetString(PyExc_ImportError
,
2965 "existing directory");
2970 if (object_exists(path
)) {
2973 /* it's a directory */
2974 PyErr_SetString(PyExc_ImportError
,
2975 "existing directory");
2985 NullImporter_find_module(NullImporter
*self
, PyObject
*args
)
2990 static PyMethodDef NullImporter_methods
[] = {
2991 {"find_module", (PyCFunction
)NullImporter_find_module
, METH_VARARGS
,
2992 "Always return None"
2994 {NULL
} /* Sentinel */
2998 static PyTypeObject NullImporterType
= {
2999 PyObject_HEAD_INIT(NULL
)
3001 "imp.NullImporter", /*tp_name*/
3002 sizeof(NullImporter
), /*tp_basicsize*/
3011 0, /*tp_as_sequence*/
3012 0, /*tp_as_mapping*/
3019 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
3020 "Null importer object", /* tp_doc */
3021 0, /* tp_traverse */
3023 0, /* tp_richcompare */
3024 0, /* tp_weaklistoffset */
3026 0, /* tp_iternext */
3027 NullImporter_methods
, /* tp_methods */
3032 0, /* tp_descr_get */
3033 0, /* tp_descr_set */
3034 0, /* tp_dictoffset */
3035 (initproc
)NullImporter_init
, /* tp_init */
3037 PyType_GenericNew
/* tp_new */
3046 if (PyType_Ready(&NullImporterType
) < 0)
3049 m
= Py_InitModule4("imp", imp_methods
, doc_imp
,
3050 NULL
, PYTHON_API_VERSION
);
3053 d
= PyModule_GetDict(m
);
3057 if (setint(d
, "SEARCH_ERROR", SEARCH_ERROR
) < 0) goto failure
;
3058 if (setint(d
, "PY_SOURCE", PY_SOURCE
) < 0) goto failure
;
3059 if (setint(d
, "PY_COMPILED", PY_COMPILED
) < 0) goto failure
;
3060 if (setint(d
, "C_EXTENSION", C_EXTENSION
) < 0) goto failure
;
3061 if (setint(d
, "PY_RESOURCE", PY_RESOURCE
) < 0) goto failure
;
3062 if (setint(d
, "PKG_DIRECTORY", PKG_DIRECTORY
) < 0) goto failure
;
3063 if (setint(d
, "C_BUILTIN", C_BUILTIN
) < 0) goto failure
;
3064 if (setint(d
, "PY_FROZEN", PY_FROZEN
) < 0) goto failure
;
3065 if (setint(d
, "PY_CODERESOURCE", PY_CODERESOURCE
) < 0) goto failure
;
3066 if (setint(d
, "IMP_HOOK", IMP_HOOK
) < 0) goto failure
;
3068 Py_INCREF(&NullImporterType
);
3069 PyModule_AddObject(m
, "NullImporter", (PyObject
*)&NullImporterType
);
3075 /* API for embedding applications that want to add their own entries
3076 to the table of built-in modules. This should normally be called
3077 *before* Py_Initialize(). When the table resize fails, -1 is
3078 returned and the existing table is unchanged.
3080 After a similar function by Just van Rossum. */
3083 PyImport_ExtendInittab(struct _inittab
*newtab
)
3085 static struct _inittab
*our_copy
= NULL
;
3089 /* Count the number of entries in both tables */
3090 for (n
= 0; newtab
[n
].name
!= NULL
; n
++)
3093 return 0; /* Nothing to do */
3094 for (i
= 0; PyImport_Inittab
[i
].name
!= NULL
; i
++)
3097 /* Allocate new memory for the combined table */
3099 PyMem_RESIZE(p
, struct _inittab
, i
+n
+1);
3103 /* Copy the tables into the new memory */
3104 if (our_copy
!= PyImport_Inittab
)
3105 memcpy(p
, PyImport_Inittab
, (i
+1) * sizeof(struct _inittab
));
3106 PyImport_Inittab
= our_copy
= p
;
3107 memcpy(p
+i
, newtab
, (n
+1) * sizeof(struct _inittab
));
3112 /* Shorthand to add a single entry given a name and a function */
3115 PyImport_AppendInittab(char *name
, void (*initfunc
)(void))
3117 struct _inittab newtab
[2];
3119 memset(newtab
, '\0', sizeof newtab
);
3121 newtab
[0].name
= name
;
3122 newtab
[0].initfunc
= initfunc
;
3124 return PyImport_ExtendInittab(newtab
);