Issue #7282: Fix a memory leak when an RLock was used in a thread other
[python.git] / Python / import.c
blob3ca452a9840657b3459bf144839bea4fcaa6b114
2 /* Module definition and import implementation */
4 #include "Python.h"
6 #include "Python-ast.h"
7 #undef Yield /* undefine macro conflicting with winbase.h */
8 #include "pyarena.h"
9 #include "pythonrun.h"
10 #include "errcode.h"
11 #include "marshal.h"
12 #include "code.h"
13 #include "compile.h"
14 #include "eval.h"
15 #include "osdefs.h"
16 #include "importdl.h"
18 #ifdef HAVE_FCNTL_H
19 #include <fcntl.h>
20 #endif
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
25 #ifdef MS_WINDOWS
26 /* for stat.st_mode */
27 typedef unsigned short mode_t;
28 #endif
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
44 10.
46 Known values:
47 Python 1.5: 20121
48 Python 1.5.1: 20121
49 Python 1.5.2: 20121
50 Python 1.6: 50428
51 Python 2.0: 50823
52 Python 2.0.1: 50823
53 Python 2.1: 60202
54 Python 2.1.1: 60202
55 Python 2.1.2: 60202
56 Python 2.2: 60717
57 Python 2.3a0: 62011
58 Python 2.3a0: 62021
59 Python 2.3a0: 62011 (!)
60 Python 2.4a0: 62041
61 Python 2.4a3: 62051
62 Python 2.4b1: 62061
63 Python 2.5a0: 62071
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;
98 #ifdef RISCOS
99 static const struct filedescr _PyImport_StandardFiletab[] = {
100 {"/py", "U", PY_SOURCE},
101 {"/pyc", "rb", PY_COMPILED},
102 {0, 0}
104 #else
105 static const struct filedescr _PyImport_StandardFiletab[] = {
106 {".py", "U", PY_SOURCE},
107 #ifdef MS_WINDOWS
108 {".pyw", "U", PY_SOURCE},
109 #endif
110 {".pyc", "rb", PY_COMPILED},
111 {0, 0}
113 #endif
116 /* Initialize things */
118 void
119 _PyImport_Init(void)
121 const struct filedescr *scan;
122 struct filedescr *filetab;
123 int countD = 0;
124 int countS = 0;
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)
131 ++countD;
132 #endif
133 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
134 ++countS;
135 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
136 if (filetab == NULL)
137 Py_FatalError("Can't initialize import file table.");
138 #ifdef HAVE_DYNAMIC_LOADING
139 memcpy(filetab, _PyImport_DynLoadFiletab,
140 countD * sizeof(struct filedescr));
141 #endif
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++) {
151 #ifndef RISCOS
152 if (strcmp(filetab->suffix, ".pyc") == 0)
153 filetab->suffix = ".pyo";
154 #else
155 if (strcmp(filetab->suffix, "/pyc") == 0)
156 filetab->suffix = "/pyo";
157 #endif
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;
169 void
170 _PyImportHooks_Init(void)
172 PyObject *v, *path_hooks = NULL, *zimpimport;
173 int err = 0;
175 /* adding sys.path_hooks and sys.path_importer_cache, setting up
176 zipimport */
177 if (PyType_Ready(&PyNullImporter_Type) < 0)
178 goto error;
180 if (Py_VerboseFlag)
181 PySys_WriteStderr("# installing zipimport hook\n");
183 v = PyList_New(0);
184 if (v == NULL)
185 goto error;
186 err = PySys_SetObject("meta_path", v);
187 Py_DECREF(v);
188 if (err)
189 goto error;
190 v = PyDict_New();
191 if (v == NULL)
192 goto error;
193 err = PySys_SetObject("path_importer_cache", v);
194 Py_DECREF(v);
195 if (err)
196 goto error;
197 path_hooks = PyList_New(0);
198 if (path_hooks == NULL)
199 goto error;
200 err = PySys_SetObject("path_hooks", path_hooks);
201 if (err) {
202 error:
203 PyErr_Print();
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 */
212 if (Py_VerboseFlag)
213 PySys_WriteStderr("# can't import zipimport\n");
215 else {
216 PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
217 "zipimporter");
218 Py_DECREF(zimpimport);
219 if (zipimporter == NULL) {
220 PyErr_Clear(); /* No zipimporter object -- okay */
221 if (Py_VerboseFlag)
222 PySys_WriteStderr(
223 "# can't import zipimport.zipimporter\n");
225 else {
226 /* sys.path_hooks.append(zipimporter) */
227 err = PyList_Append(path_hooks, zipimporter);
228 Py_DECREF(zipimporter);
229 if (err)
230 goto error;
231 if (Py_VerboseFlag)
232 PySys_WriteStderr(
233 "# installed zipimport hook\n");
236 Py_DECREF(path_hooks);
239 void
240 _PyImport_Fini(void)
242 Py_XDECREF(extensions);
243 extensions = NULL;
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. */
253 #ifdef WITH_THREAD
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;
261 void
262 _PyImport_AcquireLock(void)
264 long me = PyThread_get_thread_ident();
265 if (me == -1)
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) {
273 import_lock_level++;
274 return;
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;
287 _PyImport_ReleaseLock(void)
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)
293 return -1;
294 import_lock_level--;
295 if (import_lock_level == 0) {
296 import_lock_thread = -1;
297 PyThread_release_lock(import_lock);
299 return 1;
302 /* This function used to be called from PyOS_AfterFork to ensure that newly
303 created child processes do not share locks with the parent, but for some
304 reason only on AIX systems. Instead of re-initializing the lock, we now
305 acquire the import lock around fork() calls. */
307 void
308 _PyImport_ReInitLock(void)
312 #endif
314 static PyObject *
315 imp_lock_held(PyObject *self, PyObject *noargs)
317 #ifdef WITH_THREAD
318 return PyBool_FromLong(import_lock_thread != -1);
319 #else
320 return PyBool_FromLong(0);
321 #endif
324 static PyObject *
325 imp_acquire_lock(PyObject *self, PyObject *noargs)
327 #ifdef WITH_THREAD
328 _PyImport_AcquireLock();
329 #endif
330 Py_INCREF(Py_None);
331 return Py_None;
334 static PyObject *
335 imp_release_lock(PyObject *self, PyObject *noargs)
337 #ifdef WITH_THREAD
338 if (_PyImport_ReleaseLock() < 0) {
339 PyErr_SetString(PyExc_RuntimeError,
340 "not holding the import lock");
341 return NULL;
343 #endif
344 Py_INCREF(Py_None);
345 return Py_None;
348 static void
349 imp_modules_reloading_clear(void)
351 PyInterpreterState *interp = PyThreadState_Get()->interp;
352 if (interp->modules_reloading != NULL)
353 PyDict_Clear(interp->modules_reloading);
356 /* Helper for sys */
358 PyObject *
359 PyImport_GetModuleDict(void)
361 PyInterpreterState *interp = PyThreadState_GET()->interp;
362 if (interp->modules == NULL)
363 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
364 return interp->modules;
368 /* List of names to clear in sys */
369 static char* sys_deletes[] = {
370 "path", "argv", "ps1", "ps2", "exitfunc",
371 "exc_type", "exc_value", "exc_traceback",
372 "last_type", "last_value", "last_traceback",
373 "path_hooks", "path_importer_cache", "meta_path",
374 /* misc stuff */
375 "flags", "float_info",
376 NULL
379 static char* sys_files[] = {
380 "stdin", "__stdin__",
381 "stdout", "__stdout__",
382 "stderr", "__stderr__",
383 NULL
387 /* Un-initialize things, as good as we can */
389 void
390 PyImport_Cleanup(void)
392 Py_ssize_t pos, ndone;
393 char *name;
394 PyObject *key, *value, *dict;
395 PyInterpreterState *interp = PyThreadState_GET()->interp;
396 PyObject *modules = interp->modules;
398 if (modules == NULL)
399 return; /* Already done */
401 /* Delete some special variables first. These are common
402 places where user values hide and people complain when their
403 destructors fail. Since the modules containing them are
404 deleted *last* of all, they would come too late in the normal
405 destruction order. Sigh. */
407 value = PyDict_GetItemString(modules, "__builtin__");
408 if (value != NULL && PyModule_Check(value)) {
409 dict = PyModule_GetDict(value);
410 if (Py_VerboseFlag)
411 PySys_WriteStderr("# clear __builtin__._\n");
412 PyDict_SetItemString(dict, "_", Py_None);
414 value = PyDict_GetItemString(modules, "sys");
415 if (value != NULL && PyModule_Check(value)) {
416 char **p;
417 PyObject *v;
418 dict = PyModule_GetDict(value);
419 for (p = sys_deletes; *p != NULL; p++) {
420 if (Py_VerboseFlag)
421 PySys_WriteStderr("# clear sys.%s\n", *p);
422 PyDict_SetItemString(dict, *p, Py_None);
424 for (p = sys_files; *p != NULL; p+=2) {
425 if (Py_VerboseFlag)
426 PySys_WriteStderr("# restore sys.%s\n", *p);
427 v = PyDict_GetItemString(dict, *(p+1));
428 if (v == NULL)
429 v = Py_None;
430 PyDict_SetItemString(dict, *p, v);
434 /* First, delete __main__ */
435 value = PyDict_GetItemString(modules, "__main__");
436 if (value != NULL && PyModule_Check(value)) {
437 if (Py_VerboseFlag)
438 PySys_WriteStderr("# cleanup __main__\n");
439 _PyModule_Clear(value);
440 PyDict_SetItemString(modules, "__main__", Py_None);
443 /* The special treatment of __builtin__ here is because even
444 when it's not referenced as a module, its dictionary is
445 referenced by almost every module's __builtins__. Since
446 deleting a module clears its dictionary (even if there are
447 references left to it), we need to delete the __builtin__
448 module last. Likewise, we don't delete sys until the very
449 end because it is implicitly referenced (e.g. by print).
451 Also note that we 'delete' modules by replacing their entry
452 in the modules dict with None, rather than really deleting
453 them; this avoids a rehash of the modules dictionary and
454 also marks them as "non existent" so they won't be
455 re-imported. */
457 /* Next, repeatedly delete modules with a reference count of
458 one (skipping __builtin__ and sys) and delete them */
459 do {
460 ndone = 0;
461 pos = 0;
462 while (PyDict_Next(modules, &pos, &key, &value)) {
463 if (value->ob_refcnt != 1)
464 continue;
465 if (PyString_Check(key) && PyModule_Check(value)) {
466 name = PyString_AS_STRING(key);
467 if (strcmp(name, "__builtin__") == 0)
468 continue;
469 if (strcmp(name, "sys") == 0)
470 continue;
471 if (Py_VerboseFlag)
472 PySys_WriteStderr(
473 "# cleanup[1] %s\n", name);
474 _PyModule_Clear(value);
475 PyDict_SetItem(modules, key, Py_None);
476 ndone++;
479 } while (ndone > 0);
481 /* Next, delete all modules (still skipping __builtin__ and sys) */
482 pos = 0;
483 while (PyDict_Next(modules, &pos, &key, &value)) {
484 if (PyString_Check(key) && PyModule_Check(value)) {
485 name = PyString_AS_STRING(key);
486 if (strcmp(name, "__builtin__") == 0)
487 continue;
488 if (strcmp(name, "sys") == 0)
489 continue;
490 if (Py_VerboseFlag)
491 PySys_WriteStderr("# cleanup[2] %s\n", name);
492 _PyModule_Clear(value);
493 PyDict_SetItem(modules, key, Py_None);
497 /* Next, delete sys and __builtin__ (in that order) */
498 value = PyDict_GetItemString(modules, "sys");
499 if (value != NULL && PyModule_Check(value)) {
500 if (Py_VerboseFlag)
501 PySys_WriteStderr("# cleanup sys\n");
502 _PyModule_Clear(value);
503 PyDict_SetItemString(modules, "sys", Py_None);
505 value = PyDict_GetItemString(modules, "__builtin__");
506 if (value != NULL && PyModule_Check(value)) {
507 if (Py_VerboseFlag)
508 PySys_WriteStderr("# cleanup __builtin__\n");
509 _PyModule_Clear(value);
510 PyDict_SetItemString(modules, "__builtin__", Py_None);
513 /* Finally, clear and delete the modules directory */
514 PyDict_Clear(modules);
515 interp->modules = NULL;
516 Py_DECREF(modules);
517 Py_CLEAR(interp->modules_reloading);
521 /* Helper for pythonrun.c -- return magic number */
523 long
524 PyImport_GetMagicNumber(void)
526 return pyc_magic;
530 /* Magic for extension modules (built-in as well as dynamically
531 loaded). To prevent initializing an extension module more than
532 once, we keep a static dictionary 'extensions' keyed by module name
533 (for built-in modules) or by filename (for dynamically loaded
534 modules), containing these modules. A copy of the module's
535 dictionary is stored by calling _PyImport_FixupExtension()
536 immediately after the module initialization function succeeds. A
537 copy can be retrieved from there by calling
538 _PyImport_FindExtension(). */
540 PyObject *
541 _PyImport_FixupExtension(char *name, char *filename)
543 PyObject *modules, *mod, *dict, *copy;
544 if (extensions == NULL) {
545 extensions = PyDict_New();
546 if (extensions == NULL)
547 return NULL;
549 modules = PyImport_GetModuleDict();
550 mod = PyDict_GetItemString(modules, name);
551 if (mod == NULL || !PyModule_Check(mod)) {
552 PyErr_Format(PyExc_SystemError,
553 "_PyImport_FixupExtension: module %.200s not loaded", name);
554 return NULL;
556 dict = PyModule_GetDict(mod);
557 if (dict == NULL)
558 return NULL;
559 copy = PyDict_Copy(dict);
560 if (copy == NULL)
561 return NULL;
562 PyDict_SetItemString(extensions, filename, copy);
563 Py_DECREF(copy);
564 return copy;
567 PyObject *
568 _PyImport_FindExtension(char *name, char *filename)
570 PyObject *dict, *mod, *mdict;
571 if (extensions == NULL)
572 return NULL;
573 dict = PyDict_GetItemString(extensions, filename);
574 if (dict == NULL)
575 return NULL;
576 mod = PyImport_AddModule(name);
577 if (mod == NULL)
578 return NULL;
579 mdict = PyModule_GetDict(mod);
580 if (mdict == NULL)
581 return NULL;
582 if (PyDict_Update(mdict, dict))
583 return NULL;
584 if (Py_VerboseFlag)
585 PySys_WriteStderr("import %s # previously loaded (%s)\n",
586 name, filename);
587 return mod;
591 /* Get the module object corresponding to a module name.
592 First check the modules dictionary if there's one there,
593 if not, create a new one and insert it in the modules dictionary.
594 Because the former action is most common, THIS DOES NOT RETURN A
595 'NEW' REFERENCE! */
597 PyObject *
598 PyImport_AddModule(const char *name)
600 PyObject *modules = PyImport_GetModuleDict();
601 PyObject *m;
603 if ((m = PyDict_GetItemString(modules, name)) != NULL &&
604 PyModule_Check(m))
605 return m;
606 m = PyModule_New(name);
607 if (m == NULL)
608 return NULL;
609 if (PyDict_SetItemString(modules, name, m) != 0) {
610 Py_DECREF(m);
611 return NULL;
613 Py_DECREF(m); /* Yes, it still exists, in modules! */
615 return m;
618 /* Remove name from sys.modules, if it's there. */
619 static void
620 _RemoveModule(const char *name)
622 PyObject *modules = PyImport_GetModuleDict();
623 if (PyDict_GetItemString(modules, name) == NULL)
624 return;
625 if (PyDict_DelItemString(modules, name) < 0)
626 Py_FatalError("import: deleting existing key in"
627 "sys.modules failed");
630 /* Execute a code object in a module and return the module object
631 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
632 * removed from sys.modules, to avoid leaving damaged module objects
633 * in sys.modules. The caller may wish to restore the original
634 * module object (if any) in this case; PyImport_ReloadModule is an
635 * example.
637 PyObject *
638 PyImport_ExecCodeModule(char *name, PyObject *co)
640 return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
643 PyObject *
644 PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
646 PyObject *modules = PyImport_GetModuleDict();
647 PyObject *m, *d, *v;
649 m = PyImport_AddModule(name);
650 if (m == NULL)
651 return NULL;
652 /* If the module is being reloaded, we get the old module back
653 and re-use its dict to exec the new code. */
654 d = PyModule_GetDict(m);
655 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
656 if (PyDict_SetItemString(d, "__builtins__",
657 PyEval_GetBuiltins()) != 0)
658 goto error;
660 /* Remember the filename as the __file__ attribute */
661 v = NULL;
662 if (pathname != NULL) {
663 v = PyString_FromString(pathname);
664 if (v == NULL)
665 PyErr_Clear();
667 if (v == NULL) {
668 v = ((PyCodeObject *)co)->co_filename;
669 Py_INCREF(v);
671 if (PyDict_SetItemString(d, "__file__", v) != 0)
672 PyErr_Clear(); /* Not important enough to report */
673 Py_DECREF(v);
675 v = PyEval_EvalCode((PyCodeObject *)co, d, d);
676 if (v == NULL)
677 goto error;
678 Py_DECREF(v);
680 if ((m = PyDict_GetItemString(modules, name)) == NULL) {
681 PyErr_Format(PyExc_ImportError,
682 "Loaded module %.200s not found in sys.modules",
683 name);
684 return NULL;
687 Py_INCREF(m);
689 return m;
691 error:
692 _RemoveModule(name);
693 return NULL;
697 /* Given a pathname for a Python source file, fill a buffer with the
698 pathname for the corresponding compiled file. Return the pathname
699 for the compiled file, or NULL if there's no space in the buffer.
700 Doesn't set an exception. */
702 static char *
703 make_compiled_pathname(char *pathname, char *buf, size_t buflen)
705 size_t len = strlen(pathname);
706 if (len+2 > buflen)
707 return NULL;
709 #ifdef MS_WINDOWS
710 /* Treat .pyw as if it were .py. The case of ".pyw" must match
711 that used in _PyImport_StandardFiletab. */
712 if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
713 --len; /* pretend 'w' isn't there */
714 #endif
715 memcpy(buf, pathname, len);
716 buf[len] = Py_OptimizeFlag ? 'o' : 'c';
717 buf[len+1] = '\0';
719 return buf;
723 /* Given a pathname for a Python source file, its time of last
724 modification, and a pathname for a compiled file, check whether the
725 compiled file represents the same version of the source. If so,
726 return a FILE pointer for the compiled file, positioned just after
727 the header; if not, return NULL.
728 Doesn't set an exception. */
730 static FILE *
731 check_compiled_module(char *pathname, time_t mtime, char *cpathname)
733 FILE *fp;
734 long magic;
735 long pyc_mtime;
737 fp = fopen(cpathname, "rb");
738 if (fp == NULL)
739 return NULL;
740 magic = PyMarshal_ReadLongFromFile(fp);
741 if (magic != pyc_magic) {
742 if (Py_VerboseFlag)
743 PySys_WriteStderr("# %s has bad magic\n", cpathname);
744 fclose(fp);
745 return NULL;
747 pyc_mtime = PyMarshal_ReadLongFromFile(fp);
748 if (pyc_mtime != mtime) {
749 if (Py_VerboseFlag)
750 PySys_WriteStderr("# %s has bad mtime\n", cpathname);
751 fclose(fp);
752 return NULL;
754 if (Py_VerboseFlag)
755 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
756 return fp;
760 /* Read a code object from a file and check it for validity */
762 static PyCodeObject *
763 read_compiled_module(char *cpathname, FILE *fp)
765 PyObject *co;
767 co = PyMarshal_ReadLastObjectFromFile(fp);
768 if (co == NULL)
769 return NULL;
770 if (!PyCode_Check(co)) {
771 PyErr_Format(PyExc_ImportError,
772 "Non-code object in %.200s", cpathname);
773 Py_DECREF(co);
774 return NULL;
776 return (PyCodeObject *)co;
780 /* Load a module from a compiled file, execute it, and return its
781 module object WITH INCREMENTED REFERENCE COUNT */
783 static PyObject *
784 load_compiled_module(char *name, char *cpathname, FILE *fp)
786 long magic;
787 PyCodeObject *co;
788 PyObject *m;
790 magic = PyMarshal_ReadLongFromFile(fp);
791 if (magic != pyc_magic) {
792 PyErr_Format(PyExc_ImportError,
793 "Bad magic number in %.200s", cpathname);
794 return NULL;
796 (void) PyMarshal_ReadLongFromFile(fp);
797 co = read_compiled_module(cpathname, fp);
798 if (co == NULL)
799 return NULL;
800 if (Py_VerboseFlag)
801 PySys_WriteStderr("import %s # precompiled from %s\n",
802 name, cpathname);
803 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
804 Py_DECREF(co);
806 return m;
809 /* Parse a source file and return the corresponding code object */
811 static PyCodeObject *
812 parse_source_module(const char *pathname, FILE *fp)
814 PyCodeObject *co = NULL;
815 mod_ty mod;
816 PyCompilerFlags flags;
817 PyArena *arena = PyArena_New();
818 if (arena == NULL)
819 return NULL;
821 flags.cf_flags = 0;
823 mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags,
824 NULL, arena);
825 if (mod) {
826 co = PyAST_Compile(mod, pathname, NULL, arena);
828 PyArena_Free(arena);
829 return co;
833 /* Helper to open a bytecode file for writing in exclusive mode */
835 static FILE *
836 open_exclusive(char *filename, mode_t mode)
838 #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
839 /* Use O_EXCL to avoid a race condition when another process tries to
840 write the same file. When that happens, our open() call fails,
841 which is just fine (since it's only a cache).
842 XXX If the file exists and is writable but the directory is not
843 writable, the file will never be written. Oh well.
845 int fd;
846 (void) unlink(filename);
847 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
848 #ifdef O_BINARY
849 |O_BINARY /* necessary for Windows */
850 #endif
851 #ifdef __VMS
852 , mode, "ctxt=bin", "shr=nil"
853 #else
854 , mode
855 #endif
857 if (fd < 0)
858 return NULL;
859 return fdopen(fd, "wb");
860 #else
861 /* Best we can do -- on Windows this can't happen anyway */
862 return fopen(filename, "wb");
863 #endif
867 /* Write a compiled module to a file, placing the time of last
868 modification of its source into the header.
869 Errors are ignored, if a write error occurs an attempt is made to
870 remove the file. */
872 static void
873 write_compiled_module(PyCodeObject *co, char *cpathname, struct stat *srcstat)
875 FILE *fp;
876 time_t mtime = srcstat->st_mtime;
877 #ifdef MS_WINDOWS /* since Windows uses different permissions */
878 mode_t mode = srcstat->st_mode & ~S_IEXEC;
879 #else
880 mode_t mode = srcstat->st_mode & ~S_IXUSR & ~S_IXGRP & ~S_IXOTH;
881 #endif
883 fp = open_exclusive(cpathname, mode);
884 if (fp == NULL) {
885 if (Py_VerboseFlag)
886 PySys_WriteStderr(
887 "# can't create %s\n", cpathname);
888 return;
890 PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
891 /* First write a 0 for mtime */
892 PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
893 PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
894 if (fflush(fp) != 0 || ferror(fp)) {
895 if (Py_VerboseFlag)
896 PySys_WriteStderr("# can't write %s\n", cpathname);
897 /* Don't keep partial file */
898 fclose(fp);
899 (void) unlink(cpathname);
900 return;
902 /* Now write the true mtime */
903 fseek(fp, 4L, 0);
904 assert(mtime < LONG_MAX);
905 PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
906 fflush(fp);
907 fclose(fp);
908 if (Py_VerboseFlag)
909 PySys_WriteStderr("# wrote %s\n", cpathname);
912 static void
913 update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
915 PyObject *constants, *tmp;
916 Py_ssize_t i, n;
918 if (!_PyString_Eq(co->co_filename, oldname))
919 return;
921 tmp = co->co_filename;
922 co->co_filename = newname;
923 Py_INCREF(co->co_filename);
924 Py_DECREF(tmp);
926 constants = co->co_consts;
927 n = PyTuple_GET_SIZE(constants);
928 for (i = 0; i < n; i++) {
929 tmp = PyTuple_GET_ITEM(constants, i);
930 if (PyCode_Check(tmp))
931 update_code_filenames((PyCodeObject *)tmp,
932 oldname, newname);
936 static int
937 update_compiled_module(PyCodeObject *co, char *pathname)
939 PyObject *oldname, *newname;
941 if (strcmp(PyString_AsString(co->co_filename), pathname) == 0)
942 return 0;
944 newname = PyString_FromString(pathname);
945 if (newname == NULL)
946 return -1;
948 oldname = co->co_filename;
949 Py_INCREF(oldname);
950 update_code_filenames(co, oldname, newname);
951 Py_DECREF(oldname);
952 Py_DECREF(newname);
953 return 1;
956 /* Load a source module from a given file and return its module
957 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
958 byte-compiled file, use that instead. */
960 static PyObject *
961 load_source_module(char *name, char *pathname, FILE *fp)
963 struct stat st;
964 FILE *fpc;
965 char buf[MAXPATHLEN+1];
966 char *cpathname;
967 PyCodeObject *co;
968 PyObject *m;
970 if (fstat(fileno(fp), &st) != 0) {
971 PyErr_Format(PyExc_RuntimeError,
972 "unable to get file status from '%s'",
973 pathname);
974 return NULL;
976 #if SIZEOF_TIME_T > 4
977 /* Python's .pyc timestamp handling presumes that the timestamp fits
978 in 4 bytes. This will be fine until sometime in the year 2038,
979 when a 4-byte signed time_t will overflow.
981 if (st.st_mtime >> 32) {
982 PyErr_SetString(PyExc_OverflowError,
983 "modification time overflows a 4 byte field");
984 return NULL;
986 #endif
987 cpathname = make_compiled_pathname(pathname, buf,
988 (size_t)MAXPATHLEN + 1);
989 if (cpathname != NULL &&
990 (fpc = check_compiled_module(pathname, st.st_mtime, cpathname))) {
991 co = read_compiled_module(cpathname, fpc);
992 fclose(fpc);
993 if (co == NULL)
994 return NULL;
995 if (update_compiled_module(co, pathname) < 0)
996 return NULL;
997 if (Py_VerboseFlag)
998 PySys_WriteStderr("import %s # precompiled from %s\n",
999 name, cpathname);
1000 pathname = cpathname;
1002 else {
1003 co = parse_source_module(pathname, fp);
1004 if (co == NULL)
1005 return NULL;
1006 if (Py_VerboseFlag)
1007 PySys_WriteStderr("import %s # from %s\n",
1008 name, pathname);
1009 if (cpathname) {
1010 PyObject *ro = PySys_GetObject("dont_write_bytecode");
1011 if (ro == NULL || !PyObject_IsTrue(ro))
1012 write_compiled_module(co, cpathname, &st);
1015 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
1016 Py_DECREF(co);
1018 return m;
1022 /* Forward */
1023 static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
1024 static struct filedescr *find_module(char *, char *, PyObject *,
1025 char *, size_t, FILE **, PyObject **);
1026 static struct _frozen *find_frozen(char *name);
1028 /* Load a package and return its module object WITH INCREMENTED
1029 REFERENCE COUNT */
1031 static PyObject *
1032 load_package(char *name, char *pathname)
1034 PyObject *m, *d;
1035 PyObject *file = NULL;
1036 PyObject *path = NULL;
1037 int err;
1038 char buf[MAXPATHLEN+1];
1039 FILE *fp = NULL;
1040 struct filedescr *fdp;
1042 m = PyImport_AddModule(name);
1043 if (m == NULL)
1044 return NULL;
1045 if (Py_VerboseFlag)
1046 PySys_WriteStderr("import %s # directory %s\n",
1047 name, pathname);
1048 d = PyModule_GetDict(m);
1049 file = PyString_FromString(pathname);
1050 if (file == NULL)
1051 goto error;
1052 path = Py_BuildValue("[O]", file);
1053 if (path == NULL)
1054 goto error;
1055 err = PyDict_SetItemString(d, "__file__", file);
1056 if (err == 0)
1057 err = PyDict_SetItemString(d, "__path__", path);
1058 if (err != 0)
1059 goto error;
1060 buf[0] = '\0';
1061 fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
1062 if (fdp == NULL) {
1063 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1064 PyErr_Clear();
1065 Py_INCREF(m);
1067 else
1068 m = NULL;
1069 goto cleanup;
1071 m = load_module(name, fp, buf, fdp->type, NULL);
1072 if (fp != NULL)
1073 fclose(fp);
1074 goto cleanup;
1076 error:
1077 m = NULL;
1078 cleanup:
1079 Py_XDECREF(path);
1080 Py_XDECREF(file);
1081 return m;
1085 /* Helper to test for built-in module */
1087 static int
1088 is_builtin(char *name)
1090 int i;
1091 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1092 if (strcmp(name, PyImport_Inittab[i].name) == 0) {
1093 if (PyImport_Inittab[i].initfunc == NULL)
1094 return -1;
1095 else
1096 return 1;
1099 return 0;
1103 /* Return an importer object for a sys.path/pkg.__path__ item 'p',
1104 possibly by fetching it from the path_importer_cache dict. If it
1105 wasn't yet cached, traverse path_hooks until a hook is found
1106 that can handle the path item. Return None if no hook could;
1107 this tells our caller it should fall back to the builtin
1108 import mechanism. Cache the result in path_importer_cache.
1109 Returns a borrowed reference. */
1111 static PyObject *
1112 get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
1113 PyObject *p)
1115 PyObject *importer;
1116 Py_ssize_t j, nhooks;
1118 /* These conditions are the caller's responsibility: */
1119 assert(PyList_Check(path_hooks));
1120 assert(PyDict_Check(path_importer_cache));
1122 nhooks = PyList_Size(path_hooks);
1123 if (nhooks < 0)
1124 return NULL; /* Shouldn't happen */
1126 importer = PyDict_GetItem(path_importer_cache, p);
1127 if (importer != NULL)
1128 return importer;
1130 /* set path_importer_cache[p] to None to avoid recursion */
1131 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1132 return NULL;
1134 for (j = 0; j < nhooks; j++) {
1135 PyObject *hook = PyList_GetItem(path_hooks, j);
1136 if (hook == NULL)
1137 return NULL;
1138 importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
1139 if (importer != NULL)
1140 break;
1142 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1143 return NULL;
1145 PyErr_Clear();
1147 if (importer == NULL) {
1148 importer = PyObject_CallFunctionObjArgs(
1149 (PyObject *)&PyNullImporter_Type, p, NULL
1151 if (importer == NULL) {
1152 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1153 PyErr_Clear();
1154 return Py_None;
1158 if (importer != NULL) {
1159 int err = PyDict_SetItem(path_importer_cache, p, importer);
1160 Py_DECREF(importer);
1161 if (err != 0)
1162 return NULL;
1164 return importer;
1167 PyAPI_FUNC(PyObject *)
1168 PyImport_GetImporter(PyObject *path) {
1169 PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
1171 if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {
1172 if ((path_hooks = PySys_GetObject("path_hooks"))) {
1173 importer = get_path_importer(path_importer_cache,
1174 path_hooks, path);
1177 Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
1178 return importer;
1181 /* Search the path (default sys.path) for a module. Return the
1182 corresponding filedescr struct, and (via return arguments) the
1183 pathname and an open file. Return NULL if the module is not found. */
1185 #ifdef MS_COREDLL
1186 extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
1187 char *, Py_ssize_t);
1188 #endif
1190 static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
1191 static int find_init_module(char *); /* Forward */
1192 static struct filedescr importhookdescr = {"", "", IMP_HOOK};
1194 static struct filedescr *
1195 find_module(char *fullname, char *subname, PyObject *path, char *buf,
1196 size_t buflen, FILE **p_fp, PyObject **p_loader)
1198 Py_ssize_t i, npath;
1199 size_t len, namelen;
1200 struct filedescr *fdp = NULL;
1201 char *filemode;
1202 FILE *fp = NULL;
1203 PyObject *path_hooks, *path_importer_cache;
1204 #ifndef RISCOS
1205 struct stat statbuf;
1206 #endif
1207 static struct filedescr fd_frozen = {"", "", PY_FROZEN};
1208 static struct filedescr fd_builtin = {"", "", C_BUILTIN};
1209 static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
1210 char name[MAXPATHLEN+1];
1211 #if defined(PYOS_OS2)
1212 size_t saved_len;
1213 size_t saved_namelen;
1214 char *saved_buf = NULL;
1215 #endif
1216 if (p_loader != NULL)
1217 *p_loader = NULL;
1219 if (strlen(subname) > MAXPATHLEN) {
1220 PyErr_SetString(PyExc_OverflowError,
1221 "module name is too long");
1222 return NULL;
1224 strcpy(name, subname);
1226 /* sys.meta_path import hook */
1227 if (p_loader != NULL) {
1228 PyObject *meta_path;
1230 meta_path = PySys_GetObject("meta_path");
1231 if (meta_path == NULL || !PyList_Check(meta_path)) {
1232 PyErr_SetString(PyExc_ImportError,
1233 "sys.meta_path must be a list of "
1234 "import hooks");
1235 return NULL;
1237 Py_INCREF(meta_path); /* zap guard */
1238 npath = PyList_Size(meta_path);
1239 for (i = 0; i < npath; i++) {
1240 PyObject *loader;
1241 PyObject *hook = PyList_GetItem(meta_path, i);
1242 loader = PyObject_CallMethod(hook, "find_module",
1243 "sO", fullname,
1244 path != NULL ?
1245 path : Py_None);
1246 if (loader == NULL) {
1247 Py_DECREF(meta_path);
1248 return NULL; /* true error */
1250 if (loader != Py_None) {
1251 /* a loader was found */
1252 *p_loader = loader;
1253 Py_DECREF(meta_path);
1254 return &importhookdescr;
1256 Py_DECREF(loader);
1258 Py_DECREF(meta_path);
1261 if (path != NULL && PyString_Check(path)) {
1262 /* The only type of submodule allowed inside a "frozen"
1263 package are other frozen modules or packages. */
1264 if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
1265 PyErr_SetString(PyExc_ImportError,
1266 "full frozen module name too long");
1267 return NULL;
1269 strcpy(buf, PyString_AsString(path));
1270 strcat(buf, ".");
1271 strcat(buf, name);
1272 strcpy(name, buf);
1273 if (find_frozen(name) != NULL) {
1274 strcpy(buf, name);
1275 return &fd_frozen;
1277 PyErr_Format(PyExc_ImportError,
1278 "No frozen submodule named %.200s", name);
1279 return NULL;
1281 if (path == NULL) {
1282 if (is_builtin(name)) {
1283 strcpy(buf, name);
1284 return &fd_builtin;
1286 if ((find_frozen(name)) != NULL) {
1287 strcpy(buf, name);
1288 return &fd_frozen;
1291 #ifdef MS_COREDLL
1292 fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
1293 if (fp != NULL) {
1294 *p_fp = fp;
1295 return fdp;
1297 #endif
1298 path = PySys_GetObject("path");
1300 if (path == NULL || !PyList_Check(path)) {
1301 PyErr_SetString(PyExc_ImportError,
1302 "sys.path must be a list of directory names");
1303 return NULL;
1306 path_hooks = PySys_GetObject("path_hooks");
1307 if (path_hooks == NULL || !PyList_Check(path_hooks)) {
1308 PyErr_SetString(PyExc_ImportError,
1309 "sys.path_hooks must be a list of "
1310 "import hooks");
1311 return NULL;
1313 path_importer_cache = PySys_GetObject("path_importer_cache");
1314 if (path_importer_cache == NULL ||
1315 !PyDict_Check(path_importer_cache)) {
1316 PyErr_SetString(PyExc_ImportError,
1317 "sys.path_importer_cache must be a dict");
1318 return NULL;
1321 npath = PyList_Size(path);
1322 namelen = strlen(name);
1323 for (i = 0; i < npath; i++) {
1324 PyObject *copy = NULL;
1325 PyObject *v = PyList_GetItem(path, i);
1326 if (!v)
1327 return NULL;
1328 #ifdef Py_USING_UNICODE
1329 if (PyUnicode_Check(v)) {
1330 copy = PyUnicode_Encode(PyUnicode_AS_UNICODE(v),
1331 PyUnicode_GET_SIZE(v), Py_FileSystemDefaultEncoding, NULL);
1332 if (copy == NULL)
1333 return NULL;
1334 v = copy;
1336 else
1337 #endif
1338 if (!PyString_Check(v))
1339 continue;
1340 len = PyString_GET_SIZE(v);
1341 if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
1342 Py_XDECREF(copy);
1343 continue; /* Too long */
1345 strcpy(buf, PyString_AS_STRING(v));
1346 if (strlen(buf) != len) {
1347 Py_XDECREF(copy);
1348 continue; /* v contains '\0' */
1351 /* sys.path_hooks import hook */
1352 if (p_loader != NULL) {
1353 PyObject *importer;
1355 importer = get_path_importer(path_importer_cache,
1356 path_hooks, v);
1357 if (importer == NULL) {
1358 Py_XDECREF(copy);
1359 return NULL;
1361 /* Note: importer is a borrowed reference */
1362 if (importer != Py_None) {
1363 PyObject *loader;
1364 loader = PyObject_CallMethod(importer,
1365 "find_module",
1366 "s", fullname);
1367 Py_XDECREF(copy);
1368 if (loader == NULL)
1369 return NULL; /* error */
1370 if (loader != Py_None) {
1371 /* a loader was found */
1372 *p_loader = loader;
1373 return &importhookdescr;
1375 Py_DECREF(loader);
1376 continue;
1379 /* no hook was found, use builtin import */
1381 if (len > 0 && buf[len-1] != SEP
1382 #ifdef ALTSEP
1383 && buf[len-1] != ALTSEP
1384 #endif
1386 buf[len++] = SEP;
1387 strcpy(buf+len, name);
1388 len += namelen;
1390 /* Check for package import (buf holds a directory name,
1391 and there's an __init__ module in that directory */
1392 #ifdef HAVE_STAT
1393 if (stat(buf, &statbuf) == 0 && /* it exists */
1394 S_ISDIR(statbuf.st_mode) && /* it's a directory */
1395 case_ok(buf, len, namelen, name)) { /* case matches */
1396 if (find_init_module(buf)) { /* and has __init__.py */
1397 Py_XDECREF(copy);
1398 return &fd_package;
1400 else {
1401 char warnstr[MAXPATHLEN+80];
1402 sprintf(warnstr, "Not importing directory "
1403 "'%.*s': missing __init__.py",
1404 MAXPATHLEN, buf);
1405 if (PyErr_Warn(PyExc_ImportWarning,
1406 warnstr)) {
1407 Py_XDECREF(copy);
1408 return NULL;
1412 #else
1413 /* XXX How are you going to test for directories? */
1414 #ifdef RISCOS
1415 if (isdir(buf) &&
1416 case_ok(buf, len, namelen, name)) {
1417 if (find_init_module(buf)) {
1418 Py_XDECREF(copy);
1419 return &fd_package;
1421 else {
1422 char warnstr[MAXPATHLEN+80];
1423 sprintf(warnstr, "Not importing directory "
1424 "'%.*s': missing __init__.py",
1425 MAXPATHLEN, buf);
1426 if (PyErr_Warn(PyExc_ImportWarning,
1427 warnstr)) {
1428 Py_XDECREF(copy);
1429 return NULL;
1432 #endif
1433 #endif
1434 #if defined(PYOS_OS2)
1435 /* take a snapshot of the module spec for restoration
1436 * after the 8 character DLL hackery
1438 saved_buf = strdup(buf);
1439 saved_len = len;
1440 saved_namelen = namelen;
1441 #endif /* PYOS_OS2 */
1442 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
1443 #if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
1444 /* OS/2 limits DLLs to 8 character names (w/o
1445 extension)
1446 * so if the name is longer than that and its a
1447 * dynamically loaded module we're going to try,
1448 * truncate the name before trying
1450 if (strlen(subname) > 8) {
1451 /* is this an attempt to load a C extension? */
1452 const struct filedescr *scan;
1453 scan = _PyImport_DynLoadFiletab;
1454 while (scan->suffix != NULL) {
1455 if (!strcmp(scan->suffix, fdp->suffix))
1456 break;
1457 else
1458 scan++;
1460 if (scan->suffix != NULL) {
1461 /* yes, so truncate the name */
1462 namelen = 8;
1463 len -= strlen(subname) - namelen;
1464 buf[len] = '\0';
1467 #endif /* PYOS_OS2 */
1468 strcpy(buf+len, fdp->suffix);
1469 if (Py_VerboseFlag > 1)
1470 PySys_WriteStderr("# trying %s\n", buf);
1471 filemode = fdp->mode;
1472 if (filemode[0] == 'U')
1473 filemode = "r" PY_STDIOTEXTMODE;
1474 fp = fopen(buf, filemode);
1475 if (fp != NULL) {
1476 if (case_ok(buf, len, namelen, name))
1477 break;
1478 else { /* continue search */
1479 fclose(fp);
1480 fp = NULL;
1483 #if defined(PYOS_OS2)
1484 /* restore the saved snapshot */
1485 strcpy(buf, saved_buf);
1486 len = saved_len;
1487 namelen = saved_namelen;
1488 #endif
1490 #if defined(PYOS_OS2)
1491 /* don't need/want the module name snapshot anymore */
1492 if (saved_buf)
1494 free(saved_buf);
1495 saved_buf = NULL;
1497 #endif
1498 Py_XDECREF(copy);
1499 if (fp != NULL)
1500 break;
1502 if (fp == NULL) {
1503 PyErr_Format(PyExc_ImportError,
1504 "No module named %.200s", name);
1505 return NULL;
1507 *p_fp = fp;
1508 return fdp;
1511 /* Helpers for main.c
1512 * Find the source file corresponding to a named module
1514 struct filedescr *
1515 _PyImport_FindModule(const char *name, PyObject *path, char *buf,
1516 size_t buflen, FILE **p_fp, PyObject **p_loader)
1518 return find_module((char *) name, (char *) name, path,
1519 buf, buflen, p_fp, p_loader);
1522 PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)
1524 return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
1527 /* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
1528 * The arguments here are tricky, best shown by example:
1529 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1530 * ^ ^ ^ ^
1531 * |--------------------- buf ---------------------|
1532 * |------------------- len ------------------|
1533 * |------ name -------|
1534 * |----- namelen -----|
1535 * buf is the full path, but len only counts up to (& exclusive of) the
1536 * extension. name is the module name, also exclusive of extension.
1538 * We've already done a successful stat() or fopen() on buf, so know that
1539 * there's some match, possibly case-insensitive.
1541 * case_ok() is to return 1 if there's a case-sensitive match for
1542 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1543 * exists.
1545 * case_ok() is used to implement case-sensitive import semantics even
1546 * on platforms with case-insensitive filesystems. It's trivial to implement
1547 * for case-sensitive filesystems. It's pretty much a cross-platform
1548 * nightmare for systems with case-insensitive filesystems.
1551 /* First we may need a pile of platform-specific header files; the sequence
1552 * of #if's here should match the sequence in the body of case_ok().
1554 #if defined(MS_WINDOWS)
1555 #include <windows.h>
1557 #elif defined(DJGPP)
1558 #include <dir.h>
1560 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1561 #include <sys/types.h>
1562 #include <dirent.h>
1564 #elif defined(PYOS_OS2)
1565 #define INCL_DOS
1566 #define INCL_DOSERRORS
1567 #define INCL_NOPMAPI
1568 #include <os2.h>
1570 #elif defined(RISCOS)
1571 #include "oslib/osfscontrol.h"
1572 #endif
1574 static int
1575 case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
1577 /* Pick a platform-specific implementation; the sequence of #if's here should
1578 * match the sequence just above.
1581 /* MS_WINDOWS */
1582 #if defined(MS_WINDOWS)
1583 WIN32_FIND_DATA data;
1584 HANDLE h;
1586 if (Py_GETENV("PYTHONCASEOK") != NULL)
1587 return 1;
1589 h = FindFirstFile(buf, &data);
1590 if (h == INVALID_HANDLE_VALUE) {
1591 PyErr_Format(PyExc_NameError,
1592 "Can't find file for module %.100s\n(filename %.300s)",
1593 name, buf);
1594 return 0;
1596 FindClose(h);
1597 return strncmp(data.cFileName, name, namelen) == 0;
1599 /* DJGPP */
1600 #elif defined(DJGPP)
1601 struct ffblk ffblk;
1602 int done;
1604 if (Py_GETENV("PYTHONCASEOK") != NULL)
1605 return 1;
1607 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1608 if (done) {
1609 PyErr_Format(PyExc_NameError,
1610 "Can't find file for module %.100s\n(filename %.300s)",
1611 name, buf);
1612 return 0;
1614 return strncmp(ffblk.ff_name, name, namelen) == 0;
1616 /* new-fangled macintosh (macosx) or Cygwin */
1617 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1618 DIR *dirp;
1619 struct dirent *dp;
1620 char dirname[MAXPATHLEN + 1];
1621 const int dirlen = len - namelen - 1; /* don't want trailing SEP */
1623 if (Py_GETENV("PYTHONCASEOK") != NULL)
1624 return 1;
1626 /* Copy the dir component into dirname; substitute "." if empty */
1627 if (dirlen <= 0) {
1628 dirname[0] = '.';
1629 dirname[1] = '\0';
1631 else {
1632 assert(dirlen <= MAXPATHLEN);
1633 memcpy(dirname, buf, dirlen);
1634 dirname[dirlen] = '\0';
1636 /* Open the directory and search the entries for an exact match. */
1637 dirp = opendir(dirname);
1638 if (dirp) {
1639 char *nameWithExt = buf + len - namelen;
1640 while ((dp = readdir(dirp)) != NULL) {
1641 const int thislen =
1642 #ifdef _DIRENT_HAVE_D_NAMELEN
1643 dp->d_namlen;
1644 #else
1645 strlen(dp->d_name);
1646 #endif
1647 if (thislen >= namelen &&
1648 strcmp(dp->d_name, nameWithExt) == 0) {
1649 (void)closedir(dirp);
1650 return 1; /* Found */
1653 (void)closedir(dirp);
1655 return 0 ; /* Not found */
1657 /* RISC OS */
1658 #elif defined(RISCOS)
1659 char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */
1660 char buf2[MAXPATHLEN+2];
1661 char *nameWithExt = buf+len-namelen;
1662 int canonlen;
1663 os_error *e;
1665 if (Py_GETENV("PYTHONCASEOK") != NULL)
1666 return 1;
1668 /* workaround:
1669 append wildcard, otherwise case of filename wouldn't be touched */
1670 strcpy(buf2, buf);
1671 strcat(buf2, "*");
1673 e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen);
1674 canonlen = MAXPATHLEN+1-canonlen;
1675 if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) )
1676 return 0;
1677 if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)
1678 return 1; /* match */
1680 return 0;
1682 /* OS/2 */
1683 #elif defined(PYOS_OS2)
1684 HDIR hdir = 1;
1685 ULONG srchcnt = 1;
1686 FILEFINDBUF3 ffbuf;
1687 APIRET rc;
1689 if (Py_GETENV("PYTHONCASEOK") != NULL)
1690 return 1;
1692 rc = DosFindFirst(buf,
1693 &hdir,
1694 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1695 &ffbuf, sizeof(ffbuf),
1696 &srchcnt,
1697 FIL_STANDARD);
1698 if (rc != NO_ERROR)
1699 return 0;
1700 return strncmp(ffbuf.achName, name, namelen) == 0;
1702 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1703 #else
1704 return 1;
1706 #endif
1710 #ifdef HAVE_STAT
1711 /* Helper to look for __init__.py or __init__.py[co] in potential package */
1712 static int
1713 find_init_module(char *buf)
1715 const size_t save_len = strlen(buf);
1716 size_t i = save_len;
1717 char *pname; /* pointer to start of __init__ */
1718 struct stat statbuf;
1720 /* For calling case_ok(buf, len, namelen, name):
1721 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1722 * ^ ^ ^ ^
1723 * |--------------------- buf ---------------------|
1724 * |------------------- len ------------------|
1725 * |------ name -------|
1726 * |----- namelen -----|
1728 if (save_len + 13 >= MAXPATHLEN)
1729 return 0;
1730 buf[i++] = SEP;
1731 pname = buf + i;
1732 strcpy(pname, "__init__.py");
1733 if (stat(buf, &statbuf) == 0) {
1734 if (case_ok(buf,
1735 save_len + 9, /* len("/__init__") */
1736 8, /* len("__init__") */
1737 pname)) {
1738 buf[save_len] = '\0';
1739 return 1;
1742 i += strlen(pname);
1743 strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
1744 if (stat(buf, &statbuf) == 0) {
1745 if (case_ok(buf,
1746 save_len + 9, /* len("/__init__") */
1747 8, /* len("__init__") */
1748 pname)) {
1749 buf[save_len] = '\0';
1750 return 1;
1753 buf[save_len] = '\0';
1754 return 0;
1757 #else
1759 #ifdef RISCOS
1760 static int
1761 find_init_module(buf)
1762 char *buf;
1764 int save_len = strlen(buf);
1765 int i = save_len;
1767 if (save_len + 13 >= MAXPATHLEN)
1768 return 0;
1769 buf[i++] = SEP;
1770 strcpy(buf+i, "__init__/py");
1771 if (isfile(buf)) {
1772 buf[save_len] = '\0';
1773 return 1;
1776 if (Py_OptimizeFlag)
1777 strcpy(buf+i, "o");
1778 else
1779 strcpy(buf+i, "c");
1780 if (isfile(buf)) {
1781 buf[save_len] = '\0';
1782 return 1;
1784 buf[save_len] = '\0';
1785 return 0;
1787 #endif /*RISCOS*/
1789 #endif /* HAVE_STAT */
1792 static int init_builtin(char *); /* Forward */
1794 /* Load an external module using the default search path and return
1795 its module object WITH INCREMENTED REFERENCE COUNT */
1797 static PyObject *
1798 load_module(char *name, FILE *fp, char *pathname, int type, PyObject *loader)
1800 PyObject *modules;
1801 PyObject *m;
1802 int err;
1804 /* First check that there's an open file (if we need one) */
1805 switch (type) {
1806 case PY_SOURCE:
1807 case PY_COMPILED:
1808 if (fp == NULL) {
1809 PyErr_Format(PyExc_ValueError,
1810 "file object required for import (type code %d)",
1811 type);
1812 return NULL;
1816 switch (type) {
1818 case PY_SOURCE:
1819 m = load_source_module(name, pathname, fp);
1820 break;
1822 case PY_COMPILED:
1823 m = load_compiled_module(name, pathname, fp);
1824 break;
1826 #ifdef HAVE_DYNAMIC_LOADING
1827 case C_EXTENSION:
1828 m = _PyImport_LoadDynamicModule(name, pathname, fp);
1829 break;
1830 #endif
1832 case PKG_DIRECTORY:
1833 m = load_package(name, pathname);
1834 break;
1836 case C_BUILTIN:
1837 case PY_FROZEN:
1838 if (pathname != NULL && pathname[0] != '\0')
1839 name = pathname;
1840 if (type == C_BUILTIN)
1841 err = init_builtin(name);
1842 else
1843 err = PyImport_ImportFrozenModule(name);
1844 if (err < 0)
1845 return NULL;
1846 if (err == 0) {
1847 PyErr_Format(PyExc_ImportError,
1848 "Purported %s module %.200s not found",
1849 type == C_BUILTIN ?
1850 "builtin" : "frozen",
1851 name);
1852 return NULL;
1854 modules = PyImport_GetModuleDict();
1855 m = PyDict_GetItemString(modules, name);
1856 if (m == NULL) {
1857 PyErr_Format(
1858 PyExc_ImportError,
1859 "%s module %.200s not properly initialized",
1860 type == C_BUILTIN ?
1861 "builtin" : "frozen",
1862 name);
1863 return NULL;
1865 Py_INCREF(m);
1866 break;
1868 case IMP_HOOK: {
1869 if (loader == NULL) {
1870 PyErr_SetString(PyExc_ImportError,
1871 "import hook without loader");
1872 return NULL;
1874 m = PyObject_CallMethod(loader, "load_module", "s", name);
1875 break;
1878 default:
1879 PyErr_Format(PyExc_ImportError,
1880 "Don't know how to import %.200s (type code %d)",
1881 name, type);
1882 m = NULL;
1886 return m;
1890 /* Initialize a built-in module.
1891 Return 1 for success, 0 if the module is not found, and -1 with
1892 an exception set if the initialization failed. */
1894 static int
1895 init_builtin(char *name)
1897 struct _inittab *p;
1899 if (_PyImport_FindExtension(name, name) != NULL)
1900 return 1;
1902 for (p = PyImport_Inittab; p->name != NULL; p++) {
1903 if (strcmp(name, p->name) == 0) {
1904 if (p->initfunc == NULL) {
1905 PyErr_Format(PyExc_ImportError,
1906 "Cannot re-init internal module %.200s",
1907 name);
1908 return -1;
1910 if (Py_VerboseFlag)
1911 PySys_WriteStderr("import %s # builtin\n", name);
1912 (*p->initfunc)();
1913 if (PyErr_Occurred())
1914 return -1;
1915 if (_PyImport_FixupExtension(name, name) == NULL)
1916 return -1;
1917 return 1;
1920 return 0;
1924 /* Frozen modules */
1926 static struct _frozen *
1927 find_frozen(char *name)
1929 struct _frozen *p;
1931 for (p = PyImport_FrozenModules; ; p++) {
1932 if (p->name == NULL)
1933 return NULL;
1934 if (strcmp(p->name, name) == 0)
1935 break;
1937 return p;
1940 static PyObject *
1941 get_frozen_object(char *name)
1943 struct _frozen *p = find_frozen(name);
1944 int size;
1946 if (p == NULL) {
1947 PyErr_Format(PyExc_ImportError,
1948 "No such frozen object named %.200s",
1949 name);
1950 return NULL;
1952 if (p->code == NULL) {
1953 PyErr_Format(PyExc_ImportError,
1954 "Excluded frozen object named %.200s",
1955 name);
1956 return NULL;
1958 size = p->size;
1959 if (size < 0)
1960 size = -size;
1961 return PyMarshal_ReadObjectFromString((char *)p->code, size);
1964 /* Initialize a frozen module.
1965 Return 1 for succes, 0 if the module is not found, and -1 with
1966 an exception set if the initialization failed.
1967 This function is also used from frozenmain.c */
1970 PyImport_ImportFrozenModule(char *name)
1972 struct _frozen *p = find_frozen(name);
1973 PyObject *co;
1974 PyObject *m;
1975 int ispackage;
1976 int size;
1978 if (p == NULL)
1979 return 0;
1980 if (p->code == NULL) {
1981 PyErr_Format(PyExc_ImportError,
1982 "Excluded frozen object named %.200s",
1983 name);
1984 return -1;
1986 size = p->size;
1987 ispackage = (size < 0);
1988 if (ispackage)
1989 size = -size;
1990 if (Py_VerboseFlag)
1991 PySys_WriteStderr("import %s # frozen%s\n",
1992 name, ispackage ? " package" : "");
1993 co = PyMarshal_ReadObjectFromString((char *)p->code, size);
1994 if (co == NULL)
1995 return -1;
1996 if (!PyCode_Check(co)) {
1997 PyErr_Format(PyExc_TypeError,
1998 "frozen object %.200s is not a code object",
1999 name);
2000 goto err_return;
2002 if (ispackage) {
2003 /* Set __path__ to the package name */
2004 PyObject *d, *s;
2005 int err;
2006 m = PyImport_AddModule(name);
2007 if (m == NULL)
2008 goto err_return;
2009 d = PyModule_GetDict(m);
2010 s = PyString_InternFromString(name);
2011 if (s == NULL)
2012 goto err_return;
2013 err = PyDict_SetItemString(d, "__path__", s);
2014 Py_DECREF(s);
2015 if (err != 0)
2016 goto err_return;
2018 m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
2019 if (m == NULL)
2020 goto err_return;
2021 Py_DECREF(co);
2022 Py_DECREF(m);
2023 return 1;
2024 err_return:
2025 Py_DECREF(co);
2026 return -1;
2030 /* Import a module, either built-in, frozen, or external, and return
2031 its module object WITH INCREMENTED REFERENCE COUNT */
2033 PyObject *
2034 PyImport_ImportModule(const char *name)
2036 PyObject *pname;
2037 PyObject *result;
2039 pname = PyString_FromString(name);
2040 if (pname == NULL)
2041 return NULL;
2042 result = PyImport_Import(pname);
2043 Py_DECREF(pname);
2044 return result;
2047 /* Import a module without blocking
2049 * At first it tries to fetch the module from sys.modules. If the module was
2050 * never loaded before it loads it with PyImport_ImportModule() unless another
2051 * thread holds the import lock. In the latter case the function raises an
2052 * ImportError instead of blocking.
2054 * Returns the module object with incremented ref count.
2056 PyObject *
2057 PyImport_ImportModuleNoBlock(const char *name)
2059 PyObject *result;
2060 PyObject *modules;
2061 long me;
2063 /* Try to get the module from sys.modules[name] */
2064 modules = PyImport_GetModuleDict();
2065 if (modules == NULL)
2066 return NULL;
2068 result = PyDict_GetItemString(modules, name);
2069 if (result != NULL) {
2070 Py_INCREF(result);
2071 return result;
2073 else {
2074 PyErr_Clear();
2076 #ifdef WITH_THREAD
2077 /* check the import lock
2078 * me might be -1 but I ignore the error here, the lock function
2079 * takes care of the problem */
2080 me = PyThread_get_thread_ident();
2081 if (import_lock_thread == -1 || import_lock_thread == me) {
2082 /* no thread or me is holding the lock */
2083 return PyImport_ImportModule(name);
2085 else {
2086 PyErr_Format(PyExc_ImportError,
2087 "Failed to import %.200s because the import lock"
2088 "is held by another thread.",
2089 name);
2090 return NULL;
2092 #else
2093 return PyImport_ImportModule(name);
2094 #endif
2097 /* Forward declarations for helper routines */
2098 static PyObject *get_parent(PyObject *globals, char *buf,
2099 Py_ssize_t *p_buflen, int level);
2100 static PyObject *load_next(PyObject *mod, PyObject *altmod,
2101 char **p_name, char *buf, Py_ssize_t *p_buflen);
2102 static int mark_miss(char *name);
2103 static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
2104 char *buf, Py_ssize_t buflen, int recursive);
2105 static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
2107 /* The Magnum Opus of dotted-name import :-) */
2109 static PyObject *
2110 import_module_level(char *name, PyObject *globals, PyObject *locals,
2111 PyObject *fromlist, int level)
2113 char buf[MAXPATHLEN+1];
2114 Py_ssize_t buflen = 0;
2115 PyObject *parent, *head, *next, *tail;
2117 if (strchr(name, '/') != NULL
2118 #ifdef MS_WINDOWS
2119 || strchr(name, '\\') != NULL
2120 #endif
2122 PyErr_SetString(PyExc_ImportError,
2123 "Import by filename is not supported.");
2124 return NULL;
2127 parent = get_parent(globals, buf, &buflen, level);
2128 if (parent == NULL)
2129 return NULL;
2131 head = load_next(parent, Py_None, &name, buf, &buflen);
2132 if (head == NULL)
2133 return NULL;
2135 tail = head;
2136 Py_INCREF(tail);
2137 while (name) {
2138 next = load_next(tail, tail, &name, buf, &buflen);
2139 Py_DECREF(tail);
2140 if (next == NULL) {
2141 Py_DECREF(head);
2142 return NULL;
2144 tail = next;
2146 if (tail == Py_None) {
2147 /* If tail is Py_None, both get_parent and load_next found
2148 an empty module name: someone called __import__("") or
2149 doctored faulty bytecode */
2150 Py_DECREF(tail);
2151 Py_DECREF(head);
2152 PyErr_SetString(PyExc_ValueError,
2153 "Empty module name");
2154 return NULL;
2157 if (fromlist != NULL) {
2158 if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
2159 fromlist = NULL;
2162 if (fromlist == NULL) {
2163 Py_DECREF(tail);
2164 return head;
2167 Py_DECREF(head);
2168 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
2169 Py_DECREF(tail);
2170 return NULL;
2173 return tail;
2176 PyObject *
2177 PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
2178 PyObject *fromlist, int level)
2180 PyObject *result;
2181 _PyImport_AcquireLock();
2182 result = import_module_level(name, globals, locals, fromlist, level);
2183 if (_PyImport_ReleaseLock() < 0) {
2184 Py_XDECREF(result);
2185 PyErr_SetString(PyExc_RuntimeError,
2186 "not holding the import lock");
2187 return NULL;
2189 return result;
2192 /* Return the package that an import is being performed in. If globals comes
2193 from the module foo.bar.bat (not itself a package), this returns the
2194 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2195 the package's entry in sys.modules is returned, as a borrowed reference.
2197 The *name* of the returned package is returned in buf, with the length of
2198 the name in *p_buflen.
2200 If globals doesn't come from a package or a module in a package, or a
2201 corresponding entry is not found in sys.modules, Py_None is returned.
2203 static PyObject *
2204 get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
2206 static PyObject *namestr = NULL;
2207 static PyObject *pathstr = NULL;
2208 static PyObject *pkgstr = NULL;
2209 PyObject *pkgname, *modname, *modpath, *modules, *parent;
2210 int orig_level = level;
2212 if (globals == NULL || !PyDict_Check(globals) || !level)
2213 return Py_None;
2215 if (namestr == NULL) {
2216 namestr = PyString_InternFromString("__name__");
2217 if (namestr == NULL)
2218 return NULL;
2220 if (pathstr == NULL) {
2221 pathstr = PyString_InternFromString("__path__");
2222 if (pathstr == NULL)
2223 return NULL;
2225 if (pkgstr == NULL) {
2226 pkgstr = PyString_InternFromString("__package__");
2227 if (pkgstr == NULL)
2228 return NULL;
2231 *buf = '\0';
2232 *p_buflen = 0;
2233 pkgname = PyDict_GetItem(globals, pkgstr);
2235 if ((pkgname != NULL) && (pkgname != Py_None)) {
2236 /* __package__ is set, so use it */
2237 Py_ssize_t len;
2238 if (!PyString_Check(pkgname)) {
2239 PyErr_SetString(PyExc_ValueError,
2240 "__package__ set to non-string");
2241 return NULL;
2243 len = PyString_GET_SIZE(pkgname);
2244 if (len == 0) {
2245 if (level > 0) {
2246 PyErr_SetString(PyExc_ValueError,
2247 "Attempted relative import in non-package");
2248 return NULL;
2250 return Py_None;
2252 if (len > MAXPATHLEN) {
2253 PyErr_SetString(PyExc_ValueError,
2254 "Package name too long");
2255 return NULL;
2257 strcpy(buf, PyString_AS_STRING(pkgname));
2258 } else {
2259 /* __package__ not set, so figure it out and set it */
2260 modname = PyDict_GetItem(globals, namestr);
2261 if (modname == NULL || !PyString_Check(modname))
2262 return Py_None;
2264 modpath = PyDict_GetItem(globals, pathstr);
2265 if (modpath != NULL) {
2266 /* __path__ is set, so modname is already the package name */
2267 Py_ssize_t len = PyString_GET_SIZE(modname);
2268 int error;
2269 if (len > MAXPATHLEN) {
2270 PyErr_SetString(PyExc_ValueError,
2271 "Module name too long");
2272 return NULL;
2274 strcpy(buf, PyString_AS_STRING(modname));
2275 error = PyDict_SetItem(globals, pkgstr, modname);
2276 if (error) {
2277 PyErr_SetString(PyExc_ValueError,
2278 "Could not set __package__");
2279 return NULL;
2281 } else {
2282 /* Normal module, so work out the package name if any */
2283 char *start = PyString_AS_STRING(modname);
2284 char *lastdot = strrchr(start, '.');
2285 size_t len;
2286 int error;
2287 if (lastdot == NULL && level > 0) {
2288 PyErr_SetString(PyExc_ValueError,
2289 "Attempted relative import in non-package");
2290 return NULL;
2292 if (lastdot == NULL) {
2293 error = PyDict_SetItem(globals, pkgstr, Py_None);
2294 if (error) {
2295 PyErr_SetString(PyExc_ValueError,
2296 "Could not set __package__");
2297 return NULL;
2299 return Py_None;
2301 len = lastdot - start;
2302 if (len >= MAXPATHLEN) {
2303 PyErr_SetString(PyExc_ValueError,
2304 "Module name too long");
2305 return NULL;
2307 strncpy(buf, start, len);
2308 buf[len] = '\0';
2309 pkgname = PyString_FromString(buf);
2310 if (pkgname == NULL) {
2311 return NULL;
2313 error = PyDict_SetItem(globals, pkgstr, pkgname);
2314 Py_DECREF(pkgname);
2315 if (error) {
2316 PyErr_SetString(PyExc_ValueError,
2317 "Could not set __package__");
2318 return NULL;
2322 while (--level > 0) {
2323 char *dot = strrchr(buf, '.');
2324 if (dot == NULL) {
2325 PyErr_SetString(PyExc_ValueError,
2326 "Attempted relative import beyond "
2327 "toplevel package");
2328 return NULL;
2330 *dot = '\0';
2332 *p_buflen = strlen(buf);
2334 modules = PyImport_GetModuleDict();
2335 parent = PyDict_GetItemString(modules, buf);
2336 if (parent == NULL) {
2337 if (orig_level < 1) {
2338 PyObject *err_msg = PyString_FromFormat(
2339 "Parent module '%.200s' not found "
2340 "while handling absolute import", buf);
2341 if (err_msg == NULL) {
2342 return NULL;
2344 if (!PyErr_WarnEx(PyExc_RuntimeWarning,
2345 PyString_AsString(err_msg), 1)) {
2346 *buf = '\0';
2347 *p_buflen = 0;
2348 parent = Py_None;
2350 Py_DECREF(err_msg);
2351 } else {
2352 PyErr_Format(PyExc_SystemError,
2353 "Parent module '%.200s' not loaded, "
2354 "cannot perform relative import", buf);
2357 return parent;
2358 /* We expect, but can't guarantee, if parent != None, that:
2359 - parent.__name__ == buf
2360 - parent.__dict__ is globals
2361 If this is violated... Who cares? */
2364 /* altmod is either None or same as mod */
2365 static PyObject *
2366 load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
2367 Py_ssize_t *p_buflen)
2369 char *name = *p_name;
2370 char *dot = strchr(name, '.');
2371 size_t len;
2372 char *p;
2373 PyObject *result;
2375 if (strlen(name) == 0) {
2376 /* completely empty module name should only happen in
2377 'from . import' (or '__import__("")')*/
2378 Py_INCREF(mod);
2379 *p_name = NULL;
2380 return mod;
2383 if (dot == NULL) {
2384 *p_name = NULL;
2385 len = strlen(name);
2387 else {
2388 *p_name = dot+1;
2389 len = dot-name;
2391 if (len == 0) {
2392 PyErr_SetString(PyExc_ValueError,
2393 "Empty module name");
2394 return NULL;
2397 p = buf + *p_buflen;
2398 if (p != buf)
2399 *p++ = '.';
2400 if (p+len-buf >= MAXPATHLEN) {
2401 PyErr_SetString(PyExc_ValueError,
2402 "Module name too long");
2403 return NULL;
2405 strncpy(p, name, len);
2406 p[len] = '\0';
2407 *p_buflen = p+len-buf;
2409 result = import_submodule(mod, p, buf);
2410 if (result == Py_None && altmod != mod) {
2411 Py_DECREF(result);
2412 /* Here, altmod must be None and mod must not be None */
2413 result = import_submodule(altmod, p, p);
2414 if (result != NULL && result != Py_None) {
2415 if (mark_miss(buf) != 0) {
2416 Py_DECREF(result);
2417 return NULL;
2419 strncpy(buf, name, len);
2420 buf[len] = '\0';
2421 *p_buflen = len;
2424 if (result == NULL)
2425 return NULL;
2427 if (result == Py_None) {
2428 Py_DECREF(result);
2429 PyErr_Format(PyExc_ImportError,
2430 "No module named %.200s", name);
2431 return NULL;
2434 return result;
2437 static int
2438 mark_miss(char *name)
2440 PyObject *modules = PyImport_GetModuleDict();
2441 return PyDict_SetItemString(modules, name, Py_None);
2444 static int
2445 ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
2446 int recursive)
2448 int i;
2450 if (!PyObject_HasAttrString(mod, "__path__"))
2451 return 1;
2453 for (i = 0; ; i++) {
2454 PyObject *item = PySequence_GetItem(fromlist, i);
2455 int hasit;
2456 if (item == NULL) {
2457 if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2458 PyErr_Clear();
2459 return 1;
2461 return 0;
2463 if (!PyString_Check(item)) {
2464 PyErr_SetString(PyExc_TypeError,
2465 "Item in ``from list'' not a string");
2466 Py_DECREF(item);
2467 return 0;
2469 if (PyString_AS_STRING(item)[0] == '*') {
2470 PyObject *all;
2471 Py_DECREF(item);
2472 /* See if the package defines __all__ */
2473 if (recursive)
2474 continue; /* Avoid endless recursion */
2475 all = PyObject_GetAttrString(mod, "__all__");
2476 if (all == NULL)
2477 PyErr_Clear();
2478 else {
2479 int ret = ensure_fromlist(mod, all, buf, buflen, 1);
2480 Py_DECREF(all);
2481 if (!ret)
2482 return 0;
2484 continue;
2486 hasit = PyObject_HasAttr(mod, item);
2487 if (!hasit) {
2488 char *subname = PyString_AS_STRING(item);
2489 PyObject *submod;
2490 char *p;
2491 if (buflen + strlen(subname) >= MAXPATHLEN) {
2492 PyErr_SetString(PyExc_ValueError,
2493 "Module name too long");
2494 Py_DECREF(item);
2495 return 0;
2497 p = buf + buflen;
2498 *p++ = '.';
2499 strcpy(p, subname);
2500 submod = import_submodule(mod, subname, buf);
2501 Py_XDECREF(submod);
2502 if (submod == NULL) {
2503 Py_DECREF(item);
2504 return 0;
2507 Py_DECREF(item);
2510 /* NOTREACHED */
2513 static int
2514 add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
2515 PyObject *modules)
2517 if (mod == Py_None)
2518 return 1;
2519 /* Irrespective of the success of this load, make a
2520 reference to it in the parent package module. A copy gets
2521 saved in the modules dictionary under the full name, so get a
2522 reference from there, if need be. (The exception is when the
2523 load failed with a SyntaxError -- then there's no trace in
2524 sys.modules. In that case, of course, do nothing extra.) */
2525 if (submod == NULL) {
2526 submod = PyDict_GetItemString(modules, fullname);
2527 if (submod == NULL)
2528 return 1;
2530 if (PyModule_Check(mod)) {
2531 /* We can't use setattr here since it can give a
2532 * spurious warning if the submodule name shadows a
2533 * builtin name */
2534 PyObject *dict = PyModule_GetDict(mod);
2535 if (!dict)
2536 return 0;
2537 if (PyDict_SetItemString(dict, subname, submod) < 0)
2538 return 0;
2540 else {
2541 if (PyObject_SetAttrString(mod, subname, submod) < 0)
2542 return 0;
2544 return 1;
2547 static PyObject *
2548 import_submodule(PyObject *mod, char *subname, char *fullname)
2550 PyObject *modules = PyImport_GetModuleDict();
2551 PyObject *m = NULL;
2553 /* Require:
2554 if mod == None: subname == fullname
2555 else: mod.__name__ + "." + subname == fullname
2558 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
2559 Py_INCREF(m);
2561 else {
2562 PyObject *path, *loader = NULL;
2563 char buf[MAXPATHLEN+1];
2564 struct filedescr *fdp;
2565 FILE *fp = NULL;
2567 if (mod == Py_None)
2568 path = NULL;
2569 else {
2570 path = PyObject_GetAttrString(mod, "__path__");
2571 if (path == NULL) {
2572 PyErr_Clear();
2573 Py_INCREF(Py_None);
2574 return Py_None;
2578 buf[0] = '\0';
2579 fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
2580 &fp, &loader);
2581 Py_XDECREF(path);
2582 if (fdp == NULL) {
2583 if (!PyErr_ExceptionMatches(PyExc_ImportError))
2584 return NULL;
2585 PyErr_Clear();
2586 Py_INCREF(Py_None);
2587 return Py_None;
2589 m = load_module(fullname, fp, buf, fdp->type, loader);
2590 Py_XDECREF(loader);
2591 if (fp)
2592 fclose(fp);
2593 if (!add_submodule(mod, m, fullname, subname, modules)) {
2594 Py_XDECREF(m);
2595 m = NULL;
2599 return m;
2603 /* Re-import a module of any kind and return its module object, WITH
2604 INCREMENTED REFERENCE COUNT */
2606 PyObject *
2607 PyImport_ReloadModule(PyObject *m)
2609 PyInterpreterState *interp = PyThreadState_Get()->interp;
2610 PyObject *modules_reloading = interp->modules_reloading;
2611 PyObject *modules = PyImport_GetModuleDict();
2612 PyObject *path = NULL, *loader = NULL, *existing_m = NULL;
2613 char *name, *subname;
2614 char buf[MAXPATHLEN+1];
2615 struct filedescr *fdp;
2616 FILE *fp = NULL;
2617 PyObject *newm;
2619 if (modules_reloading == NULL) {
2620 Py_FatalError("PyImport_ReloadModule: "
2621 "no modules_reloading dictionary!");
2622 return NULL;
2625 if (m == NULL || !PyModule_Check(m)) {
2626 PyErr_SetString(PyExc_TypeError,
2627 "reload() argument must be module");
2628 return NULL;
2630 name = PyModule_GetName(m);
2631 if (name == NULL)
2632 return NULL;
2633 if (m != PyDict_GetItemString(modules, name)) {
2634 PyErr_Format(PyExc_ImportError,
2635 "reload(): module %.200s not in sys.modules",
2636 name);
2637 return NULL;
2639 existing_m = PyDict_GetItemString(modules_reloading, name);
2640 if (existing_m != NULL) {
2641 /* Due to a recursive reload, this module is already
2642 being reloaded. */
2643 Py_INCREF(existing_m);
2644 return existing_m;
2646 if (PyDict_SetItemString(modules_reloading, name, m) < 0)
2647 return NULL;
2649 subname = strrchr(name, '.');
2650 if (subname == NULL)
2651 subname = name;
2652 else {
2653 PyObject *parentname, *parent;
2654 parentname = PyString_FromStringAndSize(name, (subname-name));
2655 if (parentname == NULL) {
2656 imp_modules_reloading_clear();
2657 return NULL;
2659 parent = PyDict_GetItem(modules, parentname);
2660 if (parent == NULL) {
2661 PyErr_Format(PyExc_ImportError,
2662 "reload(): parent %.200s not in sys.modules",
2663 PyString_AS_STRING(parentname));
2664 Py_DECREF(parentname);
2665 imp_modules_reloading_clear();
2666 return NULL;
2668 Py_DECREF(parentname);
2669 subname++;
2670 path = PyObject_GetAttrString(parent, "__path__");
2671 if (path == NULL)
2672 PyErr_Clear();
2674 buf[0] = '\0';
2675 fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
2676 Py_XDECREF(path);
2678 if (fdp == NULL) {
2679 Py_XDECREF(loader);
2680 imp_modules_reloading_clear();
2681 return NULL;
2684 newm = load_module(name, fp, buf, fdp->type, loader);
2685 Py_XDECREF(loader);
2687 if (fp)
2688 fclose(fp);
2689 if (newm == NULL) {
2690 /* load_module probably removed name from modules because of
2691 * the error. Put back the original module object. We're
2692 * going to return NULL in this case regardless of whether
2693 * replacing name succeeds, so the return value is ignored.
2695 PyDict_SetItemString(modules, name, m);
2697 imp_modules_reloading_clear();
2698 return newm;
2702 /* Higher-level import emulator which emulates the "import" statement
2703 more accurately -- it invokes the __import__() function from the
2704 builtins of the current globals. This means that the import is
2705 done using whatever import hooks are installed in the current
2706 environment, e.g. by "rexec".
2707 A dummy list ["__doc__"] is passed as the 4th argument so that
2708 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2709 will return <module "gencache"> instead of <module "win32com">. */
2711 PyObject *
2712 PyImport_Import(PyObject *module_name)
2714 static PyObject *silly_list = NULL;
2715 static PyObject *builtins_str = NULL;
2716 static PyObject *import_str = NULL;
2717 PyObject *globals = NULL;
2718 PyObject *import = NULL;
2719 PyObject *builtins = NULL;
2720 PyObject *r = NULL;
2722 /* Initialize constant string objects */
2723 if (silly_list == NULL) {
2724 import_str = PyString_InternFromString("__import__");
2725 if (import_str == NULL)
2726 return NULL;
2727 builtins_str = PyString_InternFromString("__builtins__");
2728 if (builtins_str == NULL)
2729 return NULL;
2730 silly_list = Py_BuildValue("[s]", "__doc__");
2731 if (silly_list == NULL)
2732 return NULL;
2735 /* Get the builtins from current globals */
2736 globals = PyEval_GetGlobals();
2737 if (globals != NULL) {
2738 Py_INCREF(globals);
2739 builtins = PyObject_GetItem(globals, builtins_str);
2740 if (builtins == NULL)
2741 goto err;
2743 else {
2744 /* No globals -- use standard builtins, and fake globals */
2745 PyErr_Clear();
2747 builtins = PyImport_ImportModuleLevel("__builtin__",
2748 NULL, NULL, NULL, 0);
2749 if (builtins == NULL)
2750 return NULL;
2751 globals = Py_BuildValue("{OO}", builtins_str, builtins);
2752 if (globals == NULL)
2753 goto err;
2756 /* Get the __import__ function from the builtins */
2757 if (PyDict_Check(builtins)) {
2758 import = PyObject_GetItem(builtins, import_str);
2759 if (import == NULL)
2760 PyErr_SetObject(PyExc_KeyError, import_str);
2762 else
2763 import = PyObject_GetAttr(builtins, import_str);
2764 if (import == NULL)
2765 goto err;
2767 /* Call the __import__ function with the proper argument list
2768 * Always use absolute import here. */
2769 r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
2770 globals, silly_list, 0, NULL);
2772 err:
2773 Py_XDECREF(globals);
2774 Py_XDECREF(builtins);
2775 Py_XDECREF(import);
2777 return r;
2781 /* Module 'imp' provides Python access to the primitives used for
2782 importing modules.
2785 static PyObject *
2786 imp_get_magic(PyObject *self, PyObject *noargs)
2788 char buf[4];
2790 buf[0] = (char) ((pyc_magic >> 0) & 0xff);
2791 buf[1] = (char) ((pyc_magic >> 8) & 0xff);
2792 buf[2] = (char) ((pyc_magic >> 16) & 0xff);
2793 buf[3] = (char) ((pyc_magic >> 24) & 0xff);
2795 return PyString_FromStringAndSize(buf, 4);
2798 static PyObject *
2799 imp_get_suffixes(PyObject *self, PyObject *noargs)
2801 PyObject *list;
2802 struct filedescr *fdp;
2804 list = PyList_New(0);
2805 if (list == NULL)
2806 return NULL;
2807 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
2808 PyObject *item = Py_BuildValue("ssi",
2809 fdp->suffix, fdp->mode, fdp->type);
2810 if (item == NULL) {
2811 Py_DECREF(list);
2812 return NULL;
2814 if (PyList_Append(list, item) < 0) {
2815 Py_DECREF(list);
2816 Py_DECREF(item);
2817 return NULL;
2819 Py_DECREF(item);
2821 return list;
2824 static PyObject *
2825 call_find_module(char *name, PyObject *path)
2827 extern int fclose(FILE *);
2828 PyObject *fob, *ret;
2829 struct filedescr *fdp;
2830 char pathname[MAXPATHLEN+1];
2831 FILE *fp = NULL;
2833 pathname[0] = '\0';
2834 if (path == Py_None)
2835 path = NULL;
2836 fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
2837 if (fdp == NULL)
2838 return NULL;
2839 if (fp != NULL) {
2840 fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);
2841 if (fob == NULL) {
2842 fclose(fp);
2843 return NULL;
2846 else {
2847 fob = Py_None;
2848 Py_INCREF(fob);
2850 ret = Py_BuildValue("Os(ssi)",
2851 fob, pathname, fdp->suffix, fdp->mode, fdp->type);
2852 Py_DECREF(fob);
2853 return ret;
2856 static PyObject *
2857 imp_find_module(PyObject *self, PyObject *args)
2859 char *name;
2860 PyObject *path = NULL;
2861 if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))
2862 return NULL;
2863 return call_find_module(name, path);
2866 static PyObject *
2867 imp_init_builtin(PyObject *self, PyObject *args)
2869 char *name;
2870 int ret;
2871 PyObject *m;
2872 if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
2873 return NULL;
2874 ret = init_builtin(name);
2875 if (ret < 0)
2876 return NULL;
2877 if (ret == 0) {
2878 Py_INCREF(Py_None);
2879 return Py_None;
2881 m = PyImport_AddModule(name);
2882 Py_XINCREF(m);
2883 return m;
2886 static PyObject *
2887 imp_init_frozen(PyObject *self, PyObject *args)
2889 char *name;
2890 int ret;
2891 PyObject *m;
2892 if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
2893 return NULL;
2894 ret = PyImport_ImportFrozenModule(name);
2895 if (ret < 0)
2896 return NULL;
2897 if (ret == 0) {
2898 Py_INCREF(Py_None);
2899 return Py_None;
2901 m = PyImport_AddModule(name);
2902 Py_XINCREF(m);
2903 return m;
2906 static PyObject *
2907 imp_get_frozen_object(PyObject *self, PyObject *args)
2909 char *name;
2911 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
2912 return NULL;
2913 return get_frozen_object(name);
2916 static PyObject *
2917 imp_is_builtin(PyObject *self, PyObject *args)
2919 char *name;
2920 if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
2921 return NULL;
2922 return PyInt_FromLong(is_builtin(name));
2925 static PyObject *
2926 imp_is_frozen(PyObject *self, PyObject *args)
2928 char *name;
2929 struct _frozen *p;
2930 if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
2931 return NULL;
2932 p = find_frozen(name);
2933 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
2936 static FILE *
2937 get_file(char *pathname, PyObject *fob, char *mode)
2939 FILE *fp;
2940 if (fob == NULL) {
2941 if (mode[0] == 'U')
2942 mode = "r" PY_STDIOTEXTMODE;
2943 fp = fopen(pathname, mode);
2944 if (fp == NULL)
2945 PyErr_SetFromErrno(PyExc_IOError);
2947 else {
2948 fp = PyFile_AsFile(fob);
2949 if (fp == NULL)
2950 PyErr_SetString(PyExc_ValueError,
2951 "bad/closed file object");
2953 return fp;
2956 static PyObject *
2957 imp_load_compiled(PyObject *self, PyObject *args)
2959 char *name;
2960 char *pathname;
2961 PyObject *fob = NULL;
2962 PyObject *m;
2963 FILE *fp;
2964 if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,
2965 &PyFile_Type, &fob))
2966 return NULL;
2967 fp = get_file(pathname, fob, "rb");
2968 if (fp == NULL)
2969 return NULL;
2970 m = load_compiled_module(name, pathname, fp);
2971 if (fob == NULL)
2972 fclose(fp);
2973 return m;
2976 #ifdef HAVE_DYNAMIC_LOADING
2978 static PyObject *
2979 imp_load_dynamic(PyObject *self, PyObject *args)
2981 char *name;
2982 char *pathname;
2983 PyObject *fob = NULL;
2984 PyObject *m;
2985 FILE *fp = NULL;
2986 if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,
2987 &PyFile_Type, &fob))
2988 return NULL;
2989 if (fob) {
2990 fp = get_file(pathname, fob, "r");
2991 if (fp == NULL)
2992 return NULL;
2994 m = _PyImport_LoadDynamicModule(name, pathname, fp);
2995 return m;
2998 #endif /* HAVE_DYNAMIC_LOADING */
3000 static PyObject *
3001 imp_load_source(PyObject *self, PyObject *args)
3003 char *name;
3004 char *pathname;
3005 PyObject *fob = NULL;
3006 PyObject *m;
3007 FILE *fp;
3008 if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,
3009 &PyFile_Type, &fob))
3010 return NULL;
3011 fp = get_file(pathname, fob, "r");
3012 if (fp == NULL)
3013 return NULL;
3014 m = load_source_module(name, pathname, fp);
3015 if (fob == NULL)
3016 fclose(fp);
3017 return m;
3020 static PyObject *
3021 imp_load_module(PyObject *self, PyObject *args)
3023 char *name;
3024 PyObject *fob;
3025 char *pathname;
3026 char *suffix; /* Unused */
3027 char *mode;
3028 int type;
3029 FILE *fp;
3031 if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
3032 &name, &fob, &pathname,
3033 &suffix, &mode, &type))
3034 return NULL;
3035 if (*mode) {
3036 /* Mode must start with 'r' or 'U' and must not contain '+'.
3037 Implicit in this test is the assumption that the mode
3038 may contain other modifiers like 'b' or 't'. */
3040 if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
3041 PyErr_Format(PyExc_ValueError,
3042 "invalid file open mode %.200s", mode);
3043 return NULL;
3046 if (fob == Py_None)
3047 fp = NULL;
3048 else {
3049 if (!PyFile_Check(fob)) {
3050 PyErr_SetString(PyExc_ValueError,
3051 "load_module arg#2 should be a file or None");
3052 return NULL;
3054 fp = get_file(pathname, fob, mode);
3055 if (fp == NULL)
3056 return NULL;
3058 return load_module(name, fp, pathname, type, NULL);
3061 static PyObject *
3062 imp_load_package(PyObject *self, PyObject *args)
3064 char *name;
3065 char *pathname;
3066 if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
3067 return NULL;
3068 return load_package(name, pathname);
3071 static PyObject *
3072 imp_new_module(PyObject *self, PyObject *args)
3074 char *name;
3075 if (!PyArg_ParseTuple(args, "s:new_module", &name))
3076 return NULL;
3077 return PyModule_New(name);
3080 static PyObject *
3081 imp_reload(PyObject *self, PyObject *v)
3083 return PyImport_ReloadModule(v);
3087 /* Doc strings */
3089 PyDoc_STRVAR(doc_imp,
3090 "This module provides the components needed to build your own\n\
3091 __import__ function. Undocumented functions are obsolete.");
3093 PyDoc_STRVAR(doc_reload,
3094 "reload(module) -> module\n\
3096 Reload the module. The module must have been successfully imported before.");
3098 PyDoc_STRVAR(doc_find_module,
3099 "find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
3100 Search for a module. If path is omitted or None, search for a\n\
3101 built-in, frozen or special module and continue search in sys.path.\n\
3102 The module name cannot contain '.'; to search for a submodule of a\n\
3103 package, pass the submodule name and the package's __path__.");
3105 PyDoc_STRVAR(doc_load_module,
3106 "load_module(name, file, filename, (suffix, mode, type)) -> module\n\
3107 Load a module, given information returned by find_module().\n\
3108 The module name must include the full package name, if any.");
3110 PyDoc_STRVAR(doc_get_magic,
3111 "get_magic() -> string\n\
3112 Return the magic number for .pyc or .pyo files.");
3114 PyDoc_STRVAR(doc_get_suffixes,
3115 "get_suffixes() -> [(suffix, mode, type), ...]\n\
3116 Return a list of (suffix, mode, type) tuples describing the files\n\
3117 that find_module() looks for.");
3119 PyDoc_STRVAR(doc_new_module,
3120 "new_module(name) -> module\n\
3121 Create a new module. Do not enter it in sys.modules.\n\
3122 The module name must include the full package name, if any.");
3124 PyDoc_STRVAR(doc_lock_held,
3125 "lock_held() -> boolean\n\
3126 Return True if the import lock is currently held, else False.\n\
3127 On platforms without threads, return False.");
3129 PyDoc_STRVAR(doc_acquire_lock,
3130 "acquire_lock() -> None\n\
3131 Acquires the interpreter's import lock for the current thread.\n\
3132 This lock should be used by import hooks to ensure thread-safety\n\
3133 when importing modules.\n\
3134 On platforms without threads, this function does nothing.");
3136 PyDoc_STRVAR(doc_release_lock,
3137 "release_lock() -> None\n\
3138 Release the interpreter's import lock.\n\
3139 On platforms without threads, this function does nothing.");
3141 static PyMethodDef imp_methods[] = {
3142 {"reload", imp_reload, METH_O, doc_reload},
3143 {"find_module", imp_find_module, METH_VARARGS, doc_find_module},
3144 {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},
3145 {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},
3146 {"load_module", imp_load_module, METH_VARARGS, doc_load_module},
3147 {"new_module", imp_new_module, METH_VARARGS, doc_new_module},
3148 {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
3149 {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
3150 {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
3151 /* The rest are obsolete */
3152 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
3153 {"init_builtin", imp_init_builtin, METH_VARARGS},
3154 {"init_frozen", imp_init_frozen, METH_VARARGS},
3155 {"is_builtin", imp_is_builtin, METH_VARARGS},
3156 {"is_frozen", imp_is_frozen, METH_VARARGS},
3157 {"load_compiled", imp_load_compiled, METH_VARARGS},
3158 #ifdef HAVE_DYNAMIC_LOADING
3159 {"load_dynamic", imp_load_dynamic, METH_VARARGS},
3160 #endif
3161 {"load_package", imp_load_package, METH_VARARGS},
3162 {"load_source", imp_load_source, METH_VARARGS},
3163 {NULL, NULL} /* sentinel */
3166 static int
3167 setint(PyObject *d, char *name, int value)
3169 PyObject *v;
3170 int err;
3172 v = PyInt_FromLong((long)value);
3173 err = PyDict_SetItemString(d, name, v);
3174 Py_XDECREF(v);
3175 return err;
3178 typedef struct {
3179 PyObject_HEAD
3180 } NullImporter;
3182 static int
3183 NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
3185 char *path;
3186 Py_ssize_t pathlen;
3188 if (!_PyArg_NoKeywords("NullImporter()", kwds))
3189 return -1;
3191 if (!PyArg_ParseTuple(args, "s:NullImporter",
3192 &path))
3193 return -1;
3195 pathlen = strlen(path);
3196 if (pathlen == 0) {
3197 PyErr_SetString(PyExc_ImportError, "empty pathname");
3198 return -1;
3199 } else {
3200 #ifndef RISCOS
3201 #ifndef MS_WINDOWS
3202 struct stat statbuf;
3203 int rv;
3205 rv = stat(path, &statbuf);
3206 if (rv == 0) {
3207 /* it exists */
3208 if (S_ISDIR(statbuf.st_mode)) {
3209 /* it's a directory */
3210 PyErr_SetString(PyExc_ImportError,
3211 "existing directory");
3212 return -1;
3215 #else /* MS_WINDOWS */
3216 DWORD rv;
3217 /* see issue1293 and issue3677:
3218 * stat() on Windows doesn't recognise paths like
3219 * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
3221 rv = GetFileAttributesA(path);
3222 if (rv != INVALID_FILE_ATTRIBUTES) {
3223 /* it exists */
3224 if (rv & FILE_ATTRIBUTE_DIRECTORY) {
3225 /* it's a directory */
3226 PyErr_SetString(PyExc_ImportError,
3227 "existing directory");
3228 return -1;
3231 #endif
3232 #else /* RISCOS */
3233 if (object_exists(path)) {
3234 /* it exists */
3235 if (isdir(path)) {
3236 /* it's a directory */
3237 PyErr_SetString(PyExc_ImportError,
3238 "existing directory");
3239 return -1;
3242 #endif
3244 return 0;
3247 static PyObject *
3248 NullImporter_find_module(NullImporter *self, PyObject *args)
3250 Py_RETURN_NONE;
3253 static PyMethodDef NullImporter_methods[] = {
3254 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
3255 "Always return None"
3257 {NULL} /* Sentinel */
3261 PyTypeObject PyNullImporter_Type = {
3262 PyVarObject_HEAD_INIT(NULL, 0)
3263 "imp.NullImporter", /*tp_name*/
3264 sizeof(NullImporter), /*tp_basicsize*/
3265 0, /*tp_itemsize*/
3266 0, /*tp_dealloc*/
3267 0, /*tp_print*/
3268 0, /*tp_getattr*/
3269 0, /*tp_setattr*/
3270 0, /*tp_compare*/
3271 0, /*tp_repr*/
3272 0, /*tp_as_number*/
3273 0, /*tp_as_sequence*/
3274 0, /*tp_as_mapping*/
3275 0, /*tp_hash */
3276 0, /*tp_call*/
3277 0, /*tp_str*/
3278 0, /*tp_getattro*/
3279 0, /*tp_setattro*/
3280 0, /*tp_as_buffer*/
3281 Py_TPFLAGS_DEFAULT, /*tp_flags*/
3282 "Null importer object", /* tp_doc */
3283 0, /* tp_traverse */
3284 0, /* tp_clear */
3285 0, /* tp_richcompare */
3286 0, /* tp_weaklistoffset */
3287 0, /* tp_iter */
3288 0, /* tp_iternext */
3289 NullImporter_methods, /* tp_methods */
3290 0, /* tp_members */
3291 0, /* tp_getset */
3292 0, /* tp_base */
3293 0, /* tp_dict */
3294 0, /* tp_descr_get */
3295 0, /* tp_descr_set */
3296 0, /* tp_dictoffset */
3297 (initproc)NullImporter_init, /* tp_init */
3298 0, /* tp_alloc */
3299 PyType_GenericNew /* tp_new */
3303 PyMODINIT_FUNC
3304 initimp(void)
3306 PyObject *m, *d;
3308 if (PyType_Ready(&PyNullImporter_Type) < 0)
3309 goto failure;
3311 m = Py_InitModule4("imp", imp_methods, doc_imp,
3312 NULL, PYTHON_API_VERSION);
3313 if (m == NULL)
3314 goto failure;
3315 d = PyModule_GetDict(m);
3316 if (d == NULL)
3317 goto failure;
3319 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
3320 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
3321 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
3322 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
3323 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
3324 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
3325 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
3326 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
3327 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
3328 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
3330 Py_INCREF(&PyNullImporter_Type);
3331 PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
3332 failure:
3337 /* API for embedding applications that want to add their own entries
3338 to the table of built-in modules. This should normally be called
3339 *before* Py_Initialize(). When the table resize fails, -1 is
3340 returned and the existing table is unchanged.
3342 After a similar function by Just van Rossum. */
3345 PyImport_ExtendInittab(struct _inittab *newtab)
3347 static struct _inittab *our_copy = NULL;
3348 struct _inittab *p;
3349 int i, n;
3351 /* Count the number of entries in both tables */
3352 for (n = 0; newtab[n].name != NULL; n++)
3354 if (n == 0)
3355 return 0; /* Nothing to do */
3356 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3359 /* Allocate new memory for the combined table */
3360 p = our_copy;
3361 PyMem_RESIZE(p, struct _inittab, i+n+1);
3362 if (p == NULL)
3363 return -1;
3365 /* Copy the tables into the new memory */
3366 if (our_copy != PyImport_Inittab)
3367 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
3368 PyImport_Inittab = our_copy = p;
3369 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
3371 return 0;
3374 /* Shorthand to add a single entry given a name and a function */
3377 PyImport_AppendInittab(const char *name, void (*initfunc)(void))
3379 struct _inittab newtab[2];
3381 memset(newtab, '\0', sizeof newtab);
3383 newtab[0].name = (char *)name;
3384 newtab[0].initfunc = initfunc;
3386 return PyImport_ExtendInittab(newtab);
3389 #ifdef __cplusplus
3391 #endif