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