source: vendor/python/2.5/Python/import.c

Last change on this file was 3225, checked in by bird, 18 years ago

Python 2.5
File size: 76.5 KB
Line 
1
2/* Module definition and import implementation */
3
4#include "Python.h"
5
6#include "Python-ast.h"
7#include "pyarena.h"
8#include "pythonrun.h"
9#include "errcode.h"
10#include "marshal.h"
11#include "code.h"
12#include "compile.h"
13#include "eval.h"
14#include "osdefs.h"
15#include "importdl.h"
16
17#ifdef HAVE_FCNTL_H
18#include <fcntl.h>
19#endif
20#ifdef __cplusplus
21extern "C" {
22#endif
23
24extern time_t PyOS_GetLastModificationTime(char *, FILE *);
25 /* In getmtime.c */
26
27/* Magic word to reject .pyc files generated by other Python versions.
28 It should change for each incompatible change to the bytecode.
29
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.
33
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.
37
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
40 10.
41
42 Known values:
43 Python 1.5: 20121
44 Python 1.5.1: 20121
45 Python 1.5.2: 20121
46 Python 1.6: 50428
47 Python 2.0: 50823
48 Python 2.0.1: 50823
49 Python 2.1: 60202
50 Python 2.1.1: 60202
51 Python 2.1.2: 60202
52 Python 2.2: 60717
53 Python 2.3a0: 62011
54 Python 2.3a0: 62021
55 Python 2.3a0: 62011 (!)
56 Python 2.4a0: 62041
57 Python 2.4a3: 62051
58 Python 2.4b1: 62061
59 Python 2.5a0: 62071
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)
68.
69*/
70#define MAGIC (62131 | ((long)'\r'<<16) | ((long)'\n'<<24))
71
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. */
75static long pyc_magic = MAGIC;
76
77/* See _PyImport_FixupExtension() below */
78static PyObject *extensions = NULL;
79
80/* This table is defined in config.c: */
81extern struct _inittab _PyImport_Inittab[];
82
83struct _inittab *PyImport_Inittab = _PyImport_Inittab;
84
85/* these tables define the module suffixes that Python recognizes */
86struct filedescr * _PyImport_Filetab = NULL;
87
88#ifdef RISCOS
89static const struct filedescr _PyImport_StandardFiletab[] = {
90 {"/py", "U", PY_SOURCE},
91 {"/pyc", "rb", PY_COMPILED},
92 {0, 0}
93};
94#else
95static const struct filedescr _PyImport_StandardFiletab[] = {
96 {".py", "U", PY_SOURCE},
97#ifdef MS_WINDOWS
98 {".pyw", "U", PY_SOURCE},
99#endif
100 {".pyc", "rb", PY_COMPILED},
101 {0, 0}
102};
103#endif
104
105static PyTypeObject NullImporterType; /* Forward reference */
106
107/* Initialize things */
108
109void
110_PyImport_Init(void)
111{
112 const struct filedescr *scan;
113 struct filedescr *filetab;
114 int countD = 0;
115 int countS = 0;
116
117 /* prepare _PyImport_Filetab: copy entries from
118 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
119 */
120 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
121 ++countD;
122 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
123 ++countS;
124 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
125 if (filetab == NULL)
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;
132
133 _PyImport_Filetab = filetab;
134
135 if (Py_OptimizeFlag) {
136 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
137 for (; filetab->suffix != NULL; filetab++) {
138#ifndef RISCOS
139 if (strcmp(filetab->suffix, ".pyc") == 0)
140 filetab->suffix = ".pyo";
141#else
142 if (strcmp(filetab->suffix, "/pyc") == 0)
143 filetab->suffix = "/pyo";
144#endif
145 }
146 }
147
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;
153 }
154}
155
156void
157_PyImportHooks_Init(void)
158{
159 PyObject *v, *path_hooks = NULL, *zimpimport;
160 int err = 0;
161
162 /* adding sys.path_hooks and sys.path_importer_cache, setting up
163 zipimport */
164 if (PyType_Ready(&NullImporterType) < 0)
165 goto error;
166
167 if (Py_VerboseFlag)
168 PySys_WriteStderr("# installing zipimport hook\n");
169
170 v = PyList_New(0);
171 if (v == NULL)
172 goto error;
173 err = PySys_SetObject("meta_path", v);
174 Py_DECREF(v);
175 if (err)
176 goto error;
177 v = PyDict_New();
178 if (v == NULL)
179 goto error;
180 err = PySys_SetObject("path_importer_cache", v);
181 Py_DECREF(v);
182 if (err)
183 goto error;
184 path_hooks = PyList_New(0);
185 if (path_hooks == NULL)
186 goto error;
187 err = PySys_SetObject("path_hooks", path_hooks);
188 if (err) {
189 error:
190 PyErr_Print();
191 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
192 "path_importer_cache, or NullImporter failed"
193 );
194 }
195
196 zimpimport = PyImport_ImportModule("zipimport");
197 if (zimpimport == NULL) {
198 PyErr_Clear(); /* No zip import module -- okay */
199 if (Py_VerboseFlag)
200 PySys_WriteStderr("# can't import zipimport\n");
201 }
202 else {
203 PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
204 "zipimporter");
205 Py_DECREF(zimpimport);
206 if (zipimporter == NULL) {
207 PyErr_Clear(); /* No zipimporter object -- okay */
208 if (Py_VerboseFlag)
209 PySys_WriteStderr(
210 "# can't import zipimport.zipimporter\n");
211 }
212 else {
213 /* sys.path_hooks.append(zipimporter) */
214 err = PyList_Append(path_hooks, zipimporter);
215 Py_DECREF(zipimporter);
216 if (err)
217 goto error;
218 if (Py_VerboseFlag)
219 PySys_WriteStderr(
220 "# installed zipimport hook\n");
221 }
222 }
223 Py_DECREF(path_hooks);
224}
225
226void
227_PyImport_Fini(void)
228{
229 Py_XDECREF(extensions);
230 extensions = NULL;
231 PyMem_DEL(_PyImport_Filetab);
232 _PyImport_Filetab = NULL;
233}
234
235
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. */
239
240#ifdef WITH_THREAD
241
242#include "pythread.h"
243
244static PyThread_type_lock import_lock = 0;
245static long import_lock_thread = -1;
246static int import_lock_level = 0;
247
248static void
249lock_import(void)
250{
251 long me = PyThread_get_thread_ident();
252 if (me == -1)
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. */
258 }
259 if (import_lock_thread == me) {
260 import_lock_level++;
261 return;
262 }
263 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
264 {
265 PyThreadState *tstate = PyEval_SaveThread();
266 PyThread_acquire_lock(import_lock, 1);
267 PyEval_RestoreThread(tstate);
268 }
269 import_lock_thread = me;
270 import_lock_level = 1;
271}
272
273static int
274unlock_import(void)
275{
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)
280 return -1;
281 import_lock_level--;
282 if (import_lock_level == 0) {
283 import_lock_thread = -1;
284 PyThread_release_lock(import_lock);
285 }
286 return 1;
287}
288
289/* This function is called from PyOS_AfterFork to ensure that newly
290 created child processes do not share locks with the parent. */
291
292void
293_PyImport_ReInitLock(void)
294{
295#ifdef _AIX
296 if (import_lock != NULL)
297 import_lock = PyThread_allocate_lock();
298#endif
299}
300
301#else
302
303#define lock_import()
304#define unlock_import() 0
305
306#endif
307
308static PyObject *
309imp_lock_held(PyObject *self, PyObject *noargs)
310{
311#ifdef WITH_THREAD
312 return PyBool_FromLong(import_lock_thread != -1);
313#else
314 return PyBool_FromLong(0);
315#endif
316}
317
318static PyObject *
319imp_acquire_lock(PyObject *self, PyObject *noargs)
320{
321#ifdef WITH_THREAD
322 lock_import();
323#endif
324 Py_INCREF(Py_None);
325 return Py_None;
326}
327
328static PyObject *
329imp_release_lock(PyObject *self, PyObject *noargs)
330{
331#ifdef WITH_THREAD
332 if (unlock_import() < 0) {
333 PyErr_SetString(PyExc_RuntimeError,
334 "not holding the import lock");
335 return NULL;
336 }
337#endif
338 Py_INCREF(Py_None);
339 return Py_None;
340}
341
342/* Helper for sys */
343
344PyObject *
345PyImport_GetModuleDict(void)
346{
347 PyInterpreterState *interp = PyThreadState_GET()->interp;
348 if (interp->modules == NULL)
349 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
350 return interp->modules;
351}
352
353
354/* List of names to clear in sys */
355static 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",
360 NULL
361};
362
363static char* sys_files[] = {
364 "stdin", "__stdin__",
365 "stdout", "__stdout__",
366 "stderr", "__stderr__",
367 NULL
368};
369
370
371/* Un-initialize things, as good as we can */
372
373void
374PyImport_Cleanup(void)
375{
376 Py_ssize_t pos, ndone;
377 char *name;
378 PyObject *key, *value, *dict;
379 PyInterpreterState *interp = PyThreadState_GET()->interp;
380 PyObject *modules = interp->modules;
381
382 if (modules == NULL)
383 return; /* Already done */
384
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. */
390
391 value = PyDict_GetItemString(modules, "__builtin__");
392 if (value != NULL && PyModule_Check(value)) {
393 dict = PyModule_GetDict(value);
394 if (Py_VerboseFlag)
395 PySys_WriteStderr("# clear __builtin__._\n");
396 PyDict_SetItemString(dict, "_", Py_None);
397 }
398 value = PyDict_GetItemString(modules, "sys");
399 if (value != NULL && PyModule_Check(value)) {
400 char **p;
401 PyObject *v;
402 dict = PyModule_GetDict(value);
403 for (p = sys_deletes; *p != NULL; p++) {
404 if (Py_VerboseFlag)
405 PySys_WriteStderr("# clear sys.%s\n", *p);
406 PyDict_SetItemString(dict, *p, Py_None);
407 }
408 for (p = sys_files; *p != NULL; p+=2) {
409 if (Py_VerboseFlag)
410 PySys_WriteStderr("# restore sys.%s\n", *p);
411 v = PyDict_GetItemString(dict, *(p+1));
412 if (v == NULL)
413 v = Py_None;
414 PyDict_SetItemString(dict, *p, v);
415 }
416 }
417
418 /* First, delete __main__ */
419 value = PyDict_GetItemString(modules, "__main__");
420 if (value != NULL && PyModule_Check(value)) {
421 if (Py_VerboseFlag)
422 PySys_WriteStderr("# cleanup __main__\n");
423 _PyModule_Clear(value);
424 PyDict_SetItemString(modules, "__main__", Py_None);
425 }
426
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).
434
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
439 re-imported. */
440
441 /* Next, repeatedly delete modules with a reference count of
442 one (skipping __builtin__ and sys) and delete them */
443 do {
444 ndone = 0;
445 pos = 0;
446 while (PyDict_Next(modules, &pos, &key, &value)) {
447 if (value->ob_refcnt != 1)
448 continue;
449 if (PyString_Check(key) && PyModule_Check(value)) {
450 name = PyString_AS_STRING(key);
451 if (strcmp(name, "__builtin__") == 0)
452 continue;
453 if (strcmp(name, "sys") == 0)
454 continue;
455 if (Py_VerboseFlag)
456 PySys_WriteStderr(
457 "# cleanup[1] %s\n", name);
458 _PyModule_Clear(value);
459 PyDict_SetItem(modules, key, Py_None);
460 ndone++;
461 }
462 }
463 } while (ndone > 0);
464
465 /* Next, delete all modules (still skipping __builtin__ and sys) */
466 pos = 0;
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)
471 continue;
472 if (strcmp(name, "sys") == 0)
473 continue;
474 if (Py_VerboseFlag)
475 PySys_WriteStderr("# cleanup[2] %s\n", name);
476 _PyModule_Clear(value);
477 PyDict_SetItem(modules, key, Py_None);
478 }
479 }
480
481 /* Next, delete sys and __builtin__ (in that order) */
482 value = PyDict_GetItemString(modules, "sys");
483 if (value != NULL && PyModule_Check(value)) {
484 if (Py_VerboseFlag)
485 PySys_WriteStderr("# cleanup sys\n");
486 _PyModule_Clear(value);
487 PyDict_SetItemString(modules, "sys", Py_None);
488 }
489 value = PyDict_GetItemString(modules, "__builtin__");
490 if (value != NULL && PyModule_Check(value)) {
491 if (Py_VerboseFlag)
492 PySys_WriteStderr("# cleanup __builtin__\n");
493 _PyModule_Clear(value);
494 PyDict_SetItemString(modules, "__builtin__", Py_None);
495 }
496
497 /* Finally, clear and delete the modules directory */
498 PyDict_Clear(modules);
499 interp->modules = NULL;
500 Py_DECREF(modules);
501}
502
503
504/* Helper for pythonrun.c -- return magic number */
505
506long
507PyImport_GetMagicNumber(void)
508{
509 return pyc_magic;
510}
511
512
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(). */
522
523PyObject *
524_PyImport_FixupExtension(char *name, char *filename)
525{
526 PyObject *modules, *mod, *dict, *copy;
527 if (extensions == NULL) {
528 extensions = PyDict_New();
529 if (extensions == NULL)
530 return NULL;
531 }
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);
537 return NULL;
538 }
539 dict = PyModule_GetDict(mod);
540 if (dict == NULL)
541 return NULL;
542 copy = PyDict_Copy(dict);
543 if (copy == NULL)
544 return NULL;
545 PyDict_SetItemString(extensions, filename, copy);
546 Py_DECREF(copy);
547 return copy;
548}
549
550PyObject *
551_PyImport_FindExtension(char *name, char *filename)
552{
553 PyObject *dict, *mod, *mdict;
554 if (extensions == NULL)
555 return NULL;
556 dict = PyDict_GetItemString(extensions, filename);
557 if (dict == NULL)
558 return NULL;
559 mod = PyImport_AddModule(name);
560 if (mod == NULL)
561 return NULL;
562 mdict = PyModule_GetDict(mod);
563 if (mdict == NULL)
564 return NULL;
565 if (PyDict_Update(mdict, dict))
566 return NULL;
567 if (Py_VerboseFlag)
568 PySys_WriteStderr("import %s # previously loaded (%s)\n",
569 name, filename);
570 return mod;
571}
572
573
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
578 'NEW' REFERENCE! */
579
580PyObject *
581PyImport_AddModule(const char *name)
582{
583 PyObject *modules = PyImport_GetModuleDict();
584 PyObject *m;
585
586 if ((m = PyDict_GetItemString(modules, name)) != NULL &&
587 PyModule_Check(m))
588 return m;
589 m = PyModule_New(name);
590 if (m == NULL)
591 return NULL;
592 if (PyDict_SetItemString(modules, name, m) != 0) {
593 Py_DECREF(m);
594 return NULL;
595 }
596 Py_DECREF(m); /* Yes, it still exists, in modules! */
597
598 return m;
599}
600
601/* Remove name from sys.modules, if it's there. */
602static void
603_RemoveModule(const char *name)
604{
605 PyObject *modules = PyImport_GetModuleDict();
606 if (PyDict_GetItemString(modules, name) == NULL)
607 return;
608 if (PyDict_DelItemString(modules, name) < 0)
609 Py_FatalError("import: deleting existing key in"
610 "sys.modules failed");
611}
612
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
618 * example.
619 */
620PyObject *
621PyImport_ExecCodeModule(char *name, PyObject *co)
622{
623 return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
624}
625
626PyObject *
627PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
628{
629 PyObject *modules = PyImport_GetModuleDict();
630 PyObject *m, *d, *v;
631
632 m = PyImport_AddModule(name);
633 if (m == NULL)
634 return NULL;
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)
641 goto error;
642 }
643 /* Remember the filename as the __file__ attribute */
644 v = NULL;
645 if (pathname != NULL) {
646 v = PyString_FromString(pathname);
647 if (v == NULL)
648 PyErr_Clear();
649 }
650 if (v == NULL) {
651 v = ((PyCodeObject *)co)->co_filename;
652 Py_INCREF(v);
653 }
654 if (PyDict_SetItemString(d, "__file__", v) != 0)
655 PyErr_Clear(); /* Not important enough to report */
656 Py_DECREF(v);
657
658 v = PyEval_EvalCode((PyCodeObject *)co, d, d);
659 if (v == NULL)
660 goto error;
661 Py_DECREF(v);
662
663 if ((m = PyDict_GetItemString(modules, name)) == NULL) {
664 PyErr_Format(PyExc_ImportError,
665 "Loaded module %.200s not found in sys.modules",
666 name);
667 return NULL;
668 }
669
670 Py_INCREF(m);
671
672 return m;
673
674 error:
675 _RemoveModule(name);
676 return NULL;
677}
678
679
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. */
684
685static char *
686make_compiled_pathname(char *pathname, char *buf, size_t buflen)
687{
688 size_t len = strlen(pathname);
689 if (len+2 > buflen)
690 return NULL;
691
692#ifdef MS_WINDOWS
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 */
697#endif
698 memcpy(buf, pathname, len);
699 buf[len] = Py_OptimizeFlag ? 'o' : 'c';
700 buf[len+1] = '\0';
701
702 return buf;
703}
704
705
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. */
712
713static FILE *
714check_compiled_module(char *pathname, time_t mtime, char *cpathname)
715{
716 FILE *fp;
717 long magic;
718 long pyc_mtime;
719
720 fp = fopen(cpathname, "rb");
721 if (fp == NULL)
722 return NULL;
723 magic = PyMarshal_ReadLongFromFile(fp);
724 if (magic != pyc_magic) {
725 if (Py_VerboseFlag)
726 PySys_WriteStderr("# %s has bad magic\n", cpathname);
727 fclose(fp);
728 return NULL;
729 }
730 pyc_mtime = PyMarshal_ReadLongFromFile(fp);
731 if (pyc_mtime != mtime) {
732 if (Py_VerboseFlag)
733 PySys_WriteStderr("# %s has bad mtime\n", cpathname);
734 fclose(fp);
735 return NULL;
736 }
737 if (Py_VerboseFlag)
738 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
739 return fp;
740}
741
742
743/* Read a code object from a file and check it for validity */
744
745static PyCodeObject *
746read_compiled_module(char *cpathname, FILE *fp)
747{
748 PyObject *co;
749
750 co = PyMarshal_ReadLastObjectFromFile(fp);
751 if (co == NULL)
752 return NULL;
753 if (!PyCode_Check(co)) {
754 PyErr_Format(PyExc_ImportError,
755 "Non-code object in %.200s", cpathname);
756 Py_DECREF(co);
757 return NULL;
758 }
759 return (PyCodeObject *)co;
760}
761
762
763/* Load a module from a compiled file, execute it, and return its
764 module object WITH INCREMENTED REFERENCE COUNT */
765
766static PyObject *
767load_compiled_module(char *name, char *cpathname, FILE *fp)
768{
769 long magic;
770 PyCodeObject *co;
771 PyObject *m;
772
773 magic = PyMarshal_ReadLongFromFile(fp);
774 if (magic != pyc_magic) {
775 PyErr_Format(PyExc_ImportError,
776 "Bad magic number in %.200s", cpathname);
777 return NULL;
778 }
779 (void) PyMarshal_ReadLongFromFile(fp);
780 co = read_compiled_module(cpathname, fp);
781 if (co == NULL)
782 return NULL;
783 if (Py_VerboseFlag)
784 PySys_WriteStderr("import %s # precompiled from %s\n",
785 name, cpathname);
786 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
787 Py_DECREF(co);
788
789 return m;
790}
791
792/* Parse a source file and return the corresponding code object */
793
794static PyCodeObject *
795parse_source_module(const char *pathname, FILE *fp)
796{
797 PyCodeObject *co = NULL;
798 mod_ty mod;
799 PyArena *arena = PyArena_New();
800 if (arena == NULL)
801 return NULL;
802
803 mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, 0,
804 NULL, arena);
805 if (mod) {
806 co = PyAST_Compile(mod, pathname, NULL, arena);
807 }
808 PyArena_Free(arena);
809 return co;
810}
811
812
813/* Helper to open a bytecode file for writing in exclusive mode */
814
815static FILE *
816open_exclusive(char *filename)
817{
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.
824 */
825 int fd;
826 (void) unlink(filename);
827 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
828#ifdef O_BINARY
829 |O_BINARY /* necessary for Windows */
830#endif
831#ifdef __VMS
832 , 0666, "ctxt=bin", "shr=nil"
833#else
834 , 0666
835#endif
836 );
837 if (fd < 0)
838 return NULL;
839 return fdopen(fd, "wb");
840#else
841 /* Best we can do -- on Windows this can't happen anyway */
842 return fopen(filename, "wb");
843#endif
844}
845
846
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
850 remove the file. */
851
852static void
853write_compiled_module(PyCodeObject *co, char *cpathname, time_t mtime)
854{
855 FILE *fp;
856
857 fp = open_exclusive(cpathname);
858 if (fp == NULL) {
859 if (Py_VerboseFlag)
860 PySys_WriteStderr(
861 "# can't create %s\n", cpathname);
862 return;
863 }
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)) {
869 if (Py_VerboseFlag)
870 PySys_WriteStderr("# can't write %s\n", cpathname);
871 /* Don't keep partial file */
872 fclose(fp);
873 (void) unlink(cpathname);
874 return;
875 }
876 /* Now write the true mtime */
877 fseek(fp, 4L, 0);
878 assert(mtime < LONG_MAX);
879 PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
880 fflush(fp);
881 fclose(fp);
882 if (Py_VerboseFlag)
883 PySys_WriteStderr("# wrote %s\n", cpathname);
884}
885
886
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. */
890
891static PyObject *
892load_source_module(char *name, char *pathname, FILE *fp)
893{
894 time_t mtime;
895 FILE *fpc;
896 char buf[MAXPATHLEN+1];
897 char *cpathname;
898 PyCodeObject *co;
899 PyObject *m;
900
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'",
905 pathname);
906 return NULL;
907 }
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.
912 */
913 if (mtime >> 32) {
914 PyErr_SetString(PyExc_OverflowError,
915 "modification time overflows a 4 byte field");
916 return NULL;
917 }
918#endif
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);
924 fclose(fpc);
925 if (co == NULL)
926 return NULL;
927 if (Py_VerboseFlag)
928 PySys_WriteStderr("import %s # precompiled from %s\n",
929 name, cpathname);
930 pathname = cpathname;
931 }
932 else {
933 co = parse_source_module(pathname, fp);
934 if (co == NULL)
935 return NULL;
936 if (Py_VerboseFlag)
937 PySys_WriteStderr("import %s # from %s\n",
938 name, pathname);
939 if (cpathname)
940 write_compiled_module(co, cpathname, mtime);
941 }
942 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
943 Py_DECREF(co);
944
945 return m;
946}
947
948
949/* Forward */
950static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
951static struct filedescr *find_module(char *, char *, PyObject *,
952 char *, size_t, FILE **, PyObject **);
953static struct _frozen *find_frozen(char *name);
954
955/* Load a package and return its module object WITH INCREMENTED
956 REFERENCE COUNT */
957
958static PyObject *
959load_package(char *name, char *pathname)
960{
961 PyObject *m, *d;
962 PyObject *file = NULL;
963 PyObject *path = NULL;
964 int err;
965 char buf[MAXPATHLEN+1];
966 FILE *fp = NULL;
967 struct filedescr *fdp;
968
969 m = PyImport_AddModule(name);
970 if (m == NULL)
971 return NULL;
972 if (Py_VerboseFlag)
973 PySys_WriteStderr("import %s # directory %s\n",
974 name, pathname);
975 d = PyModule_GetDict(m);
976 file = PyString_FromString(pathname);
977 if (file == NULL)
978 goto error;
979 path = Py_BuildValue("[O]", file);
980 if (path == NULL)
981 goto error;
982 err = PyDict_SetItemString(d, "__file__", file);
983 if (err == 0)
984 err = PyDict_SetItemString(d, "__path__", path);
985 if (err != 0)
986 goto error;
987 buf[0] = '\0';
988 fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
989 if (fdp == NULL) {
990 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
991 PyErr_Clear();
992 Py_INCREF(m);
993 }
994 else
995 m = NULL;
996 goto cleanup;
997 }
998 m = load_module(name, fp, buf, fdp->type, NULL);
999 if (fp != NULL)
1000 fclose(fp);
1001 goto cleanup;
1002
1003 error:
1004 m = NULL;
1005 cleanup:
1006 Py_XDECREF(path);
1007 Py_XDECREF(file);
1008 return m;
1009}
1010
1011
1012/* Helper to test for built-in module */
1013
1014static int
1015is_builtin(char *name)
1016{
1017 int i;
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)
1021 return -1;
1022 else
1023 return 1;
1024 }
1025 }
1026 return 0;
1027}
1028
1029
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. */
1037
1038static PyObject *
1039get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
1040 PyObject *p)
1041{
1042 PyObject *importer;
1043 Py_ssize_t j, nhooks;
1044
1045 /* These conditions are the caller's responsibility: */
1046 assert(PyList_Check(path_hooks));
1047 assert(PyDict_Check(path_importer_cache));
1048
1049 nhooks = PyList_Size(path_hooks);
1050 if (nhooks < 0)
1051 return NULL; /* Shouldn't happen */
1052
1053 importer = PyDict_GetItem(path_importer_cache, p);
1054 if (importer != NULL)
1055 return importer;
1056
1057 /* set path_importer_cache[p] to None to avoid recursion */
1058 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1059 return NULL;
1060
1061 for (j = 0; j < nhooks; j++) {
1062 PyObject *hook = PyList_GetItem(path_hooks, j);
1063 if (hook == NULL)
1064 return NULL;
1065 importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
1066 if (importer != NULL)
1067 break;
1068
1069 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1070 return NULL;
1071 }
1072 PyErr_Clear();
1073 }
1074 if (importer == NULL) {
1075 importer = PyObject_CallFunctionObjArgs(
1076 (PyObject *)&NullImporterType, p, NULL
1077 );
1078 if (importer == NULL) {
1079 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1080 PyErr_Clear();
1081 return Py_None;
1082 }
1083 }
1084 }
1085 if (importer != NULL) {
1086 int err = PyDict_SetItem(path_importer_cache, p, importer);
1087 Py_DECREF(importer);
1088 if (err != 0)
1089 return NULL;
1090 }
1091 return importer;
1092}
1093
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. */
1097
1098#ifdef MS_COREDLL
1099extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
1100 char *, Py_ssize_t);
1101#endif
1102
1103static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
1104static int find_init_module(char *); /* Forward */
1105static struct filedescr importhookdescr = {"", "", IMP_HOOK};
1106
1107static struct filedescr *
1108find_module(char *fullname, char *subname, PyObject *path, char *buf,
1109 size_t buflen, FILE **p_fp, PyObject **p_loader)
1110{
1111 Py_ssize_t i, npath;
1112 size_t len, namelen;
1113 struct filedescr *fdp = NULL;
1114 char *filemode;
1115 FILE *fp = NULL;
1116 PyObject *path_hooks, *path_importer_cache;
1117#ifndef RISCOS
1118 struct stat statbuf;
1119#endif
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)
1125 size_t saved_len;
1126 size_t saved_namelen;
1127 char *saved_buf = NULL;
1128#endif
1129 if (p_loader != NULL)
1130 *p_loader = NULL;
1131
1132 if (strlen(subname) > MAXPATHLEN) {
1133 PyErr_SetString(PyExc_OverflowError,
1134 "module name is too long");
1135 return NULL;
1136 }
1137 strcpy(name, subname);
1138
1139 /* sys.meta_path import hook */
1140 if (p_loader != NULL) {
1141 PyObject *meta_path;
1142
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 "
1147 "import hooks");
1148 return NULL;
1149 }
1150 Py_INCREF(meta_path); /* zap guard */
1151 npath = PyList_Size(meta_path);
1152 for (i = 0; i < npath; i++) {
1153 PyObject *loader;
1154 PyObject *hook = PyList_GetItem(meta_path, i);
1155 loader = PyObject_CallMethod(hook, "find_module",
1156 "sO", fullname,
1157 path != NULL ?
1158 path : Py_None);
1159 if (loader == NULL) {
1160 Py_DECREF(meta_path);
1161 return NULL; /* true error */
1162 }
1163 if (loader != Py_None) {
1164 /* a loader was found */
1165 *p_loader = loader;
1166 Py_DECREF(meta_path);
1167 return &importhookdescr;
1168 }
1169 Py_DECREF(loader);
1170 }
1171 Py_DECREF(meta_path);
1172 }
1173
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");
1180 return NULL;
1181 }
1182 strcpy(buf, PyString_AsString(path));
1183 strcat(buf, ".");
1184 strcat(buf, name);
1185 strcpy(name, buf);
1186 if (find_frozen(name) != NULL) {
1187 strcpy(buf, name);
1188 return &fd_frozen;
1189 }
1190 PyErr_Format(PyExc_ImportError,
1191 "No frozen submodule named %.200s", name);
1192 return NULL;
1193 }
1194 if (path == NULL) {
1195 if (is_builtin(name)) {
1196 strcpy(buf, name);
1197 return &fd_builtin;
1198 }
1199 if ((find_frozen(name)) != NULL) {
1200 strcpy(buf, name);
1201 return &fd_frozen;
1202 }
1203
1204#ifdef MS_COREDLL
1205 fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
1206 if (fp != NULL) {
1207 *p_fp = fp;
1208 return fdp;
1209 }
1210#endif
1211 path = PySys_GetObject("path");
1212 }
1213 if (path == NULL || !PyList_Check(path)) {
1214 PyErr_SetString(PyExc_ImportError,
1215 "sys.path must be a list of directory names");
1216 return NULL;
1217 }
1218
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 "
1223 "import hooks");
1224 return NULL;
1225 }
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");
1231 return NULL;
1232 }
1233
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);
1239 if (!v)
1240 return NULL;
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);
1245 if (copy == NULL)
1246 return NULL;
1247 v = copy;
1248 }
1249 else
1250#endif
1251 if (!PyString_Check(v))
1252 continue;
1253 len = PyString_GET_SIZE(v);
1254 if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
1255 Py_XDECREF(copy);
1256 continue; /* Too long */
1257 }
1258 strcpy(buf, PyString_AS_STRING(v));
1259 if (strlen(buf) != len) {
1260 Py_XDECREF(copy);
1261 continue; /* v contains '\0' */
1262 }
1263
1264 /* sys.path_hooks import hook */
1265 if (p_loader != NULL) {
1266 PyObject *importer;
1267
1268 importer = get_path_importer(path_importer_cache,
1269 path_hooks, v);
1270 if (importer == NULL) {
1271 Py_XDECREF(copy);
1272 return NULL;
1273 }
1274 /* Note: importer is a borrowed reference */
1275 if (importer != Py_None) {
1276 PyObject *loader;
1277 loader = PyObject_CallMethod(importer,
1278 "find_module",
1279 "s", fullname);
1280 Py_XDECREF(copy);
1281 if (loader == NULL)
1282 return NULL; /* error */
1283 if (loader != Py_None) {
1284 /* a loader was found */
1285 *p_loader = loader;
1286 return &importhookdescr;
1287 }
1288 Py_DECREF(loader);
1289 continue;
1290 }
1291 }
1292 /* no hook was found, use builtin import */
1293
1294 if (len > 0 && buf[len-1] != SEP
1295#ifdef ALTSEP
1296 && buf[len-1] != ALTSEP
1297#endif
1298 )
1299 buf[len++] = SEP;
1300 strcpy(buf+len, name);
1301 len += namelen;
1302
1303 /* Check for package import (buf holds a directory name,
1304 and there's an __init__ module in that directory */
1305#ifdef HAVE_STAT
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 */
1310 Py_XDECREF(copy);
1311 return &fd_package;
1312 }
1313 else {
1314 char warnstr[MAXPATHLEN+80];
1315 sprintf(warnstr, "Not importing directory "
1316 "'%.*s': missing __init__.py",
1317 MAXPATHLEN, buf);
1318 if (PyErr_Warn(PyExc_ImportWarning,
1319 warnstr)) {
1320 Py_XDECREF(copy);
1321 return NULL;
1322 }
1323 }
1324 }
1325#else
1326 /* XXX How are you going to test for directories? */
1327#ifdef RISCOS
1328 if (isdir(buf) &&
1329 case_ok(buf, len, namelen, name)) {
1330 if (find_init_module(buf)) {
1331 Py_XDECREF(copy);
1332 return &fd_package;
1333 }
1334 else {
1335 char warnstr[MAXPATHLEN+80];
1336 sprintf(warnstr, "Not importing directory "
1337 "'%.*s': missing __init__.py",
1338 MAXPATHLEN, buf);
1339 if (PyErr_Warn(PyExc_ImportWarning,
1340 warnstr)) {
1341 Py_XDECREF(copy);
1342 return NULL;
1343 }
1344 }
1345#endif
1346#endif
1347#if defined(PYOS_OS2)
1348 /* take a snapshot of the module spec for restoration
1349 * after the 8 character DLL hackery
1350 */
1351 saved_buf = strdup(buf);
1352 saved_len = len;
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
1358 extension)
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
1362 */
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))
1369 break;
1370 else
1371 scan++;
1372 }
1373 if (scan->suffix != NULL) {
1374 /* yes, so truncate the name */
1375 namelen = 8;
1376 len -= strlen(subname) - namelen;
1377 buf[len] = '\0';
1378 }
1379 }
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);
1388 if (fp != NULL) {
1389 if (case_ok(buf, len, namelen, name))
1390 break;
1391 else { /* continue search */
1392 fclose(fp);
1393 fp = NULL;
1394 }
1395 }
1396#if defined(PYOS_OS2)
1397 /* restore the saved snapshot */
1398 strcpy(buf, saved_buf);
1399 len = saved_len;
1400 namelen = saved_namelen;
1401#endif
1402 }
1403#if defined(PYOS_OS2)
1404 /* don't need/want the module name snapshot anymore */
1405 if (saved_buf)
1406 {
1407 free(saved_buf);
1408 saved_buf = NULL;
1409 }
1410#endif
1411 Py_XDECREF(copy);
1412 if (fp != NULL)
1413 break;
1414 }
1415 if (fp == NULL) {
1416 PyErr_Format(PyExc_ImportError,
1417 "No module named %.200s", name);
1418 return NULL;
1419 }
1420 *p_fp = fp;
1421 return fdp;
1422}
1423
1424/* Helpers for main.c
1425 * Find the source file corresponding to a named module
1426 */
1427struct filedescr *
1428_PyImport_FindModule(const char *name, PyObject *path, char *buf,
1429 size_t buflen, FILE **p_fp, PyObject **p_loader)
1430{
1431 return find_module((char *) name, (char *) name, path,
1432 buf, buflen, p_fp, p_loader);
1433}
1434
1435PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)
1436{
1437 return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
1438}
1439
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
1443 * ^ ^ ^ ^
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.
1450 *
1451 * We've already done a successful stat() or fopen() on buf, so know that
1452 * there's some match, possibly case-insensitive.
1453 *
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
1456 * exists.
1457 *
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.
1462 */
1463
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().
1466 */
1467#if defined(MS_WINDOWS)
1468#include <windows.h>
1469
1470#elif defined(DJGPP)
1471#include <dir.h>
1472
1473#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1474#include <sys/types.h>
1475#include <dirent.h>
1476
1477#elif defined(PYOS_OS2)
1478#define INCL_DOS
1479#define INCL_DOSERRORS
1480#define INCL_NOPMAPI
1481#include <os2.h>
1482
1483#elif defined(RISCOS)
1484#include "oslib/osfscontrol.h"
1485#endif
1486
1487static int
1488case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
1489{
1490/* Pick a platform-specific implementation; the sequence of #if's here should
1491 * match the sequence just above.
1492 */
1493
1494/* MS_WINDOWS */
1495#if defined(MS_WINDOWS)
1496 WIN32_FIND_DATA data;
1497 HANDLE h;
1498
1499 if (Py_GETENV("PYTHONCASEOK") != NULL)
1500 return 1;
1501
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)",
1506 name, buf);
1507 return 0;
1508 }
1509 FindClose(h);
1510 return strncmp(data.cFileName, name, namelen) == 0;
1511
1512/* DJGPP */
1513#elif defined(DJGPP)
1514 struct ffblk ffblk;
1515 int done;
1516
1517 if (Py_GETENV("PYTHONCASEOK") != NULL)
1518 return 1;
1519
1520 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1521 if (done) {
1522 PyErr_Format(PyExc_NameError,
1523 "Can't find file for module %.100s\n(filename %.300s)",
1524 name, buf);
1525 return 0;
1526 }
1527 return strncmp(ffblk.ff_name, name, namelen) == 0;
1528
1529/* new-fangled macintosh (macosx) or Cygwin */
1530#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1531 DIR *dirp;
1532 struct dirent *dp;
1533 char dirname[MAXPATHLEN + 1];
1534 const int dirlen = len - namelen - 1; /* don't want trailing SEP */
1535
1536 if (Py_GETENV("PYTHONCASEOK") != NULL)
1537 return 1;
1538
1539 /* Copy the dir component into dirname; substitute "." if empty */
1540 if (dirlen <= 0) {
1541 dirname[0] = '.';
1542 dirname[1] = '\0';
1543 }
1544 else {
1545 assert(dirlen <= MAXPATHLEN);
1546 memcpy(dirname, buf, dirlen);
1547 dirname[dirlen] = '\0';
1548 }
1549 /* Open the directory and search the entries for an exact match. */
1550 dirp = opendir(dirname);
1551 if (dirp) {
1552 char *nameWithExt = buf + len - namelen;
1553 while ((dp = readdir(dirp)) != NULL) {
1554 const int thislen =
1555#ifdef _DIRENT_HAVE_D_NAMELEN
1556 dp->d_namlen;
1557#else
1558 strlen(dp->d_name);
1559#endif
1560 if (thislen >= namelen &&
1561 strcmp(dp->d_name, nameWithExt) == 0) {
1562 (void)closedir(dirp);
1563 return 1; /* Found */
1564 }
1565 }
1566 (void)closedir(dirp);
1567 }
1568 return 0 ; /* Not found */
1569
1570/* RISC OS */
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;
1575 int canonlen;
1576 os_error *e;
1577
1578 if (Py_GETENV("PYTHONCASEOK") != NULL)
1579 return 1;
1580
1581 /* workaround:
1582 append wildcard, otherwise case of filename wouldn't be touched */
1583 strcpy(buf2, buf);
1584 strcat(buf2, "*");
1585
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) )
1589 return 0;
1590 if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)
1591 return 1; /* match */
1592
1593 return 0;
1594
1595/* OS/2 */
1596#elif defined(PYOS_OS2)
1597 HDIR hdir = 1;
1598 ULONG srchcnt = 1;
1599 FILEFINDBUF3 ffbuf;
1600 APIRET rc;
1601
1602 if (getenv("PYTHONCASEOK") != NULL)
1603 return 1;
1604
1605 rc = DosFindFirst(buf,
1606 &hdir,
1607 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1608 &ffbuf, sizeof(ffbuf),
1609 &srchcnt,
1610 FIL_STANDARD);
1611 if (rc != NO_ERROR)
1612 return 0;
1613 return strncmp(ffbuf.achName, name, namelen) == 0;
1614
1615/* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1616#else
1617 return 1;
1618
1619#endif
1620}
1621
1622
1623#ifdef HAVE_STAT
1624/* Helper to look for __init__.py or __init__.py[co] in potential package */
1625static int
1626find_init_module(char *buf)
1627{
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;
1632
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
1635 * ^ ^ ^ ^
1636 * |--------------------- buf ---------------------|
1637 * |------------------- len ------------------|
1638 * |------ name -------|
1639 * |----- namelen -----|
1640 */
1641 if (save_len + 13 >= MAXPATHLEN)
1642 return 0;
1643 buf[i++] = SEP;
1644 pname = buf + i;
1645 strcpy(pname, "__init__.py");
1646 if (stat(buf, &statbuf) == 0) {
1647 if (case_ok(buf,
1648 save_len + 9, /* len("/__init__") */
1649 8, /* len("__init__") */
1650 pname)) {
1651 buf[save_len] = '\0';
1652 return 1;
1653 }
1654 }
1655 i += strlen(pname);
1656 strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
1657 if (stat(buf, &statbuf) == 0) {
1658 if (case_ok(buf,
1659 save_len + 9, /* len("/__init__") */
1660 8, /* len("__init__") */
1661 pname)) {
1662 buf[save_len] = '\0';
1663 return 1;
1664 }
1665 }
1666 buf[save_len] = '\0';
1667 return 0;
1668}
1669
1670#else
1671
1672#ifdef RISCOS
1673static int
1674find_init_module(buf)
1675 char *buf;
1676{
1677 int save_len = strlen(buf);
1678 int i = save_len;
1679
1680 if (save_len + 13 >= MAXPATHLEN)
1681 return 0;
1682 buf[i++] = SEP;
1683 strcpy(buf+i, "__init__/py");
1684 if (isfile(buf)) {
1685 buf[save_len] = '\0';
1686 return 1;
1687 }
1688
1689 if (Py_OptimizeFlag)
1690 strcpy(buf+i, "o");
1691 else
1692 strcpy(buf+i, "c");
1693 if (isfile(buf)) {
1694 buf[save_len] = '\0';
1695 return 1;
1696 }
1697 buf[save_len] = '\0';
1698 return 0;
1699}
1700#endif /*RISCOS*/
1701
1702#endif /* HAVE_STAT */
1703
1704
1705static int init_builtin(char *); /* Forward */
1706
1707/* Load an external module using the default search path and return
1708 its module object WITH INCREMENTED REFERENCE COUNT */
1709
1710static PyObject *
1711load_module(char *name, FILE *fp, char *buf, int type, PyObject *loader)
1712{
1713 PyObject *modules;
1714 PyObject *m;
1715 int err;
1716
1717 /* First check that there's an open file (if we need one) */
1718 switch (type) {
1719 case PY_SOURCE:
1720 case PY_COMPILED:
1721 if (fp == NULL) {
1722 PyErr_Format(PyExc_ValueError,
1723 "file object required for import (type code %d)",
1724 type);
1725 return NULL;
1726 }
1727 }
1728
1729 switch (type) {
1730
1731 case PY_SOURCE:
1732 m = load_source_module(name, buf, fp);
1733 break;
1734
1735 case PY_COMPILED:
1736 m = load_compiled_module(name, buf, fp);
1737 break;
1738
1739#ifdef HAVE_DYNAMIC_LOADING
1740 case C_EXTENSION:
1741 m = _PyImport_LoadDynamicModule(name, buf, fp);
1742 break;
1743#endif
1744
1745 case PKG_DIRECTORY:
1746 m = load_package(name, buf);
1747 break;
1748
1749 case C_BUILTIN:
1750 case PY_FROZEN:
1751 if (buf != NULL && buf[0] != '\0')
1752 name = buf;
1753 if (type == C_BUILTIN)
1754 err = init_builtin(name);
1755 else
1756 err = PyImport_ImportFrozenModule(name);
1757 if (err < 0)
1758 return NULL;
1759 if (err == 0) {
1760 PyErr_Format(PyExc_ImportError,
1761 "Purported %s module %.200s not found",
1762 type == C_BUILTIN ?
1763 "builtin" : "frozen",
1764 name);
1765 return NULL;
1766 }
1767 modules = PyImport_GetModuleDict();
1768 m = PyDict_GetItemString(modules, name);
1769 if (m == NULL) {
1770 PyErr_Format(
1771 PyExc_ImportError,
1772 "%s module %.200s not properly initialized",
1773 type == C_BUILTIN ?
1774 "builtin" : "frozen",
1775 name);
1776 return NULL;
1777 }
1778 Py_INCREF(m);
1779 break;
1780
1781 case IMP_HOOK: {
1782 if (loader == NULL) {
1783 PyErr_SetString(PyExc_ImportError,
1784 "import hook without loader");
1785 return NULL;
1786 }
1787 m = PyObject_CallMethod(loader, "load_module", "s", name);
1788 break;
1789 }
1790
1791 default:
1792 PyErr_Format(PyExc_ImportError,
1793 "Don't know how to import %.200s (type code %d)",
1794 name, type);
1795 m = NULL;
1796
1797 }
1798
1799 return m;
1800}
1801
1802
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. */
1806
1807static int
1808init_builtin(char *name)
1809{
1810 struct _inittab *p;
1811
1812 if (_PyImport_FindExtension(name, name) != NULL)
1813 return 1;
1814
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",
1820 name);
1821 return -1;
1822 }
1823 if (Py_VerboseFlag)
1824 PySys_WriteStderr("import %s # builtin\n", name);
1825 (*p->initfunc)();
1826 if (PyErr_Occurred())
1827 return -1;
1828 if (_PyImport_FixupExtension(name, name) == NULL)
1829 return -1;
1830 return 1;
1831 }
1832 }
1833 return 0;
1834}
1835
1836
1837/* Frozen modules */
1838
1839static struct _frozen *
1840find_frozen(char *name)
1841{
1842 struct _frozen *p;
1843
1844 for (p = PyImport_FrozenModules; ; p++) {
1845 if (p->name == NULL)
1846 return NULL;
1847 if (strcmp(p->name, name) == 0)
1848 break;
1849 }
1850 return p;
1851}
1852
1853static PyObject *
1854get_frozen_object(char *name)
1855{
1856 struct _frozen *p = find_frozen(name);
1857 int size;
1858
1859 if (p == NULL) {
1860 PyErr_Format(PyExc_ImportError,
1861 "No such frozen object named %.200s",
1862 name);
1863 return NULL;
1864 }
1865 if (p->code == NULL) {
1866 PyErr_Format(PyExc_ImportError,
1867 "Excluded frozen object named %.200s",
1868 name);
1869 return NULL;
1870 }
1871 size = p->size;
1872 if (size < 0)
1873 size = -size;
1874 return PyMarshal_ReadObjectFromString((char *)p->code, size);
1875}
1876
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 */
1881
1882int
1883PyImport_ImportFrozenModule(char *name)
1884{
1885 struct _frozen *p = find_frozen(name);
1886 PyObject *co;
1887 PyObject *m;
1888 int ispackage;
1889 int size;
1890
1891 if (p == NULL)
1892 return 0;
1893 if (p->code == NULL) {
1894 PyErr_Format(PyExc_ImportError,
1895 "Excluded frozen object named %.200s",
1896 name);
1897 return -1;
1898 }
1899 size = p->size;
1900 ispackage = (size < 0);
1901 if (ispackage)
1902 size = -size;
1903 if (Py_VerboseFlag)
1904 PySys_WriteStderr("import %s # frozen%s\n",
1905 name, ispackage ? " package" : "");
1906 co = PyMarshal_ReadObjectFromString((char *)p->code, size);
1907 if (co == NULL)
1908 return -1;
1909 if (!PyCode_Check(co)) {
1910 PyErr_Format(PyExc_TypeError,
1911 "frozen object %.200s is not a code object",
1912 name);
1913 goto err_return;
1914 }
1915 if (ispackage) {
1916 /* Set __path__ to the package name */
1917 PyObject *d, *s;
1918 int err;
1919 m = PyImport_AddModule(name);
1920 if (m == NULL)
1921 goto err_return;
1922 d = PyModule_GetDict(m);
1923 s = PyString_InternFromString(name);
1924 if (s == NULL)
1925 goto err_return;
1926 err = PyDict_SetItemString(d, "__path__", s);
1927 Py_DECREF(s);
1928 if (err != 0)
1929 goto err_return;
1930 }
1931 m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
1932 if (m == NULL)
1933 goto err_return;
1934 Py_DECREF(co);
1935 Py_DECREF(m);
1936 return 1;
1937err_return:
1938 Py_DECREF(co);
1939 return -1;
1940}
1941
1942
1943/* Import a module, either built-in, frozen, or external, and return
1944 its module object WITH INCREMENTED REFERENCE COUNT */
1945
1946PyObject *
1947PyImport_ImportModule(const char *name)
1948{
1949 PyObject *pname;
1950 PyObject *result;
1951
1952 pname = PyString_FromString(name);
1953 if (pname == NULL)
1954 return NULL;
1955 result = PyImport_Import(pname);
1956 Py_DECREF(pname);
1957 return result;
1958}
1959
1960/* Forward declarations for helper routines */
1961static PyObject *get_parent(PyObject *globals, char *buf,
1962 Py_ssize_t *p_buflen, int level);
1963static PyObject *load_next(PyObject *mod, PyObject *altmod,
1964 char **p_name, char *buf, Py_ssize_t *p_buflen);
1965static int mark_miss(char *name);
1966static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
1967 char *buf, Py_ssize_t buflen, int recursive);
1968static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
1969
1970/* The Magnum Opus of dotted-name import :-) */
1971
1972static PyObject *
1973import_module_level(char *name, PyObject *globals, PyObject *locals,
1974 PyObject *fromlist, int level)
1975{
1976 char buf[MAXPATHLEN+1];
1977 Py_ssize_t buflen = 0;
1978 PyObject *parent, *head, *next, *tail;
1979
1980 parent = get_parent(globals, buf, &buflen, level);
1981 if (parent == NULL)
1982 return NULL;
1983
1984 head = load_next(parent, Py_None, &name, buf, &buflen);
1985 if (head == NULL)
1986 return NULL;
1987
1988 tail = head;
1989 Py_INCREF(tail);
1990 while (name) {
1991 next = load_next(tail, tail, &name, buf, &buflen);
1992 Py_DECREF(tail);
1993 if (next == NULL) {
1994 Py_DECREF(head);
1995 return NULL;
1996 }
1997 tail = next;
1998 }
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 */
2003 Py_DECREF(tail);
2004 Py_DECREF(head);
2005 PyErr_SetString(PyExc_ValueError,
2006 "Empty module name");
2007 return NULL;
2008 }
2009
2010 if (fromlist != NULL) {
2011 if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
2012 fromlist = NULL;
2013 }
2014
2015 if (fromlist == NULL) {
2016 Py_DECREF(tail);
2017 return head;
2018 }
2019
2020 Py_DECREF(head);
2021 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
2022 Py_DECREF(tail);
2023 return NULL;
2024 }
2025
2026 return tail;
2027}
2028
2029/* For DLL compatibility */
2030#undef PyImport_ImportModuleEx
2031PyObject *
2032PyImport_ImportModuleEx(char *name, PyObject *globals, PyObject *locals,
2033 PyObject *fromlist)
2034{
2035 PyObject *result;
2036 lock_import();
2037 result = import_module_level(name, globals, locals, fromlist, -1);
2038 if (unlock_import() < 0) {
2039 Py_XDECREF(result);
2040 PyErr_SetString(PyExc_RuntimeError,
2041 "not holding the import lock");
2042 return NULL;
2043 }
2044 return result;
2045}
2046#define PyImport_ImportModuleEx(n, g, l, f) \
2047 PyImport_ImportModuleLevel(n, g, l, f, -1);
2048
2049PyObject *
2050PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
2051 PyObject *fromlist, int level)
2052{
2053 PyObject *result;
2054 lock_import();
2055 result = import_module_level(name, globals, locals, fromlist, level);
2056 if (unlock_import() < 0) {
2057 Py_XDECREF(result);
2058 PyErr_SetString(PyExc_RuntimeError,
2059 "not holding the import lock");
2060 return NULL;
2061 }
2062 return result;
2063}
2064
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.
2069
2070 The *name* of the returned package is returned in buf, with the length of
2071 the name in *p_buflen.
2072
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.
2075*/
2076static PyObject *
2077get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
2078{
2079 static PyObject *namestr = NULL;
2080 static PyObject *pathstr = NULL;
2081 PyObject *modname, *modpath, *modules, *parent;
2082
2083 if (globals == NULL || !PyDict_Check(globals) || !level)
2084 return Py_None;
2085
2086 if (namestr == NULL) {
2087 namestr = PyString_InternFromString("__name__");
2088 if (namestr == NULL)
2089 return NULL;
2090 }
2091 if (pathstr == NULL) {
2092 pathstr = PyString_InternFromString("__path__");
2093 if (pathstr == NULL)
2094 return NULL;
2095 }
2096
2097 *buf = '\0';
2098 *p_buflen = 0;
2099 modname = PyDict_GetItem(globals, namestr);
2100 if (modname == NULL || !PyString_Check(modname))
2101 return Py_None;
2102
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");
2109 return NULL;
2110 }
2111 strcpy(buf, PyString_AS_STRING(modname));
2112 }
2113 else {
2114 char *start = PyString_AS_STRING(modname);
2115 char *lastdot = strrchr(start, '.');
2116 size_t len;
2117 if (lastdot == NULL && level > 0) {
2118 PyErr_SetString(PyExc_ValueError,
2119 "Attempted relative import in non-package");
2120 return NULL;
2121 }
2122 if (lastdot == NULL)
2123 return Py_None;
2124 len = lastdot - start;
2125 if (len >= MAXPATHLEN) {
2126 PyErr_SetString(PyExc_ValueError,
2127 "Module name too long");
2128 return NULL;
2129 }
2130 strncpy(buf, start, len);
2131 buf[len] = '\0';
2132 }
2133
2134 while (--level > 0) {
2135 char *dot = strrchr(buf, '.');
2136 if (dot == NULL) {
2137 PyErr_SetString(PyExc_ValueError,
2138 "Attempted relative import beyond "
2139 "toplevel package");
2140 return NULL;
2141 }
2142 *dot = '\0';
2143 }
2144 *p_buflen = strlen(buf);
2145
2146 modules = PyImport_GetModuleDict();
2147 parent = PyDict_GetItemString(modules, buf);
2148 if (parent == NULL)
2149 PyErr_Format(PyExc_SystemError,
2150 "Parent module '%.200s' not loaded", buf);
2151 return parent;
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? */
2156}
2157
2158/* altmod is either None or same as mod */
2159static PyObject *
2160load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
2161 Py_ssize_t *p_buflen)
2162{
2163 char *name = *p_name;
2164 char *dot = strchr(name, '.');
2165 size_t len;
2166 char *p;
2167 PyObject *result;
2168
2169 if (strlen(name) == 0) {
2170 /* completely empty module name should only happen in
2171 'from . import' (or '__import__("")')*/
2172 Py_INCREF(mod);
2173 *p_name = NULL;
2174 return mod;
2175 }
2176
2177 if (dot == NULL) {
2178 *p_name = NULL;
2179 len = strlen(name);
2180 }
2181 else {
2182 *p_name = dot+1;
2183 len = dot-name;
2184 }
2185 if (len == 0) {
2186 PyErr_SetString(PyExc_ValueError,
2187 "Empty module name");
2188 return NULL;
2189 }
2190
2191 p = buf + *p_buflen;
2192 if (p != buf)
2193 *p++ = '.';
2194 if (p+len-buf >= MAXPATHLEN) {
2195 PyErr_SetString(PyExc_ValueError,
2196 "Module name too long");
2197 return NULL;
2198 }
2199 strncpy(p, name, len);
2200 p[len] = '\0';
2201 *p_buflen = p+len-buf;
2202
2203 result = import_submodule(mod, p, buf);
2204 if (result == Py_None && altmod != mod) {
2205 Py_DECREF(result);
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) {
2210 Py_DECREF(result);
2211 return NULL;
2212 }
2213 strncpy(buf, name, len);
2214 buf[len] = '\0';
2215 *p_buflen = len;
2216 }
2217 }
2218 if (result == NULL)
2219 return NULL;
2220
2221 if (result == Py_None) {
2222 Py_DECREF(result);
2223 PyErr_Format(PyExc_ImportError,
2224 "No module named %.200s", name);
2225 return NULL;
2226 }
2227
2228 return result;
2229}
2230
2231static int
2232mark_miss(char *name)
2233{
2234 PyObject *modules = PyImport_GetModuleDict();
2235 return PyDict_SetItemString(modules, name, Py_None);
2236}
2237
2238static int
2239ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
2240 int recursive)
2241{
2242 int i;
2243
2244 if (!PyObject_HasAttrString(mod, "__path__"))
2245 return 1;
2246
2247 for (i = 0; ; i++) {
2248 PyObject *item = PySequence_GetItem(fromlist, i);
2249 int hasit;
2250 if (item == NULL) {
2251 if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2252 PyErr_Clear();
2253 return 1;
2254 }
2255 return 0;
2256 }
2257 if (!PyString_Check(item)) {
2258 PyErr_SetString(PyExc_TypeError,
2259 "Item in ``from list'' not a string");
2260 Py_DECREF(item);
2261 return 0;
2262 }
2263 if (PyString_AS_STRING(item)[0] == '*') {
2264 PyObject *all;
2265 Py_DECREF(item);
2266 /* See if the package defines __all__ */
2267 if (recursive)
2268 continue; /* Avoid endless recursion */
2269 all = PyObject_GetAttrString(mod, "__all__");
2270 if (all == NULL)
2271 PyErr_Clear();
2272 else {
2273 int ret = ensure_fromlist(mod, all, buf, buflen, 1);
2274 Py_DECREF(all);
2275 if (!ret)
2276 return 0;
2277 }
2278 continue;
2279 }
2280 hasit = PyObject_HasAttr(mod, item);
2281 if (!hasit) {
2282 char *subname = PyString_AS_STRING(item);
2283 PyObject *submod;
2284 char *p;
2285 if (buflen + strlen(subname) >= MAXPATHLEN) {
2286 PyErr_SetString(PyExc_ValueError,
2287 "Module name too long");
2288 Py_DECREF(item);
2289 return 0;
2290 }
2291 p = buf + buflen;
2292 *p++ = '.';
2293 strcpy(p, subname);
2294 submod = import_submodule(mod, subname, buf);
2295 Py_XDECREF(submod);
2296 if (submod == NULL) {
2297 Py_DECREF(item);
2298 return 0;
2299 }
2300 }
2301 Py_DECREF(item);
2302 }
2303
2304 /* NOTREACHED */
2305}
2306
2307static int
2308add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
2309 PyObject *modules)
2310{
2311 if (mod == Py_None)
2312 return 1;
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);
2321 if (submod == NULL)
2322 return 1;
2323 }
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
2327 * builtin name */
2328 PyObject *dict = PyModule_GetDict(mod);
2329 if (!dict)
2330 return 0;
2331 if (PyDict_SetItemString(dict, subname, submod) < 0)
2332 return 0;
2333 }
2334 else {
2335 if (PyObject_SetAttrString(mod, subname, submod) < 0)
2336 return 0;
2337 }
2338 return 1;
2339}
2340
2341static PyObject *
2342import_submodule(PyObject *mod, char *subname, char *fullname)
2343{
2344 PyObject *modules = PyImport_GetModuleDict();
2345 PyObject *m = NULL;
2346
2347 /* Require:
2348 if mod == None: subname == fullname
2349 else: mod.__name__ + "." + subname == fullname
2350 */
2351
2352 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
2353 Py_INCREF(m);
2354 }
2355 else {
2356 PyObject *path, *loader = NULL;
2357 char buf[MAXPATHLEN+1];
2358 struct filedescr *fdp;
2359 FILE *fp = NULL;
2360
2361 if (mod == Py_None)
2362 path = NULL;
2363 else {
2364 path = PyObject_GetAttrString(mod, "__path__");
2365 if (path == NULL) {
2366 PyErr_Clear();
2367 Py_INCREF(Py_None);
2368 return Py_None;
2369 }
2370 }
2371
2372 buf[0] = '\0';
2373 fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
2374 &fp, &loader);
2375 Py_XDECREF(path);
2376 if (fdp == NULL) {
2377 if (!PyErr_ExceptionMatches(PyExc_ImportError))
2378 return NULL;
2379 PyErr_Clear();
2380 Py_INCREF(Py_None);
2381 return Py_None;
2382 }
2383 m = load_module(fullname, fp, buf, fdp->type, loader);
2384 Py_XDECREF(loader);
2385 if (fp)
2386 fclose(fp);
2387 if (!add_submodule(mod, m, fullname, subname, modules)) {
2388 Py_XDECREF(m);
2389 m = NULL;
2390 }
2391 }
2392
2393 return m;
2394}
2395
2396
2397/* Re-import a module of any kind and return its module object, WITH
2398 INCREMENTED REFERENCE COUNT */
2399
2400PyObject *
2401PyImport_ReloadModule(PyObject *m)
2402{
2403 PyObject *modules = PyImport_GetModuleDict();
2404 PyObject *path = NULL, *loader = NULL;
2405 char *name, *subname;
2406 char buf[MAXPATHLEN+1];
2407 struct filedescr *fdp;
2408 FILE *fp = NULL;
2409 PyObject *newm;
2410
2411 if (m == NULL || !PyModule_Check(m)) {
2412 PyErr_SetString(PyExc_TypeError,
2413 "reload() argument must be module");
2414 return NULL;
2415 }
2416 name = PyModule_GetName(m);
2417 if (name == NULL)
2418 return NULL;
2419 if (m != PyDict_GetItemString(modules, name)) {
2420 PyErr_Format(PyExc_ImportError,
2421 "reload(): module %.200s not in sys.modules",
2422 name);
2423 return NULL;
2424 }
2425 subname = strrchr(name, '.');
2426 if (subname == NULL)
2427 subname = name;
2428 else {
2429 PyObject *parentname, *parent;
2430 parentname = PyString_FromStringAndSize(name, (subname-name));
2431 if (parentname == NULL)
2432 return 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);
2439 return NULL;
2440 }
2441 Py_DECREF(parentname);
2442 subname++;
2443 path = PyObject_GetAttrString(parent, "__path__");
2444 if (path == NULL)
2445 PyErr_Clear();
2446 }
2447 buf[0] = '\0';
2448 fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
2449 Py_XDECREF(path);
2450
2451 if (fdp == NULL) {
2452 Py_XDECREF(loader);
2453 return NULL;
2454 }
2455
2456 newm = load_module(name, fp, buf, fdp->type, loader);
2457 Py_XDECREF(loader);
2458
2459 if (fp)
2460 fclose(fp);
2461 if (newm == NULL) {
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.
2466 */
2467 PyDict_SetItemString(modules, name, m);
2468 }
2469 return newm;
2470}
2471
2472
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">. */
2481
2482PyObject *
2483PyImport_Import(PyObject *module_name)
2484{
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;
2491 PyObject *r = NULL;
2492
2493 /* Initialize constant string objects */
2494 if (silly_list == NULL) {
2495 import_str = PyString_InternFromString("__import__");
2496 if (import_str == NULL)
2497 return NULL;
2498 builtins_str = PyString_InternFromString("__builtins__");
2499 if (builtins_str == NULL)
2500 return NULL;
2501 silly_list = Py_BuildValue("[s]", "__doc__");
2502 if (silly_list == NULL)
2503 return NULL;
2504 }
2505
2506 /* Get the builtins from current globals */
2507 globals = PyEval_GetGlobals();
2508 if (globals != NULL) {
2509 Py_INCREF(globals);
2510 builtins = PyObject_GetItem(globals, builtins_str);
2511 if (builtins == NULL)
2512 goto err;
2513 }
2514 else {
2515 /* No globals -- use standard builtins, and fake globals */
2516 PyErr_Clear();
2517
2518 builtins = PyImport_ImportModuleLevel("__builtin__",
2519 NULL, NULL, NULL, 0);
2520 if (builtins == NULL)
2521 return NULL;
2522 globals = Py_BuildValue("{OO}", builtins_str, builtins);
2523 if (globals == NULL)
2524 goto err;
2525 }
2526
2527 /* Get the __import__ function from the builtins */
2528 if (PyDict_Check(builtins)) {
2529 import = PyObject_GetItem(builtins, import_str);
2530 if (import == NULL)
2531 PyErr_SetObject(PyExc_KeyError, import_str);
2532 }
2533 else
2534 import = PyObject_GetAttr(builtins, import_str);
2535 if (import == NULL)
2536 goto err;
2537
2538 /* Call the _import__ function with the proper argument list */
2539 r = PyObject_CallFunctionObjArgs(import, module_name, globals,
2540 globals, silly_list, NULL);
2541
2542 err:
2543 Py_XDECREF(globals);
2544 Py_XDECREF(builtins);
2545 Py_XDECREF(import);
2546
2547 return r;
2548}
2549
2550
2551/* Module 'imp' provides Python access to the primitives used for
2552 importing modules.
2553*/
2554
2555static PyObject *
2556imp_get_magic(PyObject *self, PyObject *noargs)
2557{
2558 char buf[4];
2559
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);
2564
2565 return PyString_FromStringAndSize(buf, 4);
2566}
2567
2568static PyObject *
2569imp_get_suffixes(PyObject *self, PyObject *noargs)
2570{
2571 PyObject *list;
2572 struct filedescr *fdp;
2573
2574 list = PyList_New(0);
2575 if (list == NULL)
2576 return NULL;
2577 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
2578 PyObject *item = Py_BuildValue("ssi",
2579 fdp->suffix, fdp->mode, fdp->type);
2580 if (item == NULL) {
2581 Py_DECREF(list);
2582 return NULL;
2583 }
2584 if (PyList_Append(list, item) < 0) {
2585 Py_DECREF(list);
2586 Py_DECREF(item);
2587 return NULL;
2588 }
2589 Py_DECREF(item);
2590 }
2591 return list;
2592}
2593
2594static PyObject *
2595call_find_module(char *name, PyObject *path)
2596{
2597 extern int fclose(FILE *);
2598 PyObject *fob, *ret;
2599 struct filedescr *fdp;
2600 char pathname[MAXPATHLEN+1];
2601 FILE *fp = NULL;
2602
2603 pathname[0] = '\0';
2604 if (path == Py_None)
2605 path = NULL;
2606 fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
2607 if (fdp == NULL)
2608 return NULL;
2609 if (fp != NULL) {
2610 fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);
2611 if (fob == NULL) {
2612 fclose(fp);
2613 return NULL;
2614 }
2615 }
2616 else {
2617 fob = Py_None;
2618 Py_INCREF(fob);
2619 }
2620 ret = Py_BuildValue("Os(ssi)",
2621 fob, pathname, fdp->suffix, fdp->mode, fdp->type);
2622 Py_DECREF(fob);
2623 return ret;
2624}
2625
2626static PyObject *
2627imp_find_module(PyObject *self, PyObject *args)
2628{
2629 char *name;
2630 PyObject *path = NULL;
2631 if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))
2632 return NULL;
2633 return call_find_module(name, path);
2634}
2635
2636static PyObject *
2637imp_init_builtin(PyObject *self, PyObject *args)
2638{
2639 char *name;
2640 int ret;
2641 PyObject *m;
2642 if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
2643 return NULL;
2644 ret = init_builtin(name);
2645 if (ret < 0)
2646 return NULL;
2647 if (ret == 0) {
2648 Py_INCREF(Py_None);
2649 return Py_None;
2650 }
2651 m = PyImport_AddModule(name);
2652 Py_XINCREF(m);
2653 return m;
2654}
2655
2656static PyObject *
2657imp_init_frozen(PyObject *self, PyObject *args)
2658{
2659 char *name;
2660 int ret;
2661 PyObject *m;
2662 if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
2663 return NULL;
2664 ret = PyImport_ImportFrozenModule(name);
2665 if (ret < 0)
2666 return NULL;
2667 if (ret == 0) {
2668 Py_INCREF(Py_None);
2669 return Py_None;
2670 }
2671 m = PyImport_AddModule(name);
2672 Py_XINCREF(m);
2673 return m;
2674}
2675
2676static PyObject *
2677imp_get_frozen_object(PyObject *self, PyObject *args)
2678{
2679 char *name;
2680
2681 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
2682 return NULL;
2683 return get_frozen_object(name);
2684}
2685
2686static PyObject *
2687imp_is_builtin(PyObject *self, PyObject *args)
2688{
2689 char *name;
2690 if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
2691 return NULL;
2692 return PyInt_FromLong(is_builtin(name));
2693}
2694
2695static PyObject *
2696imp_is_frozen(PyObject *self, PyObject *args)
2697{
2698 char *name;
2699 struct _frozen *p;
2700 if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
2701 return NULL;
2702 p = find_frozen(name);
2703 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
2704}
2705
2706static FILE *
2707get_file(char *pathname, PyObject *fob, char *mode)
2708{
2709 FILE *fp;
2710 if (fob == NULL) {
2711 if (mode[0] == 'U')
2712 mode = "r" PY_STDIOTEXTMODE;
2713 fp = fopen(pathname, mode);
2714 if (fp == NULL)
2715 PyErr_SetFromErrno(PyExc_IOError);
2716 }
2717 else {
2718 fp = PyFile_AsFile(fob);
2719 if (fp == NULL)
2720 PyErr_SetString(PyExc_ValueError,
2721 "bad/closed file object");
2722 }
2723 return fp;
2724}
2725
2726static PyObject *
2727imp_load_compiled(PyObject *self, PyObject *args)
2728{
2729 char *name;
2730 char *pathname;
2731 PyObject *fob = NULL;
2732 PyObject *m;
2733 FILE *fp;
2734 if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,
2735 &PyFile_Type, &fob))
2736 return NULL;
2737 fp = get_file(pathname, fob, "rb");
2738 if (fp == NULL)
2739 return NULL;
2740 m = load_compiled_module(name, pathname, fp);
2741 if (fob == NULL)
2742 fclose(fp);
2743 return m;
2744}
2745
2746#ifdef HAVE_DYNAMIC_LOADING
2747
2748static PyObject *
2749imp_load_dynamic(PyObject *self, PyObject *args)
2750{
2751 char *name;
2752 char *pathname;
2753 PyObject *fob = NULL;
2754 PyObject *m;
2755 FILE *fp = NULL;
2756 if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,
2757 &PyFile_Type, &fob))
2758 return NULL;
2759 if (fob) {
2760 fp = get_file(pathname, fob, "r");
2761 if (fp == NULL)
2762 return NULL;
2763 }
2764 m = _PyImport_LoadDynamicModule(name, pathname, fp);
2765 return m;
2766}
2767
2768#endif /* HAVE_DYNAMIC_LOADING */
2769
2770static PyObject *
2771imp_load_source(PyObject *self, PyObject *args)
2772{
2773 char *name;
2774 char *pathname;
2775 PyObject *fob = NULL;
2776 PyObject *m;
2777 FILE *fp;
2778 if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,
2779 &PyFile_Type, &fob))
2780 return NULL;
2781 fp = get_file(pathname, fob, "r");
2782 if (fp == NULL)
2783 return NULL;
2784 m = load_source_module(name, pathname, fp);
2785 if (fob == NULL)
2786 fclose(fp);
2787 return m;
2788}
2789
2790static PyObject *
2791imp_load_module(PyObject *self, PyObject *args)
2792{
2793 char *name;
2794 PyObject *fob;
2795 char *pathname;
2796 char *suffix; /* Unused */
2797 char *mode;
2798 int type;
2799 FILE *fp;
2800
2801 if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
2802 &name, &fob, &pathname,
2803 &suffix, &mode, &type))
2804 return NULL;
2805 if (*mode) {
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'. */
2809
2810 if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
2811 PyErr_Format(PyExc_ValueError,
2812 "invalid file open mode %.200s", mode);
2813 return NULL;
2814 }
2815 }
2816 if (fob == Py_None)
2817 fp = NULL;
2818 else {
2819 if (!PyFile_Check(fob)) {
2820 PyErr_SetString(PyExc_ValueError,
2821 "load_module arg#2 should be a file or None");
2822 return NULL;
2823 }
2824 fp = get_file(pathname, fob, mode);
2825 if (fp == NULL)
2826 return NULL;
2827 }
2828 return load_module(name, fp, pathname, type, NULL);
2829}
2830
2831static PyObject *
2832imp_load_package(PyObject *self, PyObject *args)
2833{
2834 char *name;
2835 char *pathname;
2836 if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
2837 return NULL;
2838 return load_package(name, pathname);
2839}
2840
2841static PyObject *
2842imp_new_module(PyObject *self, PyObject *args)
2843{
2844 char *name;
2845 if (!PyArg_ParseTuple(args, "s:new_module", &name))
2846 return NULL;
2847 return PyModule_New(name);
2848}
2849
2850/* Doc strings */
2851
2852PyDoc_STRVAR(doc_imp,
2853"This module provides the components needed to build your own\n\
2854__import__ function. Undocumented functions are obsolete.");
2855
2856PyDoc_STRVAR(doc_find_module,
2857"find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
2858Search for a module. If path is omitted or None, search for a\n\
2859built-in, frozen or special module and continue search in sys.path.\n\
2860The module name cannot contain '.'; to search for a submodule of a\n\
2861package, pass the submodule name and the package's __path__.");
2862
2863PyDoc_STRVAR(doc_load_module,
2864"load_module(name, file, filename, (suffix, mode, type)) -> module\n\
2865Load a module, given information returned by find_module().\n\
2866The module name must include the full package name, if any.");
2867
2868PyDoc_STRVAR(doc_get_magic,
2869"get_magic() -> string\n\
2870Return the magic number for .pyc or .pyo files.");
2871
2872PyDoc_STRVAR(doc_get_suffixes,
2873"get_suffixes() -> [(suffix, mode, type), ...]\n\
2874Return a list of (suffix, mode, type) tuples describing the files\n\
2875that find_module() looks for.");
2876
2877PyDoc_STRVAR(doc_new_module,
2878"new_module(name) -> module\n\
2879Create a new module. Do not enter it in sys.modules.\n\
2880The module name must include the full package name, if any.");
2881
2882PyDoc_STRVAR(doc_lock_held,
2883"lock_held() -> boolean\n\
2884Return True if the import lock is currently held, else False.\n\
2885On platforms without threads, return False.");
2886
2887PyDoc_STRVAR(doc_acquire_lock,
2888"acquire_lock() -> None\n\
2889Acquires the interpreter's import lock for the current thread.\n\
2890This lock should be used by import hooks to ensure thread-safety\n\
2891when importing modules.\n\
2892On platforms without threads, this function does nothing.");
2893
2894PyDoc_STRVAR(doc_release_lock,
2895"release_lock() -> None\n\
2896Release the interpreter's import lock.\n\
2897On platforms without threads, this function does nothing.");
2898
2899static 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},
2917#endif
2918 {"load_package", imp_load_package, METH_VARARGS},
2919 {"load_source", imp_load_source, METH_VARARGS},
2920 {NULL, NULL} /* sentinel */
2921};
2922
2923static int
2924setint(PyObject *d, char *name, int value)
2925{
2926 PyObject *v;
2927 int err;
2928
2929 v = PyInt_FromLong((long)value);
2930 err = PyDict_SetItemString(d, name, v);
2931 Py_XDECREF(v);
2932 return err;
2933}
2934
2935typedef struct {
2936 PyObject_HEAD
2937} NullImporter;
2938
2939static int
2940NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
2941{
2942 char *path;
2943
2944 if (!_PyArg_NoKeywords("NullImporter()", kwds))
2945 return -1;
2946
2947 if (!PyArg_ParseTuple(args, "s:NullImporter",
2948 &path))
2949 return -1;
2950
2951 if (strlen(path) == 0) {
2952 PyErr_SetString(PyExc_ImportError, "empty pathname");
2953 return -1;
2954 } else {
2955#ifndef RISCOS
2956 struct stat statbuf;
2957 int rv;
2958
2959 rv = stat(path, &statbuf);
2960 if (rv == 0) {
2961 /* it exists */
2962 if (S_ISDIR(statbuf.st_mode)) {
2963 /* it's a directory */
2964 PyErr_SetString(PyExc_ImportError,
2965 "existing directory");
2966 return -1;
2967 }
2968 }
2969#else
2970 if (object_exists(path)) {
2971 /* it exists */
2972 if (isdir(path)) {
2973 /* it's a directory */
2974 PyErr_SetString(PyExc_ImportError,
2975 "existing directory");
2976 return -1;
2977 }
2978 }
2979#endif
2980 }
2981 return 0;
2982}
2983
2984static PyObject *
2985NullImporter_find_module(NullImporter *self, PyObject *args)
2986{
2987 Py_RETURN_NONE;
2988}
2989
2990static PyMethodDef NullImporter_methods[] = {
2991 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
2992 "Always return None"
2993 },
2994 {NULL} /* Sentinel */
2995};
2996
2997
2998static PyTypeObject NullImporterType = {
2999 PyObject_HEAD_INIT(NULL)
3000 0, /*ob_size*/
3001 "imp.NullImporter", /*tp_name*/
3002 sizeof(NullImporter), /*tp_basicsize*/
3003 0, /*tp_itemsize*/
3004 0, /*tp_dealloc*/
3005 0, /*tp_print*/
3006 0, /*tp_getattr*/
3007 0, /*tp_setattr*/
3008 0, /*tp_compare*/
3009 0, /*tp_repr*/
3010 0, /*tp_as_number*/
3011 0, /*tp_as_sequence*/
3012 0, /*tp_as_mapping*/
3013 0, /*tp_hash */
3014 0, /*tp_call*/
3015 0, /*tp_str*/
3016 0, /*tp_getattro*/
3017 0, /*tp_setattro*/
3018 0, /*tp_as_buffer*/
3019 Py_TPFLAGS_DEFAULT, /*tp_flags*/
3020 "Null importer object", /* tp_doc */
3021 0, /* tp_traverse */
3022 0, /* tp_clear */
3023 0, /* tp_richcompare */
3024 0, /* tp_weaklistoffset */
3025 0, /* tp_iter */
3026 0, /* tp_iternext */
3027 NullImporter_methods, /* tp_methods */
3028 0, /* tp_members */
3029 0, /* tp_getset */
3030 0, /* tp_base */
3031 0, /* tp_dict */
3032 0, /* tp_descr_get */
3033 0, /* tp_descr_set */
3034 0, /* tp_dictoffset */
3035 (initproc)NullImporter_init, /* tp_init */
3036 0, /* tp_alloc */
3037 PyType_GenericNew /* tp_new */
3038};
3039
3040
3041PyMODINIT_FUNC
3042initimp(void)
3043{
3044 PyObject *m, *d;
3045
3046 if (PyType_Ready(&NullImporterType) < 0)
3047 goto failure;
3048
3049 m = Py_InitModule4("imp", imp_methods, doc_imp,
3050 NULL, PYTHON_API_VERSION);
3051 if (m == NULL)
3052 goto failure;
3053 d = PyModule_GetDict(m);
3054 if (d == NULL)
3055 goto failure;
3056
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;
3067
3068 Py_INCREF(&NullImporterType);
3069 PyModule_AddObject(m, "NullImporter", (PyObject *)&NullImporterType);
3070 failure:
3071 ;
3072}
3073
3074
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.
3079
3080 After a similar function by Just van Rossum. */
3081
3082int
3083PyImport_ExtendInittab(struct _inittab *newtab)
3084{
3085 static struct _inittab *our_copy = NULL;
3086 struct _inittab *p;
3087 int i, n;
3088
3089 /* Count the number of entries in both tables */
3090 for (n = 0; newtab[n].name != NULL; n++)
3091 ;
3092 if (n == 0)
3093 return 0; /* Nothing to do */
3094 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3095 ;
3096
3097 /* Allocate new memory for the combined table */
3098 p = our_copy;
3099 PyMem_RESIZE(p, struct _inittab, i+n+1);
3100 if (p == NULL)
3101 return -1;
3102
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));
3108
3109 return 0;
3110}
3111
3112/* Shorthand to add a single entry given a name and a function */
3113
3114int
3115PyImport_AppendInittab(char *name, void (*initfunc)(void))
3116{
3117 struct _inittab newtab[2];
3118
3119 memset(newtab, '\0', sizeof newtab);
3120
3121 newtab[0].name = name;
3122 newtab[0].initfunc = initfunc;
3123
3124 return PyImport_ExtendInittab(newtab);
3125}
3126
3127#ifdef __cplusplus
3128}
3129#endif
Note: See TracBrowser for help on using the repository browser.