?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated to reflect change in logging.config to remove out-of-date comment in _install...
[python.git] / Python / import.c
blobb65ed0e86afac150956a7d952c1e0d555ecba686
1
2 /* Module definition and import implementation */
3
4 #include "Python.h"
5
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"
17
18 #ifdef HAVE_FCNTL_H
19 #include <fcntl.h>
20 #endif
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 #ifdef MS_WINDOWS
26 /* for stat.st_mode */
27 typedef unsigned short mode_t;
28 #endif
29
30 extern time_t PyOS_GetLastModificationTime(char *, FILE *);
31 /* In getmtime.c */
32
33 /* Magic word to reject .pyc files generated by other Python versions.
34 It should change for each incompatible change to the bytecode.
35
36 The value of CR and LF is incorporated so if you ever read or write
37 a .pyc file in text mode the magic number will be wrong; also, the
38 Apple MPW compiler swaps their values, botching string constants.
39
40 The magic numbers must be spaced apart atleast 2 values, as the
41 -U interpeter flag will cause MAGIC+1 being used. They have been
42 odd numbers for some time now.
43
44 There were a variety of old schemes for setting the magic number.
45 The current working scheme is to increment the previous value by
46 10.
47
48 Known values:
49 Python 1.5: 20121
50 Python 1.5.1: 20121
51 Python 1.5.2: 20121
52 Python 1.6: 50428
53 Python 2.0: 50823
54 Python 2.0.1: 50823
55 Python 2.1: 60202
56 Python 2.1.1: 60202
57 Python 2.1.2: 60202
58 Python 2.2: 60717
59 Python 2.3a0: 62011
60 Python 2.3a0: 62021
61 Python 2.3a0: 62011 (!)
62 Python 2.4a0: 62041
63 Python 2.4a3: 62051
64 Python 2.4b1: 62061
65 Python 2.5a0: 62071
66 Python 2.5a0: 62081 (ast-branch)
67 Python 2.5a0: 62091 (with)
68 Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)
69 Python 2.5b3: 62101 (fix wrong code: for x, in ...)
70 Python 2.5b3: 62111 (fix wrong code: x += yield)
71 Python 2.5c1: 62121 (fix wrong lnotab with for loops and
72 storing constants that should have been removed)
73 Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)
74 Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode)
75 Python 2.6a1: 62161 (WITH_CLEANUP optimization)
76 .
77 */
78 #define MAGIC (62161 | ((long)'\r'<<16) | ((long)'\n'<<24))
79
80 /* Magic word as global; note that _PyImport_Init() can change the
81 value of this global to accommodate for alterations of how the
82 compiler works which are enabled by command line switches. */
83 static long pyc_magic = MAGIC;
84
85 /* See _PyImport_FixupExtension() below */
86 static PyObject *extensions = NULL;
87
88 /* This table is defined in config.c: */
89 extern struct _inittab _PyImport_Inittab[];
90
91 struct _inittab *PyImport_Inittab = _PyImport_Inittab;
92
93 /* these tables define the module suffixes that Python recognizes */
94 struct filedescr * _PyImport_Filetab = NULL;
95
96 #ifdef RISCOS
97 static const struct filedescr _PyImport_StandardFiletab[] = {
98 {"/py", "U", PY_SOURCE},
99 {"/pyc", "rb", PY_COMPILED},
100 {0, 0}
101 };
102 #else
103 static const struct filedescr _PyImport_StandardFiletab[] = {
104 {".py", "U", PY_SOURCE},
105 #ifdef MS_WINDOWS
106 {".pyw", "U", PY_SOURCE},
107 #endif
108 {".pyc", "rb", PY_COMPILED},
109 {0, 0}
110 };
111 #endif
112
113
114 /* Initialize things */
115
116 void
117 _PyImport_Init(void)
118 {
119 const struct filedescr *scan;
120 struct filedescr *filetab;
121 int countD = 0;
122 int countS = 0;
123
124 /* prepare _PyImport_Filetab: copy entries from
125 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
126 */
127 #ifdef HAVE_DYNAMIC_LOADING
128 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
129 ++countD;
130 #endif
131 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
132 ++countS;
133 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
134 if (filetab == NULL)
135 Py_FatalError("Can't initialize import file table.");
136 #ifdef HAVE_DYNAMIC_LOADING
137 memcpy(filetab, _PyImport_DynLoadFiletab,
138 countD * sizeof(struct filedescr));
139 #endif
140 memcpy(filetab + countD, _PyImport_StandardFiletab,
141 countS * sizeof(struct filedescr));
142 filetab[countD + countS].suffix = NULL;
143
144 _PyImport_Filetab = filetab;
145
146 if (Py_OptimizeFlag) {
147 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
148 for (; filetab->suffix != NULL; filetab++) {
149 #ifndef RISCOS
150 if (strcmp(filetab->suffix, ".pyc") == 0)
151 filetab->suffix = ".pyo";
152 #else
153 if (strcmp(filetab->suffix, "/pyc") == 0)
154 filetab->suffix = "/pyo";
155 #endif
156 }
157 }
158
159 if (Py_UnicodeFlag) {
160 /* Fix the pyc_magic so that byte compiled code created
161 using the all-Unicode method doesn't interfere with
162 code created in normal operation mode. */
163 pyc_magic = MAGIC + 1;
164 }
165 }
166
167 void
168 _PyImportHooks_Init(void)
169 {
170 PyObject *v, *path_hooks = NULL, *zimpimport;
171 int err = 0;
172
173 /* adding sys.path_hooks and sys.path_importer_cache, setting up
174 zipimport */
175 if (PyType_Ready(&PyNullImporter_Type) < 0)
176 goto error;
177
178 if (Py_VerboseFlag)
179 PySys_WriteStderr("# installing zipimport hook\n");
180
181 v = PyList_New(0);
182 if (v == NULL)
183 goto error;
184 err = PySys_SetObject("meta_path", v);
185 Py_DECREF(v);
186 if (err)
187 goto error;
188 v = PyDict_New();
189 if (v == NULL)
190 goto error;
191 err = PySys_SetObject("path_importer_cache", v);
192 Py_DECREF(v);
193 if (err)
194 goto error;
195 path_hooks = PyList_New(0);
196 if (path_hooks == NULL)
197 goto error;
198 err = PySys_SetObject("path_hooks", path_hooks);
199 if (err) {
200 error:
201 PyErr_Print();
202 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
203 "path_importer_cache, or NullImporter failed"
204 );
205 }
206
207 zimpimport = PyImport_ImportModule("zipimport");
208 if (zimpimport == NULL) {
209 PyErr_Clear(); /* No zip import module -- okay */
210 if (Py_VerboseFlag)
211 PySys_WriteStderr("# can't import zipimport\n");
212 }
213 else {
214 PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
215 "zipimporter");
216 Py_DECREF(zimpimport);
217 if (zipimporter == NULL) {
218 PyErr_Clear(); /* No zipimporter object -- okay */
219 if (Py_VerboseFlag)
220 PySys_WriteStderr(
221 "# can't import zipimport.zipimporter\n");
222 }
223 else {
224 /* sys.path_hooks.append(zipimporter) */
225 err = PyList_Append(path_hooks, zipimporter);
226 Py_DECREF(zipimporter);
227 if (err)
228 goto error;
229 if (Py_VerboseFlag)
230 PySys_WriteStderr(
231 "# installed zipimport hook\n");
232 }
233 }
234 Py_DECREF(path_hooks);
235 }
236
237 void
238 _PyImport_Fini(void)
239 {
240 Py_XDECREF(extensions);
241 extensions = NULL;
242 PyMem_DEL(_PyImport_Filetab);
243 _PyImport_Filetab = NULL;
244 }
245
246
247 /* Locking primitives to prevent parallel imports of the same module
248 in different threads to return with a partially loaded module.
249 These calls are serialized by the global interpreter lock. */
250
251 #ifdef WITH_THREAD
252
253 #include "pythread.h"
254
255 static PyThread_type_lock import_lock = 0;
256 static long import_lock_thread = -1;
257 static int import_lock_level = 0;
258
259 static void
260 lock_import(void)
261 {
262 long me = PyThread_get_thread_ident();
263 if (me == -1)
264 return; /* Too bad */
265 if (import_lock == NULL) {
266 import_lock = PyThread_allocate_lock();
267 if (import_lock == NULL)
268 return; /* Nothing much we can do. */
269 }
270 if (import_lock_thread == me) {
271 import_lock_level++;
272 return;
273 }
274 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
275 {
276 PyThreadState *tstate = PyEval_SaveThread();
277 PyThread_acquire_lock(import_lock, 1);
278 PyEval_RestoreThread(tstate);
279 }
280 import_lock_thread = me;
281 import_lock_level = 1;
282 }
283
284 static int
285 unlock_import(void)
286 {
287 long me = PyThread_get_thread_ident();
288 if (me == -1 || import_lock == NULL)
289 return 0; /* Too bad */
290 if (import_lock_thread != me)
291 return -1;
292 import_lock_level--;
293 if (import_lock_level == 0) {
294 import_lock_thread = -1;
295 PyThread_release_lock(import_lock);
296 }
297 return 1;
298 }
299
300 /* This function is called from PyOS_AfterFork to ensure that newly
301 created child processes do not share locks with the parent. */
302
303 void
304 _PyImport_ReInitLock(void)
305 {
306 #ifdef _AIX
307 if (import_lock != NULL)
308 import_lock = PyThread_allocate_lock();
309 #endif
310 }
311
312 #else
313
314 #define lock_import()
315 #define unlock_import() 0
316
317 #endif
318
319 static PyObject *
320 imp_lock_held(PyObject *self, PyObject *noargs)
321 {
322 #ifdef WITH_THREAD
323 return PyBool_FromLong(import_lock_thread != -1);
324 #else
325 return PyBool_FromLong(0);
326 #endif
327 }
328
329 static PyObject *
330 imp_acquire_lock(PyObject *self, PyObject *noargs)
331 {
332 #ifdef WITH_THREAD
333 lock_import();
334 #endif
335 Py_INCREF(Py_None);
336 return Py_None;
337 }
338
339 static PyObject *
340 imp_release_lock(PyObject *self, PyObject *noargs)
341 {
342 #ifdef WITH_THREAD
343 if (unlock_import() < 0) {
344 PyErr_SetString(PyExc_RuntimeError,
345 "not holding the import lock");
346 return NULL;
347 }
348 #endif
349 Py_INCREF(Py_None);
350 return Py_None;
351 }
352
353 static void
354 imp_modules_reloading_clear(void)
355 {
356 PyInterpreterState *interp = PyThreadState_Get()->interp;
357 if (interp->modules_reloading != NULL)
358 PyDict_Clear(interp->modules_reloading);
359 }
360
361 /* Helper for sys */
362
363 PyObject *
364 PyImport_GetModuleDict(void)
365 {
366 PyInterpreterState *interp = PyThreadState_GET()->interp;
367 if (interp->modules == NULL)
368 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
369 return interp->modules;
370 }
371
372
373 /* List of names to clear in sys */
374 static char* sys_deletes[] = {
375 "path", "argv", "ps1", "ps2", "exitfunc",
376 "exc_type", "exc_value", "exc_traceback",
377 "last_type", "last_value", "last_traceback",
378 "path_hooks", "path_importer_cache", "meta_path",
379 /* misc stuff */
380 "flags", "float_info",
381 NULL
382 };
383
384 static char* sys_files[] = {
385 "stdin", "__stdin__",
386 "stdout", "__stdout__",
387 "stderr", "__stderr__",
388 NULL
389 };
390
391
392 /* Un-initialize things, as good as we can */
393
394 void
395 PyImport_Cleanup(void)
396 {
397 Py_ssize_t pos, ndone;
398 char *name;
399 PyObject *key, *value, *dict;
400 PyInterpreterState *interp = PyThreadState_GET()->interp;
401 PyObject *modules = interp->modules;
402
403 if (modules == NULL)
404 return; /* Already done */
405
406 /* Delete some special variables first. These are common
407 places where user values hide and people complain when their
408 destructors fail. Since the modules containing them are
409 deleted *last* of all, they would come too late in the normal
410 destruction order. Sigh. */
411
412 value = PyDict_GetItemString(modules, "__builtin__");
413 if (value != NULL && PyModule_Check(value)) {
414 dict = PyModule_GetDict(value);
415 if (Py_VerboseFlag)
416 PySys_WriteStderr("# clear __builtin__._\n");
417 PyDict_SetItemString(dict, "_", Py_None);
418 }
419 value = PyDict_GetItemString(modules, "sys");
420 if (value != NULL && PyModule_Check(value)) {
421 char **p;
422 PyObject *v;
423 dict = PyModule_GetDict(value);
424 for (p = sys_deletes; *p != NULL; p++) {
425 if (Py_VerboseFlag)
426 PySys_WriteStderr("# clear sys.%s\n", *p);
427 PyDict_SetItemString(dict, *p, Py_None);
428 }
429 for (p = sys_files; *p != NULL; p+=2) {
430 if (Py_VerboseFlag)
431 PySys_WriteStderr("# restore sys.%s\n", *p);
432 v = PyDict_GetItemString(dict, *(p+1));
433 if (v == NULL)
434 v = Py_None;
435 PyDict_SetItemString(dict, *p, v);
436 }
437 }
438
439 /* First, delete __main__ */
440 value = PyDict_GetItemString(modules, "__main__");
441 if (value != NULL && PyModule_Check(value)) {
442 if (Py_VerboseFlag)
443 PySys_WriteStderr("# cleanup __main__\n");
444 _PyModule_Clear(value);
445 PyDict_SetItemString(modules, "__main__", Py_None);
446 }
447
448 /* The special treatment of __builtin__ here is because even
449 when it's not referenced as a module, its dictionary is
450 referenced by almost every module's __builtins__. Since
451 deleting a module clears its dictionary (even if there are
452 references left to it), we need to delete the __builtin__
453 module last. Likewise, we don't delete sys until the very
454 end because it is implicitly referenced (e.g. by print).
455
456 Also note that we 'delete' modules by replacing their entry
457 in the modules dict with None, rather than really deleting
458 them; this avoids a rehash of the modules dictionary and
459 also marks them as "non existent" so they won't be
460 re-imported. */
461
462 /* Next, repeatedly delete modules with a reference count of
463 one (skipping __builtin__ and sys) and delete them */
464 do {
465 ndone = 0;
466 pos = 0;
467 while (PyDict_Next(modules, &pos, &key, &value)) {
468 if (value->ob_refcnt != 1)
469 continue;
470 if (PyString_Check(key) && PyModule_Check(value)) {
471 name = PyString_AS_STRING(key);
472 if (strcmp(name, "__builtin__") == 0)
473 continue;
474 if (strcmp(name, "sys") == 0)
475 continue;
476 if (Py_VerboseFlag)
477 PySys_WriteStderr(
478 "# cleanup[1] %s\n", name);
479 _PyModule_Clear(value);
480 PyDict_SetItem(modules, key, Py_None);
481 ndone++;
482 }
483 }
484 } while (ndone > 0);
485
486 /* Next, delete all modules (still skipping __builtin__ and sys) */
487 pos = 0;
488 while (PyDict_Next(modules, &pos, &key, &value)) {
489 if (PyString_Check(key) && PyModule_Check(value)) {
490 name = PyString_AS_STRING(key);
491 if (strcmp(name, "__builtin__") == 0)
492 continue;
493 if (strcmp(name, "sys") == 0)
494 continue;
495 if (Py_VerboseFlag)
496 PySys_WriteStderr("# cleanup[2] %s\n", name);
497 _PyModule_Clear(value);
498 PyDict_SetItem(modules, key, Py_None);
499 }
500 }
501
502 /* Next, delete sys and __builtin__ (in that order) */
503 value = PyDict_GetItemString(modules, "sys");
504 if (value != NULL && PyModule_Check(value)) {
505 if (Py_VerboseFlag)
506 PySys_WriteStderr("# cleanup sys\n");
507 _PyModule_Clear(value);
508 PyDict_SetItemString(modules, "sys", Py_None);
509 }
510 value = PyDict_GetItemString(modules, "__builtin__");
511 if (value != NULL && PyModule_Check(value)) {
512 if (Py_VerboseFlag)
513 PySys_WriteStderr("# cleanup __builtin__\n");
514 _PyModule_Clear(value);
515 PyDict_SetItemString(modules, "__builtin__", Py_None);
516 }
517
518 /* Finally, clear and delete the modules directory */
519 PyDict_Clear(modules);
520 interp->modules = NULL;
521 Py_DECREF(modules);
522 Py_CLEAR(interp->modules_reloading);
523 }
524
525
526 /* Helper for pythonrun.c -- return magic number */
527
528 long
529 PyImport_GetMagicNumber(void)
530 {
531 return pyc_magic;
532 }
533
534
535 /* Magic for extension modules (built-in as well as dynamically
536 loaded). To prevent initializing an extension module more than
537 once, we keep a static dictionary 'extensions' keyed by module name
538 (for built-in modules) or by filename (for dynamically loaded
539 modules), containing these modules. A copy of the module's
540 dictionary is stored by calling _PyImport_FixupExtension()
541 immediately after the module initialization function succeeds. A
542 copy can be retrieved from there by calling
543 _PyImport_FindExtension(). */
544
545 PyObject *
546 _PyImport_FixupExtension(char *name, char *filename)
547 {
548 PyObject *modules, *mod, *dict, *copy;
549 if (extensions == NULL) {
550 extensions = PyDict_New();
551 if (extensions == NULL)
552 return NULL;
553 }
554 modules = PyImport_GetModuleDict();
555 mod = PyDict_GetItemString(modules, name);
556 if (mod == NULL || !PyModule_Check(mod)) {
557 PyErr_Format(PyExc_SystemError,
558 "_PyImport_FixupExtension: module %.200s not loaded", name);
559 return NULL;
560 }
561 dict = PyModule_GetDict(mod);
562 if (dict == NULL)
563 return NULL;
564 copy = PyDict_Copy(dict);
565 if (copy == NULL)
566 return NULL;
567 PyDict_SetItemString(extensions, filename, copy);
568 Py_DECREF(copy);
569 return copy;
570 }
571
572 PyObject *
573 _PyImport_FindExtension(char *name, char *filename)
574 {
575 PyObject *dict, *mod, *mdict;
576 if (extensions == NULL)
577 return NULL;
578 dict = PyDict_GetItemString(extensions, filename);
579 if (dict == NULL)
580 return NULL;
581 mod = PyImport_AddModule(name);
582 if (mod == NULL)
583 return NULL;
584 mdict = PyModule_GetDict(mod);
585 if (mdict == NULL)
586 return NULL;
587 if (PyDict_Update(mdict, dict))
588 return NULL;
589 if (Py_VerboseFlag)
590 PySys_WriteStderr("import %s # previously loaded (%s)\n",
591 name, filename);
592 return mod;
593 }
594
595
596 /* Get the module object corresponding to a module name.
597 First check the modules dictionary if there's one there,
598 if not, create a new one and insert it in the modules dictionary.
599 Because the former action is most common, THIS DOES NOT RETURN A
600 'NEW' REFERENCE! */
601
602 PyObject *
603 PyImport_AddModule(const char *name)
604 {
605 PyObject *modules = PyImport_GetModuleDict();
606 PyObject *m;
607
608 if ((m = PyDict_GetItemString(modules, name)) != NULL &&
609 PyModule_Check(m))
610 return m;
611 m = PyModule_New(name);
612 if (m == NULL)
613 return NULL;
614 if (PyDict_SetItemString(modules, name, m) != 0) {
615 Py_DECREF(m);
616 return NULL;
617 }
618 Py_DECREF(m); /* Yes, it still exists, in modules! */
619
620 return m;
621 }
622
623 /* Remove name from sys.modules, if it's there. */
624 static void
625 _RemoveModule(const char *name)
626 {
627 PyObject *modules = PyImport_GetModuleDict();
628 if (PyDict_GetItemString(modules, name) == NULL)
629 return;
630 if (PyDict_DelItemString(modules, name) < 0)
631 Py_FatalError("import: deleting existing key in"
632 "sys.modules failed");
633 }
634
635 /* Execute a code object in a module and return the module object
636 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
637 * removed from sys.modules, to avoid leaving damaged module objects
638 * in sys.modules. The caller may wish to restore the original
639 * module object (if any) in this case; PyImport_ReloadModule is an
640 * example.
641 */
642 PyObject *
643 PyImport_ExecCodeModule(char *name, PyObject *co)
644 {
645 return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
646 }
647
648 PyObject *
649 PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
650 {
651 PyObject *modules = PyImport_GetModuleDict();
652 PyObject *m, *d, *v;
653
654 m = PyImport_AddModule(name);
655 if (m == NULL)
656 return NULL;
657 /* If the module is being reloaded, we get the old module back
658 and re-use its dict to exec the new code. */
659 d = PyModule_GetDict(m);
660 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
661 if (PyDict_SetItemString(d, "__builtins__",
662 PyEval_GetBuiltins()) != 0)
663 goto error;
664 }
665 /* Remember the filename as the __file__ attribute */
666 v = NULL;
667 if (pathname != NULL) {
668 v = PyString_FromString(pathname);
669 if (v == NULL)
670 PyErr_Clear();
671 }
672 if (v == NULL) {
673 v = ((PyCodeObject *)co)->co_filename;
674 Py_INCREF(v);
675 }
676 if (PyDict_SetItemString(d, "__file__", v) != 0)
677 PyErr_Clear(); /* Not important enough to report */
678 Py_DECREF(v);
679
680 v = PyEval_EvalCode((PyCodeObject *)co, d, d);
681 if (v == NULL)
682 goto error;
683 Py_DECREF(v);
684
685 if ((m = PyDict_GetItemString(modules, name)) == NULL) {
686 PyErr_Format(PyExc_ImportError,
687 "Loaded module %.200s not found in sys.modules",
688 name);
689 return NULL;
690 }
691
692 Py_INCREF(m);
693
694 return m;
695
696 error:
697 _RemoveModule(name);
698 return NULL;
699 }
700
701
702 /* Given a pathname for a Python source file, fill a buffer with the
703 pathname for the corresponding compiled file. Return the pathname
704 for the compiled file, or NULL if there's no space in the buffer.
705 Doesn't set an exception. */
706
707 static char *
708 make_compiled_pathname(char *pathname, char *buf, size_t buflen)
709 {
710 size_t len = strlen(pathname);
711 if (len+2 > buflen)
712 return NULL;
713
714 #ifdef MS_WINDOWS
715 /* Treat .pyw as if it were .py. The case of ".pyw" must match
716 that used in _PyImport_StandardFiletab. */
717 if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
718 --len; /* pretend 'w' isn't there */
719 #endif
720 memcpy(buf, pathname, len);
721 buf[len] = Py_OptimizeFlag ? 'o' : 'c';
722 buf[len+1] = '\0';
723
724 return buf;
725 }
726
727
728 /* Given a pathname for a Python source file, its time of last
729 modification, and a pathname for a compiled file, check whether the
730 compiled file represents the same version of the source. If so,
731 return a FILE pointer for the compiled file, positioned just after
732 the header; if not, return NULL.
733 Doesn't set an exception. */
734
735 static FILE *
736 check_compiled_module(char *pathname, time_t mtime, char *cpathname)
737 {
738 FILE *fp;
739 long magic;
740 long pyc_mtime;
741
742 fp = fopen(cpathname, "rb");
743 if (fp == NULL)
744 return NULL;
745 magic = PyMarshal_ReadLongFromFile(fp);
746 if (magic != pyc_magic) {
747 if (Py_VerboseFlag)
748 PySys_WriteStderr("# %s has bad magic\n", cpathname);
749 fclose(fp);
750 return NULL;
751 }
752 pyc_mtime = PyMarshal_ReadLongFromFile(fp);
753 if (pyc_mtime != mtime) {
754 if (Py_VerboseFlag)
755 PySys_WriteStderr("# %s has bad mtime\n", cpathname);
756 fclose(fp);
757 return NULL;
758 }
759 if (Py_VerboseFlag)
760 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
761 return fp;
762 }
763
764
765 /* Read a code object from a file and check it for validity */
766
767 static PyCodeObject *
768 read_compiled_module(char *cpathname, FILE *fp)
769 {
770 PyObject *co;
771
772 co = PyMarshal_ReadLastObjectFromFile(fp);
773 if (co == NULL)
774 return NULL;
775 if (!PyCode_Check(co)) {
776 PyErr_Format(PyExc_ImportError,
777 "Non-code object in %.200s", cpathname);
778 Py_DECREF(co);
779 return NULL;
780 }
781 return (PyCodeObject *)co;
782 }
783
784
785 /* Load a module from a compiled file, execute it, and return its
786 module object WITH INCREMENTED REFERENCE COUNT */
787
788 static PyObject *
789 load_compiled_module(char *name, char *cpathname, FILE *fp)
790 {
791 long magic;
792 PyCodeObject *co;
793 PyObject *m;
794
795 magic = PyMarshal_ReadLongFromFile(fp);
796 if (magic != pyc_magic) {
797 PyErr_Format(PyExc_ImportError,
798 "Bad magic number in %.200s", cpathname);
799 return NULL;
800 }
801 (void) PyMarshal_ReadLongFromFile(fp);
802 co = read_compiled_module(cpathname, fp);
803 if (co == NULL)
804 return NULL;
805 if (Py_VerboseFlag)
806 PySys_WriteStderr("import %s # precompiled from %s\n",
807 name, cpathname);
808 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
809 Py_DECREF(co);
810
811 return m;
812 }
813
814 /* Parse a source file and return the corresponding code object */
815
816 static PyCodeObject *
817 parse_source_module(const char *pathname, FILE *fp)
818 {
819 PyCodeObject *co = NULL;
820 mod_ty mod;
821 PyCompilerFlags flags;
822 PyArena *arena = PyArena_New();
823 if (arena == NULL)
824 return NULL;
825
826 flags.cf_flags = 0;
827
828 mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags,
829 NULL, arena);
830 if (mod) {
831 co = PyAST_Compile(mod, pathname, NULL, arena);
832 }
833 PyArena_Free(arena);
834 return co;
835 }
836
837
838 /* Helper to open a bytecode file for writing in exclusive mode */
839
840 static FILE *
841 open_exclusive(char *filename, mode_t mode)
842 {
843 #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
844 /* Use O_EXCL to avoid a race condition when another process tries to
845 write the same file. When that happens, our open() call fails,
846 which is just fine (since it's only a cache).
847 XXX If the file exists and is writable but the directory is not
848 writable, the file will never be written. Oh well.
849 */
850 int fd;
851 (void) unlink(filename);
852 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
853 #ifdef O_BINARY
854 |O_BINARY /* necessary for Windows */
855 #endif
856 #ifdef __VMS
857 , mode, "ctxt=bin", "shr=nil"
858 #else
859 , mode
860 #endif
861 );
862 if (fd < 0)
863 return NULL;
864 return fdopen(fd, "wb");
865 #else
866 /* Best we can do -- on Windows this can't happen anyway */
867 return fopen(filename, "wb");
868 #endif
869 }
870
871
872 /* Write a compiled module to a file, placing the time of last
873 modification of its source into the header.
874 Errors are ignored, if a write error occurs an attempt is made to
875 remove the file. */
876
877 static void
878 write_compiled_module(PyCodeObject *co, char *cpathname, struct stat *srcstat)
879 {
880 FILE *fp;
881 time_t mtime = srcstat->st_mtime;
882 mode_t mode = srcstat->st_mode;
883
884 fp = open_exclusive(cpathname, mode);
885 if (fp == NULL) {
886 if (Py_VerboseFlag)
887 PySys_WriteStderr(
888 "# can't create %s\n", cpathname);
889 return;
890 }
891 PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
892 /* First write a 0 for mtime */
893 PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
894 PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
895 if (fflush(fp) != 0 || ferror(fp)) {
896 if (Py_VerboseFlag)
897 PySys_WriteStderr("# can't write %s\n", cpathname);
898 /* Don't keep partial file */
899 fclose(fp);
900 (void) unlink(cpathname);
901 return;
902 }
903 /* Now write the true mtime */
904 fseek(fp, 4L, 0);
905 assert(mtime < LONG_MAX);
906 PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
907 fflush(fp);
908 fclose(fp);
909 if (Py_VerboseFlag)
910 PySys_WriteStderr("# wrote %s\n", cpathname);
911 }
912
913
914 /* Load a source module from a given file and return its module
915 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
916 byte-compiled file, use that instead. */
917
918 static PyObject *
919 load_source_module(char *name, char *pathname, FILE *fp)
920 {
921 struct stat st;
922 FILE *fpc;
923 char buf[MAXPATHLEN+1];
924 char *cpathname;
925 PyCodeObject *co;
926 PyObject *m;
927
928 if (fstat(fileno(fp), &st) != 0) {
929 PyErr_Format(PyExc_RuntimeError,
930 "unable to get file status from '%s'",
931 pathname);
932 return NULL;
933 }
934 #if SIZEOF_TIME_T > 4
935 /* Python's .pyc timestamp handling presumes that the timestamp fits
936 in 4 bytes. This will be fine until sometime in the year 2038,
937 when a 4-byte signed time_t will overflow.
938 */
939 if (st.st_mtime >> 32) {
940 PyErr_SetString(PyExc_OverflowError,
941 "modification time overflows a 4 byte field");
942 return NULL;
943 }
944 #endif
945 cpathname = make_compiled_pathname(pathname, buf,
946 (size_t)MAXPATHLEN + 1);
947 if (cpathname != NULL &&
948 (fpc = check_compiled_module(pathname, st.st_mtime, cpathname))) {
949 co = read_compiled_module(cpathname, fpc);
950 fclose(fpc);
951 if (co == NULL)
952 return NULL;
953 if (Py_VerboseFlag)
954 PySys_WriteStderr("import %s # precompiled from %s\n",
955 name, cpathname);
956 pathname = cpathname;
957 }
958 else {
959 co = parse_source_module(pathname, fp);
960 if (co == NULL)
961 return NULL;
962 if (Py_VerboseFlag)
963 PySys_WriteStderr("import %s # from %s\n",
964 name, pathname);
965 if (cpathname) {
966 PyObject *ro = PySys_GetObject("dont_write_bytecode");
967 if (ro == NULL || !PyObject_IsTrue(ro))
968 write_compiled_module(co, cpathname, &st);
969 }
970 }
971 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
972 Py_DECREF(co);
973
974 return m;
975 }
976
977
978 /* Forward */
979 static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
980 static struct filedescr *find_module(char *, char *, PyObject *,
981 char *, size_t, FILE **, PyObject **);
982 static struct _frozen *find_frozen(char *name);
983
984 /* Load a package and return its module object WITH INCREMENTED
985 REFERENCE COUNT */
986
987 static PyObject *
988 load_package(char *name, char *pathname)
989 {
990 PyObject *m, *d;
991 PyObject *file = NULL;
992 PyObject *path = NULL;
993 int err;
994 char buf[MAXPATHLEN+1];
995 FILE *fp = NULL;
996 struct filedescr *fdp;
997
998 m = PyImport_AddModule(name);
999 if (m == NULL)
1000 return NULL;
1001 if (Py_VerboseFlag)
1002 PySys_WriteStderr("import %s # directory %s\n",
1003 name, pathname);
1004 d = PyModule_GetDict(m);
1005 file = PyString_FromString(pathname);
1006 if (file == NULL)
1007 goto error;
1008 path = Py_BuildValue("[O]", file);
1009 if (path == NULL)
1010 goto error;
1011 err = PyDict_SetItemString(d, "__file__", file);
1012 if (err == 0)
1013 err = PyDict_SetItemString(d, "__path__", path);
1014 if (err != 0)
1015 goto error;
1016 buf[0] = '\0';
1017 fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
1018 if (fdp == NULL) {
1019 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1020 PyErr_Clear();
1021 Py_INCREF(m);
1022 }
1023 else
1024 m = NULL;
1025 goto cleanup;
1026 }
1027 m = load_module(name, fp, buf, fdp->type, NULL);
1028 if (fp != NULL)
1029 fclose(fp);
1030 goto cleanup;
1031
1032 error:
1033 m = NULL;
1034 cleanup:
1035 Py_XDECREF(path);
1036 Py_XDECREF(file);
1037 return m;
1038 }
1039
1040
1041 /* Helper to test for built-in module */
1042
1043 static int
1044 is_builtin(char *name)
1045 {
1046 int i;
1047 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1048 if (strcmp(name, PyImport_Inittab[i].name) == 0) {
1049 if (PyImport_Inittab[i].initfunc == NULL)
1050 return -1;
1051 else
1052 return 1;
1053 }
1054 }
1055 return 0;
1056 }
1057
1058
1059 /* Return an importer object for a sys.path/pkg.__path__ item 'p',
1060 possibly by fetching it from the path_importer_cache dict. If it
1061 wasn't yet cached, traverse path_hooks until a hook is found
1062 that can handle the path item. Return None if no hook could;
1063 this tells our caller it should fall back to the builtin
1064 import mechanism. Cache the result in path_importer_cache.
1065 Returns a borrowed reference. */
1066
1067 static PyObject *
1068 get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
1069 PyObject *p)
1070 {
1071 PyObject *importer;
1072 Py_ssize_t j, nhooks;
1073
1074 /* These conditions are the caller's responsibility: */
1075 assert(PyList_Check(path_hooks));
1076 assert(PyDict_Check(path_importer_cache));
1077
1078 nhooks = PyList_Size(path_hooks);
1079 if (nhooks < 0)
1080 return NULL; /* Shouldn't happen */
1081
1082 importer = PyDict_GetItem(path_importer_cache, p);
1083 if (importer != NULL)
1084 return importer;
1085
1086 /* set path_importer_cache[p] to None to avoid recursion */
1087 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1088 return NULL;
1089
1090 for (j = 0; j < nhooks; j++) {
1091 PyObject *hook = PyList_GetItem(path_hooks, j);
1092 if (hook == NULL)
1093 return NULL;
1094 importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
1095 if (importer != NULL)
1096 break;
1097
1098 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1099 return NULL;
1100 }
1101 PyErr_Clear();
1102 }
1103 if (importer == NULL) {
1104 importer = PyObject_CallFunctionObjArgs(
1105 (PyObject *)&PyNullImporter_Type, p, NULL
1106 );
1107 if (importer == NULL) {
1108 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
1109 PyErr_Clear();
1110 return Py_None;
1111 }
1112 }
1113 }
1114 if (importer != NULL) {
1115 int err = PyDict_SetItem(path_importer_cache, p, importer);
1116 Py_DECREF(importer);
1117 if (err != 0)
1118 return NULL;
1119 }
1120 return importer;
1121 }
1122
1123 PyAPI_FUNC(PyObject *)
1124 PyImport_GetImporter(PyObject *path) {
1125 PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
1126
1127 if ((path_importer_cache = PySys_GetObject("path_importer_cache"))) {
1128 if ((path_hooks = PySys_GetObject("path_hooks"))) {
1129 importer = get_path_importer(path_importer_cache,
1130 path_hooks, path);
1131 }
1132 }
1133 Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
1134 return importer;
1135 }
1136
1137 /* Search the path (default sys.path) for a module. Return the
1138 corresponding filedescr struct, and (via return arguments) the
1139 pathname and an open file. Return NULL if the module is not found. */
1140
1141 #ifdef MS_COREDLL
1142 extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
1143 char *, Py_ssize_t);
1144 #endif
1145
1146 static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
1147 static int find_init_module(char *); /* Forward */
1148 static struct filedescr importhookdescr = {"", "", IMP_HOOK};
1149
1150 static struct filedescr *
1151 find_module(char *fullname, char *subname, PyObject *path, char *buf,
1152 size_t buflen, FILE **p_fp, PyObject **p_loader)
1153 {
1154 Py_ssize_t i, npath;
1155 size_t len, namelen;
1156 struct filedescr *fdp = NULL;
1157 char *filemode;
1158 FILE *fp = NULL;
1159 PyObject *path_hooks, *path_importer_cache;
1160 #ifndef RISCOS
1161 struct stat statbuf;
1162 #endif
1163 static struct filedescr fd_frozen = {"", "", PY_FROZEN};
1164 static struct filedescr fd_builtin = {"", "", C_BUILTIN};
1165 static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
1166 char name[MAXPATHLEN+1];
1167 #if defined(PYOS_OS2)
1168 size_t saved_len;
1169 size_t saved_namelen;
1170 char *saved_buf = NULL;
1171 #endif
1172 if (p_loader != NULL)
1173 *p_loader = NULL;
1174
1175 if (strlen(subname) > MAXPATHLEN) {
1176 PyErr_SetString(PyExc_OverflowError,
1177 "module name is too long");
1178 return NULL;
1179 }
1180 strcpy(name, subname);
1181
1182 /* sys.meta_path import hook */
1183 if (p_loader != NULL) {
1184 PyObject *meta_path;
1185
1186 meta_path = PySys_GetObject("meta_path");
1187 if (meta_path == NULL || !PyList_Check(meta_path)) {
1188 PyErr_SetString(PyExc_ImportError,
1189 "sys.meta_path must be a list of "
1190 "import hooks");
1191 return NULL;
1192 }
1193 Py_INCREF(meta_path); /* zap guard */
1194 npath = PyList_Size(meta_path);
1195 for (i = 0; i < npath; i++) {
1196 PyObject *loader;
1197 PyObject *hook = PyList_GetItem(meta_path, i);
1198 loader = PyObject_CallMethod(hook, "find_module",
1199 "sO", fullname,
1200 path != NULL ?
1201 path : Py_None);
1202 if (loader == NULL) {
1203 Py_DECREF(meta_path);
1204 return NULL; /* true error */
1205 }
1206 if (loader != Py_None) {
1207 /* a loader was found */
1208 *p_loader = loader;
1209 Py_DECREF(meta_path);
1210 return &importhookdescr;
1211 }
1212 Py_DECREF(loader);
1213 }
1214 Py_DECREF(meta_path);
1215 }
1216
1217 if (path != NULL && PyString_Check(path)) {
1218 /* The only type of submodule allowed inside a "frozen"
1219 package are other frozen modules or packages. */
1220 if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
1221 PyErr_SetString(PyExc_ImportError,
1222 "full frozen module name too long");
1223 return NULL;
1224 }
1225 strcpy(buf, PyString_AsString(path));
1226 strcat(buf, ".");
1227 strcat(buf, name);
1228 strcpy(name, buf);
1229 if (find_frozen(name) != NULL) {
1230 strcpy(buf, name);
1231 return &fd_frozen;
1232 }
1233 PyErr_Format(PyExc_ImportError,
1234 "No frozen submodule named %.200s", name);
1235 return NULL;
1236 }
1237 if (path == NULL) {
1238 if (is_builtin(name)) {
1239 strcpy(buf, name);
1240 return &fd_builtin;
1241 }
1242 if ((find_frozen(name)) != NULL) {
1243 strcpy(buf, name);
1244 return &fd_frozen;
1245 }
1246
1247 #ifdef MS_COREDLL
1248 fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
1249 if (fp != NULL) {
1250 *p_fp = fp;
1251 return fdp;
1252 }
1253 #endif
1254 path = PySys_GetObject("path");
1255 }
1256 if (path == NULL || !PyList_Check(path)) {
1257 PyErr_SetString(PyExc_ImportError,
1258 "sys.path must be a list of directory names");
1259 return NULL;
1260 }
1261
1262 path_hooks = PySys_GetObject("path_hooks");
1263 if (path_hooks == NULL || !PyList_Check(path_hooks)) {
1264 PyErr_SetString(PyExc_ImportError,
1265 "sys.path_hooks must be a list of "
1266 "import hooks");
1267 return NULL;
1268 }
1269 path_importer_cache = PySys_GetObject("path_importer_cache");
1270 if (path_importer_cache == NULL ||
1271 !PyDict_Check(path_importer_cache)) {
1272 PyErr_SetString(PyExc_ImportError,
1273 "sys.path_importer_cache must be a dict");
1274 return NULL;
1275 }
1276
1277 npath = PyList_Size(path);
1278 namelen = strlen(name);
1279 for (i = 0; i < npath; i++) {
1280 PyObject *copy = NULL;
1281 PyObject *v = PyList_GetItem(path, i);
1282 if (!v)
1283 return NULL;
1284 #ifdef Py_USING_UNICODE
1285 if (PyUnicode_Check(v)) {
1286 copy = PyUnicode_Encode(PyUnicode_AS_UNICODE(v),
1287 PyUnicode_GET_SIZE(v), Py_FileSystemDefaultEncoding, NULL);
1288 if (copy == NULL)
1289 return NULL;
1290 v = copy;
1291 }
1292 else
1293 #endif
1294 if (!PyString_Check(v))
1295 continue;
1296 len = PyString_GET_SIZE(v);
1297 if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
1298 Py_XDECREF(copy);
1299 continue; /* Too long */
1300 }
1301 strcpy(buf, PyString_AS_STRING(v));
1302 if (strlen(buf) != len) {
1303 Py_XDECREF(copy);
1304 continue; /* v contains '\0' */
1305 }
1306
1307 /* sys.path_hooks import hook */
1308 if (p_loader != NULL) {
1309 PyObject *importer;
1310
1311 importer = get_path_importer(path_importer_cache,
1312 path_hooks, v);
1313 if (importer == NULL) {
1314 Py_XDECREF(copy);
1315 return NULL;
1316 }
1317 /* Note: importer is a borrowed reference */
1318 if (importer != Py_None) {
1319 PyObject *loader;
1320 loader = PyObject_CallMethod(importer,
1321 "find_module",
1322 "s", fullname);
1323 Py_XDECREF(copy);
1324 if (loader == NULL)
1325 return NULL; /* error */
1326 if (loader != Py_None) {
1327 /* a loader was found */
1328 *p_loader = loader;
1329 return &importhookdescr;
1330 }
1331 Py_DECREF(loader);
1332 continue;
1333 }
1334 }
1335 /* no hook was found, use builtin import */
1336
1337 if (len > 0 && buf[len-1] != SEP
1338 #ifdef ALTSEP
1339 && buf[len-1] != ALTSEP
1340 #endif
1341 )
1342 buf[len++] = SEP;
1343 strcpy(buf+len, name);
1344 len += namelen;
1345
1346 /* Check for package import (buf holds a directory name,
1347 and there's an __init__ module in that directory */
1348 #ifdef HAVE_STAT
1349 if (stat(buf, &statbuf) == 0 && /* it exists */
1350 S_ISDIR(statbuf.st_mode) && /* it's a directory */
1351 case_ok(buf, len, namelen, name)) { /* case matches */
1352 if (find_init_module(buf)) { /* and has __init__.py */
1353 Py_XDECREF(copy);
1354 return &fd_package;
1355 }
1356 else {
1357 char warnstr[MAXPATHLEN+80];
1358 sprintf(warnstr, "Not importing directory "
1359 "'%.*s': missing __init__.py",
1360 MAXPATHLEN, buf);
1361 if (PyErr_Warn(PyExc_ImportWarning,
1362 warnstr)) {
1363 Py_XDECREF(copy);
1364 return NULL;
1365 }
1366 }
1367 }
1368 #else
1369 /* XXX How are you going to test for directories? */
1370 #ifdef RISCOS
1371 if (isdir(buf) &&
1372 case_ok(buf, len, namelen, name)) {
1373 if (find_init_module(buf)) {
1374 Py_XDECREF(copy);
1375 return &fd_package;
1376 }
1377 else {
1378 char warnstr[MAXPATHLEN+80];
1379 sprintf(warnstr, "Not importing directory "
1380 "'%.*s': missing __init__.py",
1381 MAXPATHLEN, buf);
1382 if (PyErr_Warn(PyExc_ImportWarning,
1383 warnstr)) {
1384 Py_XDECREF(copy);
1385 return NULL;
1386 }
1387 }
1388 #endif
1389 #endif
1390 #if defined(PYOS_OS2)
1391 /* take a snapshot of the module spec for restoration
1392 * after the 8 character DLL hackery
1393 */
1394 saved_buf = strdup(buf);
1395 saved_len = len;
1396 saved_namelen = namelen;
1397 #endif /* PYOS_OS2 */
1398 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
1399 #if defined(PYOS_OS2) && defined(HAVE_DYNAMIC_LOADING)
1400 /* OS/2 limits DLLs to 8 character names (w/o
1401 extension)
1402 * so if the name is longer than that and its a
1403 * dynamically loaded module we're going to try,
1404 * truncate the name before trying
1405 */
1406 if (strlen(subname) > 8) {
1407 /* is this an attempt to load a C extension? */
1408 const struct filedescr *scan;
1409 scan = _PyImport_DynLoadFiletab;
1410 while (scan->suffix != NULL) {
1411 if (!strcmp(scan->suffix, fdp->suffix))
1412 break;
1413 else
1414 scan++;
1415 }
1416 if (scan->suffix != NULL) {
1417 /* yes, so truncate the name */
1418 namelen = 8;
1419 len -= strlen(subname) - namelen;
1420 buf[len] = '\0';
1421 }
1422 }
1423 #endif /* PYOS_OS2 */
1424 strcpy(buf+len, fdp->suffix);
1425 if (Py_VerboseFlag > 1)
1426 PySys_WriteStderr("# trying %s\n", buf);
1427 filemode = fdp->mode;
1428 if (filemode[0] == 'U')
1429 filemode = "r" PY_STDIOTEXTMODE;
1430 fp = fopen(buf, filemode);
1431 if (fp != NULL) {
1432 if (case_ok(buf, len, namelen, name))
1433 break;
1434 else { /* continue search */
1435 fclose(fp);
1436 fp = NULL;
1437 }
1438 }
1439 #if defined(PYOS_OS2)
1440 /* restore the saved snapshot */
1441 strcpy(buf, saved_buf);
1442 len = saved_len;
1443 namelen = saved_namelen;
1444 #endif
1445 }
1446 #if defined(PYOS_OS2)
1447 /* don't need/want the module name snapshot anymore */
1448 if (saved_buf)
1449 {
1450 free(saved_buf);
1451 saved_buf = NULL;
1452 }
1453 #endif
1454 Py_XDECREF(copy);
1455 if (fp != NULL)
1456 break;
1457 }
1458 if (fp == NULL) {
1459 PyErr_Format(PyExc_ImportError,
1460 "No module named %.200s", name);
1461 return NULL;
1462 }
1463 *p_fp = fp;
1464 return fdp;
1465 }
1466
1467 /* Helpers for main.c
1468 * Find the source file corresponding to a named module
1469 */
1470 struct filedescr *
1471 _PyImport_FindModule(const char *name, PyObject *path, char *buf,
1472 size_t buflen, FILE **p_fp, PyObject **p_loader)
1473 {
1474 return find_module((char *) name, (char *) name, path,
1475 buf, buflen, p_fp, p_loader);
1476 }
1477
1478 PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)
1479 {
1480 return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
1481 }
1482
1483 /* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
1484 * The arguments here are tricky, best shown by example:
1485 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1486 * ^ ^ ^ ^
1487 * |--------------------- buf ---------------------|
1488 * |------------------- len ------------------|
1489 * |------ name -------|
1490 * |----- namelen -----|
1491 * buf is the full path, but len only counts up to (& exclusive of) the
1492 * extension. name is the module name, also exclusive of extension.
1493 *
1494 * We've already done a successful stat() or fopen() on buf, so know that
1495 * there's some match, possibly case-insensitive.
1496 *
1497 * case_ok() is to return 1 if there's a case-sensitive match for
1498 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1499 * exists.
1500 *
1501 * case_ok() is used to implement case-sensitive import semantics even
1502 * on platforms with case-insensitive filesystems. It's trivial to implement
1503 * for case-sensitive filesystems. It's pretty much a cross-platform
1504 * nightmare for systems with case-insensitive filesystems.
1505 */
1506
1507 /* First we may need a pile of platform-specific header files; the sequence
1508 * of #if's here should match the sequence in the body of case_ok().
1509 */
1510 #if defined(MS_WINDOWS)
1511 #include <windows.h>
1512
1513 #elif defined(DJGPP)
1514 #include <dir.h>
1515
1516 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1517 #include <sys/types.h>
1518 #include <dirent.h>
1519
1520 #elif defined(PYOS_OS2)
1521 #define INCL_DOS
1522 #define INCL_DOSERRORS
1523 #define INCL_NOPMAPI
1524 #include <os2.h>
1525
1526 #elif defined(RISCOS)
1527 #include "oslib/osfscontrol.h"
1528 #endif
1529
1530 static int
1531 case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
1532 {
1533 /* Pick a platform-specific implementation; the sequence of #if's here should
1534 * match the sequence just above.
1535 */
1536
1537 /* MS_WINDOWS */
1538 #if defined(MS_WINDOWS)
1539 WIN32_FIND_DATA data;
1540 HANDLE h;
1541
1542 if (Py_GETENV("PYTHONCASEOK") != NULL)
1543 return 1;
1544
1545 h = FindFirstFile(buf, &data);
1546 if (h == INVALID_HANDLE_VALUE) {
1547 PyErr_Format(PyExc_NameError,
1548 "Can't find file for module %.100s\n(filename %.300s)",
1549 name, buf);
1550 return 0;
1551 }
1552 FindClose(h);
1553 return strncmp(data.cFileName, name, namelen) == 0;
1554
1555 /* DJGPP */
1556 #elif defined(DJGPP)
1557 struct ffblk ffblk;
1558 int done;
1559
1560 if (Py_GETENV("PYTHONCASEOK") != NULL)
1561 return 1;
1562
1563 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1564 if (done) {
1565 PyErr_Format(PyExc_NameError,
1566 "Can't find file for module %.100s\n(filename %.300s)",
1567 name, buf);
1568 return 0;
1569 }
1570 return strncmp(ffblk.ff_name, name, namelen) == 0;
1571
1572 /* new-fangled macintosh (macosx) or Cygwin */
1573 #elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
1574 DIR *dirp;
1575 struct dirent *dp;
1576 char dirname[MAXPATHLEN + 1];
1577 const int dirlen = len - namelen - 1; /* don't want trailing SEP */
1578
1579 if (Py_GETENV("PYTHONCASEOK") != NULL)
1580 return 1;
1581
1582 /* Copy the dir component into dirname; substitute "." if empty */
1583 if (dirlen <= 0) {
1584 dirname[0] = '.';
1585 dirname[1] = '\0';
1586 }
1587 else {
1588 assert(dirlen <= MAXPATHLEN);
1589 memcpy(dirname, buf, dirlen);
1590 dirname[dirlen] = '\0';
1591 }
1592 /* Open the directory and search the entries for an exact match. */
1593 dirp = opendir(dirname);
1594 if (dirp) {
1595 char *nameWithExt = buf + len - namelen;
1596 while ((dp = readdir(dirp)) != NULL) {
1597 const int thislen =
1598 #ifdef _DIRENT_HAVE_D_NAMELEN
1599 dp->d_namlen;
1600 #else
1601 strlen(dp->d_name);
1602 #endif
1603 if (thislen >= namelen &&
1604 strcmp(dp->d_name, nameWithExt) == 0) {
1605 (void)closedir(dirp);
1606 return 1; /* Found */
1607 }
1608 }
1609 (void)closedir(dirp);
1610 }
1611 return 0 ; /* Not found */
1612
1613 /* RISC OS */
1614 #elif defined(RISCOS)
1615 char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */
1616 char buf2[MAXPATHLEN+2];
1617 char *nameWithExt = buf+len-namelen;
1618 int canonlen;
1619 os_error *e;
1620
1621 if (Py_GETENV("PYTHONCASEOK") != NULL)
1622 return 1;
1623
1624 /* workaround:
1625 append wildcard, otherwise case of filename wouldn't be touched */
1626 strcpy(buf2, buf);
1627 strcat(buf2, "*");
1628
1629 e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen);
1630 canonlen = MAXPATHLEN+1-canonlen;
1631 if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) )
1632 return 0;
1633 if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)
1634 return 1; /* match */
1635
1636 return 0;
1637
1638 /* OS/2 */
1639 #elif defined(PYOS_OS2)
1640 HDIR hdir = 1;
1641 ULONG srchcnt = 1;
1642 FILEFINDBUF3 ffbuf;
1643 APIRET rc;
1644
1645 if (Py_GETENV("PYTHONCASEOK") != NULL)
1646 return 1;
1647
1648 rc = DosFindFirst(buf,
1649 &hdir,
1650 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1651 &ffbuf, sizeof(ffbuf),
1652 &srchcnt,
1653 FIL_STANDARD);
1654 if (rc != NO_ERROR)
1655 return 0;
1656 return strncmp(ffbuf.achName, name, namelen) == 0;
1657
1658 /* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1659 #else
1660 return 1;
1661
1662 #endif
1663 }
1664
1665
1666 #ifdef HAVE_STAT
1667 /* Helper to look for __init__.py or __init__.py[co] in potential package */
1668 static int
1669 find_init_module(char *buf)
1670 {
1671 const size_t save_len = strlen(buf);
1672 size_t i = save_len;
1673 char *pname; /* pointer to start of __init__ */
1674 struct stat statbuf;
1675
1676 /* For calling case_ok(buf, len, namelen, name):
1677 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1678 * ^ ^ ^ ^
1679 * |--------------------- buf ---------------------|
1680 * |------------------- len ------------------|
1681 * |------ name -------|
1682 * |----- namelen -----|
1683 */
1684 if (save_len + 13 >= MAXPATHLEN)
1685 return 0;
1686 buf[i++] = SEP;
1687 pname = buf + i;
1688 strcpy(pname, "__init__.py");
1689 if (stat(buf, &statbuf) == 0) {
1690 if (case_ok(buf,
1691 save_len + 9, /* len("/__init__") */
1692 8, /* len("__init__") */
1693 pname)) {
1694 buf[save_len] = '\0';
1695 return 1;
1696 }
1697 }
1698 i += strlen(pname);
1699 strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
1700 if (stat(buf, &statbuf) == 0) {
1701 if (case_ok(buf,
1702 save_len + 9, /* len("/__init__") */
1703 8, /* len("__init__") */
1704 pname)) {
1705 buf[save_len] = '\0';
1706 return 1;
1707 }
1708 }
1709 buf[save_len] = '\0';
1710 return 0;
1711 }
1712
1713 #else
1714
1715 #ifdef RISCOS
1716 static int
1717 find_init_module(buf)
1718 char *buf;
1719 {
1720 int save_len = strlen(buf);
1721 int i = save_len;
1722
1723 if (save_len + 13 >= MAXPATHLEN)
1724 return 0;
1725 buf[i++] = SEP;
1726 strcpy(buf+i, "__init__/py");
1727 if (isfile(buf)) {
1728 buf[save_len] = '\0';
1729 return 1;
1730 }
1731
1732 if (Py_OptimizeFlag)
1733 strcpy(buf+i, "o");
1734 else
1735 strcpy(buf+i, "c");
1736 if (isfile(buf)) {
1737 buf[save_len] = '\0';
1738 return 1;
1739 }
1740 buf[save_len] = '\0';
1741 return 0;
1742 }
1743 #endif /*RISCOS*/
1744
1745 #endif /* HAVE_STAT */
1746
1747
1748 static int init_builtin(char *); /* Forward */
1749
1750 /* Load an external module using the default search path and return
1751 its module object WITH INCREMENTED REFERENCE COUNT */
1752
1753 static PyObject *
1754 load_module(char *name, FILE *fp, char *buf, int type, PyObject *loader)
1755 {
1756 PyObject *modules;
1757 PyObject *m;
1758 int err;
1759
1760 /* First check that there's an open file (if we need one) */
1761 switch (type) {
1762 case PY_SOURCE:
1763 case PY_COMPILED:
1764 if (fp == NULL) {
1765 PyErr_Format(PyExc_ValueError,
1766 "file object required for import (type code %d)",
1767 type);
1768 return NULL;
1769 }
1770 }
1771
1772 switch (type) {
1773
1774 case PY_SOURCE:
1775 m = load_source_module(name, buf, fp);
1776 break;
1777
1778 case PY_COMPILED:
1779 m = load_compiled_module(name, buf, fp);
1780 break;
1781
1782 #ifdef HAVE_DYNAMIC_LOADING
1783 case C_EXTENSION:
1784 m = _PyImport_LoadDynamicModule(name, buf, fp);
1785 break;
1786 #endif
1787
1788 case PKG_DIRECTORY:
1789 m = load_package(name, buf);
1790 break;
1791
1792 case C_BUILTIN:
1793 case PY_FROZEN:
1794 if (buf != NULL && buf[0] != '\0')
1795 name = buf;
1796 if (type == C_BUILTIN)
1797 err = init_builtin(name);
1798 else
1799 err = PyImport_ImportFrozenModule(name);
1800 if (err < 0)
1801 return NULL;
1802 if (err == 0) {
1803 PyErr_Format(PyExc_ImportError,
1804 "Purported %s module %.200s not found",
1805 type == C_BUILTIN ?
1806 "builtin" : "frozen",
1807 name);
1808 return NULL;
1809 }
1810 modules = PyImport_GetModuleDict();
1811 m = PyDict_GetItemString(modules, name);
1812 if (m == NULL) {
1813 PyErr_Format(
1814 PyExc_ImportError,
1815 "%s module %.200s not properly initialized",
1816 type == C_BUILTIN ?
1817 "builtin" : "frozen",
1818 name);
1819 return NULL;
1820 }
1821 Py_INCREF(m);
1822 break;
1823
1824 case IMP_HOOK: {
1825 if (loader == NULL) {
1826 PyErr_SetString(PyExc_ImportError,
1827 "import hook without loader");
1828 return NULL;
1829 }
1830 m = PyObject_CallMethod(loader, "load_module", "s", name);
1831 break;
1832 }
1833
1834 default:
1835 PyErr_Format(PyExc_ImportError,
1836 "Don't know how to import %.200s (type code %d)",
1837 name, type);
1838 m = NULL;
1839
1840 }
1841
1842 return m;
1843 }
1844
1845
1846 /* Initialize a built-in module.
1847 Return 1 for success, 0 if the module is not found, and -1 with
1848 an exception set if the initialization failed. */
1849
1850 static int
1851 init_builtin(char *name)
1852 {
1853 struct _inittab *p;
1854
1855 if (_PyImport_FindExtension(name, name) != NULL)
1856 return 1;
1857
1858 for (p = PyImport_Inittab; p->name != NULL; p++) {
1859 if (strcmp(name, p->name) == 0) {
1860 if (p->initfunc == NULL) {
1861 PyErr_Format(PyExc_ImportError,
1862 "Cannot re-init internal module %.200s",
1863 name);
1864 return -1;
1865 }
1866 if (Py_VerboseFlag)
1867 PySys_WriteStderr("import %s # builtin\n", name);
1868 (*p->initfunc)();
1869 if (PyErr_Occurred())
1870 return -1;
1871 if (_PyImport_FixupExtension(name, name) == NULL)
1872 return -1;
1873 return 1;
1874 }
1875 }
1876 return 0;
1877 }
1878
1879
1880 /* Frozen modules */
1881
1882 static struct _frozen *
1883 find_frozen(char *name)
1884 {
1885 struct _frozen *p;
1886
1887 for (p = PyImport_FrozenModules; ; p++) {
1888 if (p->name == NULL)
1889 return NULL;
1890 if (strcmp(p->name, name) == 0)
1891 break;
1892 }
1893 return p;
1894 }
1895
1896 static PyObject *
1897 get_frozen_object(char *name)
1898 {
1899 struct _frozen *p = find_frozen(name);
1900 int size;
1901
1902 if (p == NULL) {
1903 PyErr_Format(PyExc_ImportError,
1904 "No such frozen object named %.200s",
1905 name);
1906 return NULL;
1907 }
1908 if (p->code == NULL) {
1909 PyErr_Format(PyExc_ImportError,
1910 "Excluded frozen object named %.200s",
1911 name);
1912 return NULL;
1913 }
1914 size = p->size;
1915 if (size < 0)
1916 size = -size;
1917 return PyMarshal_ReadObjectFromString((char *)p->code, size);
1918 }
1919
1920 /* Initialize a frozen module.
1921 Return 1 for succes, 0 if the module is not found, and -1 with
1922 an exception set if the initialization failed.
1923 This function is also used from frozenmain.c */
1924
1925 int
1926 PyImport_ImportFrozenModule(char *name)
1927 {
1928 struct _frozen *p = find_frozen(name);
1929 PyObject *co;
1930 PyObject *m;
1931 int ispackage;
1932 int size;
1933
1934 if (p == NULL)
1935 return 0;
1936 if (p->code == NULL) {
1937 PyErr_Format(PyExc_ImportError,
1938 "Excluded frozen object named %.200s",
1939 name);
1940 return -1;
1941 }
1942 size = p->size;
1943 ispackage = (size < 0);
1944 if (ispackage)
1945 size = -size;
1946 if (Py_VerboseFlag)
1947 PySys_WriteStderr("import %s # frozen%s\n",
1948 name, ispackage ? " package" : "");
1949 co = PyMarshal_ReadObjectFromString((char *)p->code, size);
1950 if (co == NULL)
1951 return -1;
1952 if (!PyCode_Check(co)) {
1953 PyErr_Format(PyExc_TypeError,
1954 "frozen object %.200s is not a code object",
1955 name);
1956 goto err_return;
1957 }
1958 if (ispackage) {
1959 /* Set __path__ to the package name */
1960 PyObject *d, *s;
1961 int err;
1962 m = PyImport_AddModule(name);
1963 if (m == NULL)
1964 goto err_return;
1965 d = PyModule_GetDict(m);
1966 s = PyString_InternFromString(name);
1967 if (s == NULL)
1968 goto err_return;
1969 err = PyDict_SetItemString(d, "__path__", s);
1970 Py_DECREF(s);
1971 if (err != 0)
1972 goto err_return;
1973 }
1974 m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
1975 if (m == NULL)
1976 goto err_return;
1977 Py_DECREF(co);
1978 Py_DECREF(m);
1979 return 1;
1980 err_return:
1981 Py_DECREF(co);
1982 return -1;
1983 }
1984
1985
1986 /* Import a module, either built-in, frozen, or external, and return
1987 its module object WITH INCREMENTED REFERENCE COUNT */
1988
1989 PyObject *
1990 PyImport_ImportModule(const char *name)
1991 {
1992 PyObject *pname;
1993 PyObject *result;
1994
1995 pname = PyString_FromString(name);
1996 if (pname == NULL)
1997 return NULL;
1998 result = PyImport_Import(pname);
1999 Py_DECREF(pname);
2000 return result;
2001 }
2002
2003 /* Import a module without blocking
2004 *
2005 * At first it tries to fetch the module from sys.modules. If the module was
2006 * never loaded before it loads it with PyImport_ImportModule() unless another
2007 * thread holds the import lock. In the latter case the function raises an
2008 * ImportError instead of blocking.
2009 *
2010 * Returns the module object with incremented ref count.
2011 */
2012 PyObject *
2013 PyImport_ImportModuleNoBlock(const char *name)
2014 {
2015 PyObject *result;
2016 PyObject *modules;
2017 long me;
2018
2019 /* Try to get the module from sys.modules[name] */
2020 modules = PyImport_GetModuleDict();
2021 if (modules == NULL)
2022 return NULL;
2023
2024 result = PyDict_GetItemString(modules, name);
2025 if (result != NULL) {
2026 Py_INCREF(result);
2027 return result;
2028 }
2029 else {
2030 PyErr_Clear();
2031 }
2032
2033 /* check the import lock
2034 * me might be -1 but I ignore the error here, the lock function
2035 * takes care of the problem */
2036 me = PyThread_get_thread_ident();
2037 if (import_lock_thread == -1 || import_lock_thread == me) {
2038 /* no thread or me is holding the lock */
2039 return PyImport_ImportModule(name);
2040 }
2041 else {
2042 PyErr_Format(PyExc_ImportError,
2043 "Failed to import %.200s because the import lock"
2044 "is held by another thread.",
2045 name);
2046 return NULL;
2047 }
2048 }
2049
2050 /* Forward declarations for helper routines */
2051 static PyObject *get_parent(PyObject *globals, char *buf,
2052 Py_ssize_t *p_buflen, int level);
2053 static PyObject *load_next(PyObject *mod, PyObject *altmod,
2054 char **p_name, char *buf, Py_ssize_t *p_buflen);
2055 static int mark_miss(char *name);
2056 static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
2057 char *buf, Py_ssize_t buflen, int recursive);
2058 static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
2059
2060 /* The Magnum Opus of dotted-name import :-) */
2061
2062 static PyObject *
2063 import_module_level(char *name, PyObject *globals, PyObject *locals,
2064 PyObject *fromlist, int level)
2065 {
2066 char buf[MAXPATHLEN+1];
2067 Py_ssize_t buflen = 0;
2068 PyObject *parent, *head, *next, *tail;
2069
2070 if (strchr(name, '/') != NULL
2071 #ifdef MS_WINDOWS
2072 || strchr(name, '\\') != NULL
2073 #endif
2074 ) {
2075 PyErr_SetString(PyExc_ImportError,
2076 "Import by filename is not supported.");
2077 return NULL;
2078 }
2079
2080 parent = get_parent(globals, buf, &buflen, level);
2081 if (parent == NULL)
2082 return NULL;
2083
2084 head = load_next(parent, Py_None, &name, buf, &buflen);
2085 if (head == NULL)
2086 return NULL;
2087
2088 tail = head;
2089 Py_INCREF(tail);
2090 while (name) {
2091 next = load_next(tail, tail, &name, buf, &buflen);
2092 Py_DECREF(tail);
2093 if (next == NULL) {
2094 Py_DECREF(head);
2095 return NULL;
2096 }
2097 tail = next;
2098 }
2099 if (tail == Py_None) {
2100 /* If tail is Py_None, both get_parent and load_next found
2101 an empty module name: someone called __import__("") or
2102 doctored faulty bytecode */
2103 Py_DECREF(tail);
2104 Py_DECREF(head);
2105 PyErr_SetString(PyExc_ValueError,
2106 "Empty module name");
2107 return NULL;
2108 }
2109
2110 if (fromlist != NULL) {
2111 if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
2112 fromlist = NULL;
2113 }
2114
2115 if (fromlist == NULL) {
2116 Py_DECREF(tail);
2117 return head;
2118 }
2119
2120 Py_DECREF(head);
2121 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
2122 Py_DECREF(tail);
2123 return NULL;
2124 }
2125
2126 return tail;
2127 }
2128
2129 PyObject *
2130 PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
2131 PyObject *fromlist, int level)
2132 {
2133 PyObject *result;
2134 lock_import();
2135 result = import_module_level(name, globals, locals, fromlist, level);
2136 if (unlock_import() < 0) {
2137 Py_XDECREF(result);
2138 PyErr_SetString(PyExc_RuntimeError,
2139 "not holding the import lock");
2140 return NULL;
2141 }
2142 return result;
2143 }
2144
2145 /* Return the package that an import is being performed in. If globals comes
2146 from the module foo.bar.bat (not itself a package), this returns the
2147 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2148 the package's entry in sys.modules is returned, as a borrowed reference.
2149
2150 The *name* of the returned package is returned in buf, with the length of
2151 the name in *p_buflen.
2152
2153 If globals doesn't come from a package or a module in a package, or a
2154 corresponding entry is not found in sys.modules, Py_None is returned.
2155 */
2156 static PyObject *
2157 get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
2158 {
2159 static PyObject *namestr = NULL;
2160 static PyObject *pathstr = NULL;
2161 static PyObject *pkgstr = NULL;
2162 PyObject *pkgname, *modname, *modpath, *modules, *parent;
2163
2164 if (globals == NULL || !PyDict_Check(globals) || !level)
2165 return Py_None;
2166
2167 if (namestr == NULL) {
2168 namestr = PyString_InternFromString("__name__");
2169 if (namestr == NULL)
2170 return NULL;
2171 }
2172 if (pathstr == NULL) {
2173 pathstr = PyString_InternFromString("__path__");
2174 if (pathstr == NULL)
2175 return NULL;
2176 }
2177 if (pkgstr == NULL) {
2178 pkgstr = PyString_InternFromString("__package__");
2179 if (pkgstr == NULL)
2180 return NULL;
2181 }
2182
2183 *buf = '\0';
2184 *p_buflen = 0;
2185 pkgname = PyDict_GetItem(globals, pkgstr);
2186
2187 if ((pkgname != NULL) && (pkgname != Py_None)) {
2188 /* __package__ is set, so use it */
2189 Py_ssize_t len;
2190 if (!PyString_Check(pkgname)) {
2191 PyErr_SetString(PyExc_ValueError,
2192 "__package__ set to non-string");
2193 return NULL;
2194 }
2195 len = PyString_GET_SIZE(pkgname);
2196 if (len == 0) {
2197 if (level > 0) {
2198 PyErr_SetString(PyExc_ValueError,
2199 "Attempted relative import in non-package");
2200 return NULL;
2201 }
2202 return Py_None;
2203 }
2204 if (len > MAXPATHLEN) {
2205 PyErr_SetString(PyExc_ValueError,
2206 "Package name too long");
2207 return NULL;
2208 }
2209 strcpy(buf, PyString_AS_STRING(pkgname));
2210 } else {
2211 /* __package__ not set, so figure it out and set it */
2212 modname = PyDict_GetItem(globals, namestr);
2213 if (modname == NULL || !PyString_Check(modname))
2214 return Py_None;
2215
2216 modpath = PyDict_GetItem(globals, pathstr);
2217 if (modpath != NULL) {
2218 /* __path__ is set, so modname is already the package name */
2219 Py_ssize_t len = PyString_GET_SIZE(modname);
2220 int error;
2221 if (len > MAXPATHLEN) {
2222 PyErr_SetString(PyExc_ValueError,
2223 "Module name too long");
2224 return NULL;
2225 }
2226 strcpy(buf, PyString_AS_STRING(modname));
2227 error = PyDict_SetItem(globals, pkgstr, modname);
2228 if (error) {
2229 PyErr_SetString(PyExc_ValueError,
2230 "Could not set __package__");
2231 return NULL;
2232 }
2233 } else {
2234 /* Normal module, so work out the package name if any */
2235 char *start = PyString_AS_STRING(modname);
2236 char *lastdot = strrchr(start, '.');
2237 size_t len;
2238 int error;
2239 if (lastdot == NULL && level > 0) {
2240 PyErr_SetString(PyExc_ValueError,
2241 "Attempted relative import in non-package");
2242 return NULL;
2243 }
2244 if (lastdot == NULL) {
2245 error = PyDict_SetItem(globals, pkgstr, Py_None);
2246 if (error) {
2247 PyErr_SetString(PyExc_ValueError,
2248 "Could not set __package__");
2249 return NULL;
2250 }
2251 return Py_None;
2252 }
2253 len = lastdot - start;
2254 if (len >= MAXPATHLEN) {
2255 PyErr_SetString(PyExc_ValueError,
2256 "Module name too long");
2257 return NULL;
2258 }
2259 strncpy(buf, start, len);
2260 buf[len] = '\0';
2261 pkgname = PyString_FromString(buf);
2262 if (pkgname == NULL) {
2263 return NULL;
2264 }
2265 error = PyDict_SetItem(globals, pkgstr, pkgname);
2266 Py_DECREF(pkgname);
2267 if (error) {
2268 PyErr_SetString(PyExc_ValueError,
2269 "Could not set __package__");
2270 return NULL;
2271 }
2272 }
2273 }
2274 while (--level > 0) {
2275 char *dot = strrchr(buf, '.');
2276 if (dot == NULL) {
2277 PyErr_SetString(PyExc_ValueError,
2278 "Attempted relative import beyond "
2279 "toplevel package");
2280 return NULL;
2281 }
2282 *dot = '\0';
2283 }
2284 *p_buflen = strlen(buf);
2285
2286 modules = PyImport_GetModuleDict();
2287 parent = PyDict_GetItemString(modules, buf);
2288 if (parent == NULL)
2289 PyErr_Format(PyExc_SystemError,
2290 "Parent module '%.200s' not loaded", buf);
2291 return parent;
2292 /* We expect, but can't guarantee, if parent != None, that:
2293 - parent.__name__ == buf
2294 - parent.__dict__ is globals
2295 If this is violated... Who cares? */
2296 }
2297
2298 /* altmod is either None or same as mod */
2299 static PyObject *
2300 load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
2301 Py_ssize_t *p_buflen)
2302 {
2303 char *name = *p_name;
2304 char *dot = strchr(name, '.');
2305 size_t len;
2306 char *p;
2307 PyObject *result;
2308
2309 if (strlen(name) == 0) {
2310 /* completely empty module name should only happen in
2311 'from . import' (or '__import__("")')*/
2312 Py_INCREF(mod);
2313 *p_name = NULL;
2314 return mod;
2315 }
2316
2317 if (dot == NULL) {
2318 *p_name = NULL;
2319 len = strlen(name);
2320 }
2321 else {
2322 *p_name = dot+1;
2323 len = dot-name;
2324 }
2325 if (len == 0) {
2326 PyErr_SetString(PyExc_ValueError,
2327 "Empty module name");
2328 return NULL;
2329 }
2330
2331 p = buf + *p_buflen;
2332 if (p != buf)
2333 *p++ = '.';
2334 if (p+len-buf >= MAXPATHLEN) {
2335 PyErr_SetString(PyExc_ValueError,
2336 "Module name too long");
2337 return NULL;
2338 }
2339 strncpy(p, name, len);
2340 p[len] = '\0';
2341 *p_buflen = p+len-buf;
2342
2343 result = import_submodule(mod, p, buf);
2344 if (result == Py_None && altmod != mod) {
2345 Py_DECREF(result);
2346 /* Here, altmod must be None and mod must not be None */
2347 result = import_submodule(altmod, p, p);
2348 if (result != NULL && result != Py_None) {
2349 if (mark_miss(buf) != 0) {
2350 Py_DECREF(result);
2351 return NULL;
2352 }
2353 strncpy(buf, name, len);
2354 buf[len] = '\0';
2355 *p_buflen = len;
2356 }
2357 }
2358 if (result == NULL)
2359 return NULL;
2360
2361 if (result == Py_None) {
2362 Py_DECREF(result);
2363 PyErr_Format(PyExc_ImportError,
2364 "No module named %.200s", name);
2365 return NULL;
2366 }
2367
2368 return result;
2369 }
2370
2371 static int
2372 mark_miss(char *name)
2373 {
2374 PyObject *modules = PyImport_GetModuleDict();
2375 return PyDict_SetItemString(modules, name, Py_None);
2376 }
2377
2378 static int
2379 ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
2380 int recursive)
2381 {
2382 int i;
2383
2384 if (!PyObject_HasAttrString(mod, "__path__"))
2385 return 1;
2386
2387 for (i = 0; ; i++) {
2388 PyObject *item = PySequence_GetItem(fromlist, i);
2389 int hasit;
2390 if (item == NULL) {
2391 if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2392 PyErr_Clear();
2393 return 1;
2394 }
2395 return 0;
2396 }
2397 if (!PyString_Check(item)) {
2398 PyErr_SetString(PyExc_TypeError,
2399 "Item in ``from list'' not a string");
2400 Py_DECREF(item);
2401 return 0;
2402 }
2403 if (PyString_AS_STRING(item)[0] == '*') {
2404 PyObject *all;
2405 Py_DECREF(item);
2406 /* See if the package defines __all__ */
2407 if (recursive)
2408 continue; /* Avoid endless recursion */
2409 all = PyObject_GetAttrString(mod, "__all__");
2410 if (all == NULL)
2411 PyErr_Clear();
2412 else {
2413 int ret = ensure_fromlist(mod, all, buf, buflen, 1);
2414 Py_DECREF(all);
2415 if (!ret)
2416 return 0;
2417 }
2418 continue;
2419 }
2420 hasit = PyObject_HasAttr(mod, item);
2421 if (!hasit) {
2422 char *subname = PyString_AS_STRING(item);
2423 PyObject *submod;
2424 char *p;
2425 if (buflen + strlen(subname) >= MAXPATHLEN) {
2426 PyErr_SetString(PyExc_ValueError,
2427 "Module name too long");
2428 Py_DECREF(item);
2429 return 0;
2430 }
2431 p = buf + buflen;
2432 *p++ = '.';
2433 strcpy(p, subname);
2434 submod = import_submodule(mod, subname, buf);
2435 Py_XDECREF(submod);
2436 if (submod == NULL) {
2437 Py_DECREF(item);
2438 return 0;
2439 }
2440 }
2441 Py_DECREF(item);
2442 }
2443
2444 /* NOTREACHED */
2445 }
2446
2447 static int
2448 add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
2449 PyObject *modules)
2450 {
2451 if (mod == Py_None)
2452 return 1;
2453 /* Irrespective of the success of this load, make a
2454 reference to it in the parent package module. A copy gets
2455 saved in the modules dictionary under the full name, so get a
2456 reference from there, if need be. (The exception is when the
2457 load failed with a SyntaxError -- then there's no trace in
2458 sys.modules. In that case, of course, do nothing extra.) */
2459 if (submod == NULL) {
2460 submod = PyDict_GetItemString(modules, fullname);
2461 if (submod == NULL)
2462 return 1;
2463 }
2464 if (PyModule_Check(mod)) {
2465 /* We can't use setattr here since it can give a
2466 * spurious warning if the submodule name shadows a
2467 * builtin name */
2468 PyObject *dict = PyModule_GetDict(mod);
2469 if (!dict)
2470 return 0;
2471 if (PyDict_SetItemString(dict, subname, submod) < 0)
2472 return 0;
2473 }
2474 else {
2475 if (PyObject_SetAttrString(mod, subname, submod) < 0)
2476 return 0;
2477 }
2478 return 1;
2479 }
2480
2481 static PyObject *
2482 import_submodule(PyObject *mod, char *subname, char *fullname)
2483 {
2484 PyObject *modules = PyImport_GetModuleDict();
2485 PyObject *m = NULL;
2486
2487 /* Require:
2488 if mod == None: subname == fullname
2489 else: mod.__name__ + "." + subname == fullname
2490 */
2491
2492 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
2493 Py_INCREF(m);
2494 }
2495 else {
2496 PyObject *path, *loader = NULL;
2497 char buf[MAXPATHLEN+1];
2498 struct filedescr *fdp;
2499 FILE *fp = NULL;
2500
2501 if (mod == Py_None)
2502 path = NULL;
2503 else {
2504 path = PyObject_GetAttrString(mod, "__path__");
2505 if (path == NULL) {
2506 PyErr_Clear();
2507 Py_INCREF(Py_None);
2508 return Py_None;
2509 }
2510 }
2511
2512 buf[0] = '\0';
2513 fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
2514 &fp, &loader);
2515 Py_XDECREF(path);
2516 if (fdp == NULL) {
2517 if (!PyErr_ExceptionMatches(PyExc_ImportError))
2518 return NULL;
2519 PyErr_Clear();
2520 Py_INCREF(Py_None);
2521 return Py_None;
2522 }
2523 m = load_module(fullname, fp, buf, fdp->type, loader);
2524 Py_XDECREF(loader);
2525 if (fp)
2526 fclose(fp);
2527 if (!add_submodule(mod, m, fullname, subname, modules)) {
2528 Py_XDECREF(m);
2529 m = NULL;
2530 }
2531 }
2532
2533 return m;
2534 }
2535
2536
2537 /* Re-import a module of any kind and return its module object, WITH
2538 INCREMENTED REFERENCE COUNT */
2539
2540 PyObject *
2541 PyImport_ReloadModule(PyObject *m)
2542 {
2543 PyInterpreterState *interp = PyThreadState_Get()->interp;
2544 PyObject *modules_reloading = interp->modules_reloading;
2545 PyObject *modules = PyImport_GetModuleDict();
2546 PyObject *path = NULL, *loader = NULL, *existing_m = NULL;
2547 char *name, *subname;
2548 char buf[MAXPATHLEN+1];
2549 struct filedescr *fdp;
2550 FILE *fp = NULL;
2551 PyObject *newm;
2552
2553 if (modules_reloading == NULL) {
2554 Py_FatalError("PyImport_ReloadModule: "
2555 "no modules_reloading dictionary!");
2556 return NULL;
2557 }
2558
2559 if (m == NULL || !PyModule_Check(m)) {
2560 PyErr_SetString(PyExc_TypeError,
2561 "reload() argument must be module");
2562 return NULL;
2563 }
2564 name = PyModule_GetName(m);
2565 if (name == NULL)
2566 return NULL;
2567 if (m != PyDict_GetItemString(modules, name)) {
2568 PyErr_Format(PyExc_ImportError,
2569 "reload(): module %.200s not in sys.modules",
2570 name);
2571 return NULL;
2572 }
2573 existing_m = PyDict_GetItemString(modules_reloading, name);
2574 if (existing_m != NULL) {
2575 /* Due to a recursive reload, this module is already
2576 being reloaded. */
2577 Py_INCREF(existing_m);
2578 return existing_m;
2579 }
2580 if (PyDict_SetItemString(modules_reloading, name, m) < 0)
2581 return NULL;
2582
2583 subname = strrchr(name, '.');
2584 if (subname == NULL)
2585 subname = name;
2586 else {
2587 PyObject *parentname, *parent;
2588 parentname = PyString_FromStringAndSize(name, (subname-name));
2589 if (parentname == NULL) {
2590 imp_modules_reloading_clear();
2591 return NULL;
2592 }
2593 parent = PyDict_GetItem(modules, parentname);
2594 if (parent == NULL) {
2595 PyErr_Format(PyExc_ImportError,
2596 "reload(): parent %.200s not in sys.modules",
2597 PyString_AS_STRING(parentname));
2598 Py_DECREF(parentname);
2599 imp_modules_reloading_clear();
2600 return NULL;
2601 }
2602 Py_DECREF(parentname);
2603 subname++;
2604 path = PyObject_GetAttrString(parent, "__path__");
2605 if (path == NULL)
2606 PyErr_Clear();
2607 }
2608 buf[0] = '\0';
2609 fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
2610 Py_XDECREF(path);
2611
2612 if (fdp == NULL) {
2613 Py_XDECREF(loader);
2614 imp_modules_reloading_clear();
2615 return NULL;
2616 }
2617
2618 newm = load_module(name, fp, buf, fdp->type, loader);
2619 Py_XDECREF(loader);
2620
2621 if (fp)
2622 fclose(fp);
2623 if (newm == NULL) {
2624 /* load_module probably removed name from modules because of
2625 * the error. Put back the original module object. We're
2626 * going to return NULL in this case regardless of whether
2627 * replacing name succeeds, so the return value is ignored.
2628 */
2629 PyDict_SetItemString(modules, name, m);
2630 }
2631 imp_modules_reloading_clear();
2632 return newm;
2633 }
2634
2635
2636 /* Higher-level import emulator which emulates the "import" statement
2637 more accurately -- it invokes the __import__() function from the
2638 builtins of the current globals. This means that the import is
2639 done using whatever import hooks are installed in the current
2640 environment, e.g. by "rexec".
2641 A dummy list ["__doc__"] is passed as the 4th argument so that
2642 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2643 will return <module "gencache"> instead of <module "win32com">. */
2644
2645 PyObject *
2646 PyImport_Import(PyObject *module_name)
2647 {
2648 static PyObject *silly_list = NULL;
2649 static PyObject *builtins_str = NULL;
2650 static PyObject *import_str = NULL;
2651 PyObject *globals = NULL;
2652 PyObject *import = NULL;
2653 PyObject *builtins = NULL;
2654 PyObject *r = NULL;
2655
2656 /* Initialize constant string objects */
2657 if (silly_list == NULL) {
2658 import_str = PyString_InternFromString("__import__");
2659 if (import_str == NULL)
2660 return NULL;
2661 builtins_str = PyString_InternFromString("__builtins__");
2662 if (builtins_str == NULL)
2663 return NULL;
2664 silly_list = Py_BuildValue("[s]", "__doc__");
2665 if (silly_list == NULL)
2666 return NULL;
2667 }
2668
2669 /* Get the builtins from current globals */
2670 globals = PyEval_GetGlobals();
2671 if (globals != NULL) {
2672 Py_INCREF(globals);
2673 builtins = PyObject_GetItem(globals, builtins_str);
2674 if (builtins == NULL)
2675 goto err;
2676 }
2677 else {
2678 /* No globals -- use standard builtins, and fake globals */
2679 PyErr_Clear();
2680
2681 builtins = PyImport_ImportModuleLevel("__builtin__",
2682 NULL, NULL, NULL, 0);
2683 if (builtins == NULL)
2684 return NULL;
2685 globals = Py_BuildValue("{OO}", builtins_str, builtins);
2686 if (globals == NULL)
2687 goto err;
2688 }
2689
2690 /* Get the __import__ function from the builtins */
2691 if (PyDict_Check(builtins)) {
2692 import = PyObject_GetItem(builtins, import_str);
2693 if (import == NULL)
2694 PyErr_SetObject(PyExc_KeyError, import_str);
2695 }
2696 else
2697 import = PyObject_GetAttr(builtins, import_str);
2698 if (import == NULL)
2699 goto err;
2700
2701 /* Call the __import__ function with the proper argument list
2702 * Always use absolute import here. */
2703 r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
2704 globals, silly_list, 0, NULL);
2705
2706 err:
2707 Py_XDECREF(globals);
2708 Py_XDECREF(builtins);
2709 Py_XDECREF(import);
2710
2711 return r;
2712 }
2713
2714
2715 /* Module 'imp' provides Python access to the primitives used for
2716 importing modules.
2717 */
2718
2719 static PyObject *
2720 imp_get_magic(PyObject *self, PyObject *noargs)
2721 {
2722 char buf[4];
2723
2724 buf[0] = (char) ((pyc_magic >> 0) & 0xff);
2725 buf[1] = (char) ((pyc_magic >> 8) & 0xff);
2726 buf[2] = (char) ((pyc_magic >> 16) & 0xff);
2727 buf[3] = (char) ((pyc_magic >> 24) & 0xff);
2728
2729 return PyString_FromStringAndSize(buf, 4);
2730 }
2731
2732 static PyObject *
2733 imp_get_suffixes(PyObject *self, PyObject *noargs)
2734 {
2735 PyObject *list;
2736 struct filedescr *fdp;
2737
2738 list = PyList_New(0);
2739 if (list == NULL)
2740 return NULL;
2741 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
2742 PyObject *item = Py_BuildValue("ssi",
2743 fdp->suffix, fdp->mode, fdp->type);
2744 if (item == NULL) {
2745 Py_DECREF(list);
2746 return NULL;
2747 }
2748 if (PyList_Append(list, item) < 0) {
2749 Py_DECREF(list);
2750 Py_DECREF(item);
2751 return NULL;
2752 }
2753 Py_DECREF(item);
2754 }
2755 return list;
2756 }
2757
2758 static PyObject *
2759 call_find_module(char *name, PyObject *path)
2760 {
2761 extern int fclose(FILE *);
2762 PyObject *fob, *ret;
2763 struct filedescr *fdp;
2764 char pathname[MAXPATHLEN+1];
2765 FILE *fp = NULL;
2766
2767 pathname[0] = '\0';
2768 if (path == Py_None)
2769 path = NULL;
2770 fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
2771 if (fdp == NULL)
2772 return NULL;
2773 if (fp != NULL) {
2774 fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);
2775 if (fob == NULL) {
2776 fclose(fp);
2777 return NULL;
2778 }
2779 }
2780 else {
2781 fob = Py_None;
2782 Py_INCREF(fob);
2783 }
2784 ret = Py_BuildValue("Os(ssi)",
2785 fob, pathname, fdp->suffix, fdp->mode, fdp->type);
2786 Py_DECREF(fob);
2787 return ret;
2788 }
2789
2790 static PyObject *
2791 imp_find_module(PyObject *self, PyObject *args)
2792 {
2793 char *name;
2794 PyObject *path = NULL;
2795 if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))
2796 return NULL;
2797 return call_find_module(name, path);
2798 }
2799
2800 static PyObject *
2801 imp_init_builtin(PyObject *self, PyObject *args)
2802 {
2803 char *name;
2804 int ret;
2805 PyObject *m;
2806 if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
2807 return NULL;
2808 ret = init_builtin(name);
2809 if (ret < 0)
2810 return NULL;
2811 if (ret == 0) {
2812 Py_INCREF(Py_None);
2813 return Py_None;
2814 }
2815 m = PyImport_AddModule(name);
2816 Py_XINCREF(m);
2817 return m;
2818 }
2819
2820 static PyObject *
2821 imp_init_frozen(PyObject *self, PyObject *args)
2822 {
2823 char *name;
2824 int ret;
2825 PyObject *m;
2826 if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
2827 return NULL;
2828 ret = PyImport_ImportFrozenModule(name);
2829 if (ret < 0)
2830 return NULL;
2831 if (ret == 0) {
2832 Py_INCREF(Py_None);
2833 return Py_None;
2834 }
2835 m = PyImport_AddModule(name);
2836 Py_XINCREF(m);
2837 return m;
2838 }
2839
2840 static PyObject *
2841 imp_get_frozen_object(PyObject *self, PyObject *args)
2842 {
2843 char *name;
2844
2845 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
2846 return NULL;
2847 return get_frozen_object(name);
2848 }
2849
2850 static PyObject *
2851 imp_is_builtin(PyObject *self, PyObject *args)
2852 {
2853 char *name;
2854 if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
2855 return NULL;
2856 return PyInt_FromLong(is_builtin(name));
2857 }
2858
2859 static PyObject *
2860 imp_is_frozen(PyObject *self, PyObject *args)
2861 {
2862 char *name;
2863 struct _frozen *p;
2864 if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
2865 return NULL;
2866 p = find_frozen(name);
2867 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
2868 }
2869
2870 static FILE *
2871 get_file(char *pathname, PyObject *fob, char *mode)
2872 {
2873 FILE *fp;
2874 if (fob == NULL) {
2875 if (mode[0] == 'U')
2876 mode = "r" PY_STDIOTEXTMODE;
2877 fp = fopen(pathname, mode);
2878 if (fp == NULL)
2879 PyErr_SetFromErrno(PyExc_IOError);
2880 }
2881 else {
2882 fp = PyFile_AsFile(fob);
2883 if (fp == NULL)
2884 PyErr_SetString(PyExc_ValueError,
2885 "bad/closed file object");
2886 }
2887 return fp;
2888 }
2889
2890 static PyObject *
2891 imp_load_compiled(PyObject *self, PyObject *args)
2892 {
2893 char *name;
2894 char *pathname;
2895 PyObject *fob = NULL;
2896 PyObject *m;
2897 FILE *fp;
2898 if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,
2899 &PyFile_Type, &fob))
2900 return NULL;
2901 fp = get_file(pathname, fob, "rb");
2902 if (fp == NULL)
2903 return NULL;
2904 m = load_compiled_module(name, pathname, fp);
2905 if (fob == NULL)
2906 fclose(fp);
2907 return m;
2908 }
2909
2910 #ifdef HAVE_DYNAMIC_LOADING
2911
2912 static PyObject *
2913 imp_load_dynamic(PyObject *self, PyObject *args)
2914 {
2915 char *name;
2916 char *pathname;
2917 PyObject *fob = NULL;
2918 PyObject *m;
2919 FILE *fp = NULL;
2920 if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,
2921 &PyFile_Type, &fob))
2922 return NULL;
2923 if (fob) {
2924 fp = get_file(pathname, fob, "r");
2925 if (fp == NULL)
2926 return NULL;
2927 }
2928 m = _PyImport_LoadDynamicModule(name, pathname, fp);
2929 return m;
2930 }
2931
2932 #endif /* HAVE_DYNAMIC_LOADING */
2933
2934 static PyObject *
2935 imp_load_source(PyObject *self, PyObject *args)
2936 {
2937 char *name;
2938 char *pathname;
2939 PyObject *fob = NULL;
2940 PyObject *m;
2941 FILE *fp;
2942 if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,
2943 &PyFile_Type, &fob))
2944 return NULL;
2945 fp = get_file(pathname, fob, "r");
2946 if (fp == NULL)
2947 return NULL;
2948 m = load_source_module(name, pathname, fp);
2949 if (fob == NULL)
2950 fclose(fp);
2951 return m;
2952 }
2953
2954 static PyObject *
2955 imp_load_module(PyObject *self, PyObject *args)
2956 {
2957 char *name;
2958 PyObject *fob;
2959 char *pathname;
2960 char *suffix; /* Unused */
2961 char *mode;
2962 int type;
2963 FILE *fp;
2964
2965 if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
2966 &name, &fob, &pathname,
2967 &suffix, &mode, &type))
2968 return NULL;
2969 if (*mode) {
2970 /* Mode must start with 'r' or 'U' and must not contain '+'.
2971 Implicit in this test is the assumption that the mode
2972 may contain other modifiers like 'b' or 't'. */
2973
2974 if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
2975 PyErr_Format(PyExc_ValueError,
2976 "invalid file open mode %.200s", mode);
2977 return NULL;
2978 }
2979 }
2980 if (fob == Py_None)
2981 fp = NULL;
2982 else {
2983 if (!PyFile_Check(fob)) {
2984 PyErr_SetString(PyExc_ValueError,
2985 "load_module arg#2 should be a file or None");
2986 return NULL;
2987 }
2988 fp = get_file(pathname, fob, mode);
2989 if (fp == NULL)
2990 return NULL;
2991 }
2992 return load_module(name, fp, pathname, type, NULL);
2993 }
2994
2995 static PyObject *
2996 imp_load_package(PyObject *self, PyObject *args)
2997 {
2998 char *name;
2999 char *pathname;
3000 if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
3001 return NULL;
3002 return load_package(name, pathname);
3003 }
3004
3005 static PyObject *
3006 imp_new_module(PyObject *self, PyObject *args)
3007 {
3008 char *name;
3009 if (!PyArg_ParseTuple(args, "s:new_module", &name))
3010 return NULL;
3011 return PyModule_New(name);
3012 }
3013
3014 /* Doc strings */
3015
3016 PyDoc_STRVAR(doc_imp,
3017 "This module provides the components needed to build your own\n\
3018 __import__ function. Undocumented functions are obsolete.");
3019
3020 PyDoc_STRVAR(doc_find_module,
3021 "find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
3022 Search for a module. If path is omitted or None, search for a\n\
3023 built-in, frozen or special module and continue search in sys.path.\n\
3024 The module name cannot contain '.'; to search for a submodule of a\n\
3025 package, pass the submodule name and the package's __path__.");
3026
3027 PyDoc_STRVAR(doc_load_module,
3028 "load_module(name, file, filename, (suffix, mode, type)) -> module\n\
3029 Load a module, given information returned by find_module().\n\
3030 The module name must include the full package name, if any.");
3031
3032 PyDoc_STRVAR(doc_get_magic,
3033 "get_magic() -> string\n\
3034 Return the magic number for .pyc or .pyo files.");
3035
3036 PyDoc_STRVAR(doc_get_suffixes,
3037 "get_suffixes() -> [(suffix, mode, type), ...]\n\
3038 Return a list of (suffix, mode, type) tuples describing the files\n\
3039 that find_module() looks for.");
3040
3041 PyDoc_STRVAR(doc_new_module,
3042 "new_module(name) -> module\n\
3043 Create a new module. Do not enter it in sys.modules.\n\
3044 The module name must include the full package name, if any.");
3045
3046 PyDoc_STRVAR(doc_lock_held,
3047 "lock_held() -> boolean\n\
3048 Return True if the import lock is currently held, else False.\n\
3049 On platforms without threads, return False.");
3050
3051 PyDoc_STRVAR(doc_acquire_lock,
3052 "acquire_lock() -> None\n\
3053 Acquires the interpreter's import lock for the current thread.\n\
3054 This lock should be used by import hooks to ensure thread-safety\n\
3055 when importing modules.\n\
3056 On platforms without threads, this function does nothing.");
3057
3058 PyDoc_STRVAR(doc_release_lock,
3059 "release_lock() -> None\n\
3060 Release the interpreter's import lock.\n\
3061 On platforms without threads, this function does nothing.");
3062
3063 static PyMethodDef imp_methods[] = {
3064 {"find_module", imp_find_module, METH_VARARGS, doc_find_module},
3065 {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},
3066 {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},
3067 {"load_module", imp_load_module, METH_VARARGS, doc_load_module},
3068 {"new_module", imp_new_module, METH_VARARGS, doc_new_module},
3069 {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
3070 {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
3071 {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
3072 /* The rest are obsolete */
3073 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
3074 {"init_builtin", imp_init_builtin, METH_VARARGS},
3075 {"init_frozen", imp_init_frozen, METH_VARARGS},
3076 {"is_builtin", imp_is_builtin, METH_VARARGS},
3077 {"is_frozen", imp_is_frozen, METH_VARARGS},
3078 {"load_compiled", imp_load_compiled, METH_VARARGS},
3079 #ifdef HAVE_DYNAMIC_LOADING
3080 {"load_dynamic", imp_load_dynamic, METH_VARARGS},
3081 #endif
3082 {"load_package", imp_load_package, METH_VARARGS},
3083 {"load_source", imp_load_source, METH_VARARGS},
3084 {NULL, NULL} /* sentinel */
3085 };
3086
3087 static int
3088 setint(PyObject *d, char *name, int value)
3089 {
3090 PyObject *v;
3091 int err;
3092
3093 v = PyInt_FromLong((long)value);
3094 err = PyDict_SetItemString(d, name, v);
3095 Py_XDECREF(v);
3096 return err;
3097 }
3098
3099 typedef struct {
3100 PyObject_HEAD
3101 } NullImporter;
3102
3103 static int
3104 NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds)
3105 {
3106 char *path;
3107 Py_ssize_t pathlen;
3108
3109 if (!_PyArg_NoKeywords("NullImporter()", kwds))
3110 return -1;
3111
3112 if (!PyArg_ParseTuple(args, "s:NullImporter",
3113 &path))
3114 return -1;
3115
3116 pathlen = strlen(path);
3117 if (pathlen == 0) {
3118 PyErr_SetString(PyExc_ImportError, "empty pathname");
3119 return -1;
3120 } else {
3121 #ifndef RISCOS
3122 struct stat statbuf;
3123 int rv;
3124
3125 rv = stat(path, &statbuf);
3126 #ifdef MS_WINDOWS
3127 /* MS Windows stat() chokes on paths like C:\path\. Try to
3128 * recover *one* time by stripping off a trailing slash or
3129 * backslash. http://bugs.python.org/issue1293
3130 */
3131 if (rv != 0 && pathlen <= MAXPATHLEN &&
3132 (path[pathlen-1] == '/' || path[pathlen-1] == '\\')) {
3133 char mangled[MAXPATHLEN+1];
3134
3135 strcpy(mangled, path);
3136 mangled[pathlen-1] = '\0';
3137 rv = stat(mangled, &statbuf);
3138 }
3139 #endif
3140 if (rv == 0) {
3141 /* it exists */
3142 if (S_ISDIR(statbuf.st_mode)) {
3143 /* it's a directory */
3144 PyErr_SetString(PyExc_ImportError,
3145 "existing directory");
3146 return -1;
3147 }
3148 }
3149 #else
3150 if (object_exists(path)) {
3151 /* it exists */
3152 if (isdir(path)) {
3153 /* it's a directory */
3154 PyErr_SetString(PyExc_ImportError,
3155 "existing directory");
3156 return -1;
3157 }
3158 }
3159 #endif
3160 }
3161 return 0;
3162 }
3163
3164 static PyObject *
3165 NullImporter_find_module(NullImporter *self, PyObject *args)
3166 {
3167 Py_RETURN_NONE;
3168 }
3169
3170 static PyMethodDef NullImporter_methods[] = {
3171 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
3172 "Always return None"
3173 },
3174 {NULL} /* Sentinel */
3175 };
3176
3177
3178 PyTypeObject PyNullImporter_Type = {
3179 PyVarObject_HEAD_INIT(NULL, 0)
3180 "imp.NullImporter", /*tp_name*/
3181 sizeof(NullImporter), /*tp_basicsize*/
3182 0, /*tp_itemsize*/
3183 0, /*tp_dealloc*/
3184 0, /*tp_print*/
3185 0, /*tp_getattr*/
3186 0, /*tp_setattr*/
3187 0, /*tp_compare*/
3188 0, /*tp_repr*/
3189 0, /*tp_as_number*/
3190 0, /*tp_as_sequence*/
3191 0, /*tp_as_mapping*/
3192 0, /*tp_hash */
3193 0, /*tp_call*/
3194 0, /*tp_str*/
3195 0, /*tp_getattro*/
3196 0, /*tp_setattro*/
3197 0, /*tp_as_buffer*/
3198 Py_TPFLAGS_DEFAULT, /*tp_flags*/
3199 "Null importer object", /* tp_doc */
3200 0, /* tp_traverse */
3201 0, /* tp_clear */
3202 0, /* tp_richcompare */
3203 0, /* tp_weaklistoffset */
3204 0, /* tp_iter */
3205 0, /* tp_iternext */
3206 NullImporter_methods, /* tp_methods */
3207 0, /* tp_members */
3208 0, /* tp_getset */
3209 0, /* tp_base */
3210 0, /* tp_dict */
3211 0, /* tp_descr_get */
3212 0, /* tp_descr_set */
3213 0, /* tp_dictoffset */
3214 (initproc)NullImporter_init, /* tp_init */
3215 0, /* tp_alloc */
3216 PyType_GenericNew /* tp_new */
3217 };
3218
3219
3220 PyMODINIT_FUNC
3221 initimp(void)
3222 {
3223 PyObject *m, *d;
3224
3225 if (PyType_Ready(&PyNullImporter_Type) < 0)
3226 goto failure;
3227
3228 m = Py_InitModule4("imp", imp_methods, doc_imp,
3229 NULL, PYTHON_API_VERSION);
3230 if (m == NULL)
3231 goto failure;
3232 d = PyModule_GetDict(m);
3233 if (d == NULL)
3234 goto failure;
3235
3236 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
3237 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
3238 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
3239 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
3240 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
3241 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
3242 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
3243 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
3244 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
3245 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
3246
3247 Py_INCREF(&PyNullImporter_Type);
3248 PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
3249 failure:
3250 ;
3251 }
3252
3253
3254 /* API for embedding applications that want to add their own entries
3255 to the table of built-in modules. This should normally be called
3256 *before* Py_Initialize(). When the table resize fails, -1 is
3257 returned and the existing table is unchanged.
3258
3259 After a similar function by Just van Rossum. */
3260
3261 int
3262 PyImport_ExtendInittab(struct _inittab *newtab)
3263 {
3264 static struct _inittab *our_copy = NULL;
3265 struct _inittab *p;
3266 int i, n;
3267
3268 /* Count the number of entries in both tables */
3269 for (n = 0; newtab[n].name != NULL; n++)
3270 ;
3271 if (n == 0)
3272 return 0; /* Nothing to do */
3273 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3274 ;
3275
3276 /* Allocate new memory for the combined table */
3277 p = our_copy;
3278 PyMem_RESIZE(p, struct _inittab, i+n+1);
3279 if (p == NULL)
3280 return -1;
3281
3282 /* Copy the tables into the new memory */
3283 if (our_copy != PyImport_Inittab)
3284 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
3285 PyImport_Inittab = our_copy = p;
3286 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
3287
3288 return 0;
3289 }
3290
3291 /* Shorthand to add a single entry given a name and a function */
3292
3293 int
3294 PyImport_AppendInittab(char *name, void (*initfunc)(void))
3295 {
3296 struct _inittab newtab[2];
3297
3298 memset(newtab, '\0', sizeof newtab);
3299
3300 newtab[0].name = name;
3301 newtab[0].initfunc = initfunc;
3302
3303 return PyImport_ExtendInittab(newtab);
3304 }
3305
3306 #ifdef __cplusplus
3307 }
3308 #endif
python git mirror