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