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