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