?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Issue #7282: Fix a memory leak when an RLock was used in a thread other
[python.git] / Python / import.c
blob3ca452a9840657b3459bf144839bea4fcaa6b114
1
2 /* Module definition and import implementation */
3
4 #include "Python.h"
5
6 #include "Python-ast.h"
7 #undef Yield /* undefine macro conflicting with winbase.h */
8 #include "pyarena.h"
9 #include "pythonrun.h"
10 #include "errcode.h"
11 #include "marshal.h"
12 #include "code.h"
13 #include "compile.h"
14 #include "eval.h"
15 #include "osdefs.h"
16 #include "importdl.h"
17
18 #ifdef HAVE_FCNTL_H
19 #include <fcntl.h>
20 #endif
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 #ifdef MS_WINDOWS
26 /* for stat.st_mode */
27 typedef unsigned short mode_t;
28 #endif
29
30
31 /* Magic word to reject .pyc files generated by other Python versions.
32 It should change for each incompatible change to the bytecode.
33
34 The value of CR and LF is incorporated so if you ever read or write
35 a .pyc file in text mode the magic number will be wrong; also, the
36 Apple MPW compiler swaps their values, botching string constants.
37
38 The magic numbers must be spaced apart atleast 2 values, as the
39 -U interpeter flag will cause MAGIC+1 being used. They have been
40 odd numbers for some time now.
41
42 There were a variety of old schemes for setting the magic number.
43 The current working scheme is to increment the previous value by
44 10.
45
46 Known values:
47 Python 1.5: 20121
48 Python 1.5.1: 20121
49 Python 1.5.2: 20121
50 Python 1.6: 50428
51 Python 2.0: 50823
52 Python 2.0.1: 50823
53 Python 2.1: 60202
54 Python 2.1.1: 60202
55 Python 2.1.2: 60202
56 Python 2.2: 60717
57 Python 2.3a0: 62011
58 Python 2.3a0: 62021
59 Python 2.3a0: 62011 (!)
60 Python 2.4a0: 62041
61 Python 2.4a3: 62051
62 Python 2.4b1: 62061
63 Python 2.5a0: 62071
64 Python 2.5a0: 62081 (ast-branch)
65 Python 2.5a0: 62091 (with)
66 Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)
67 Python 2.5b3: 62101 (fix wrong code: for x, in ...)
68 Python 2.5b3: 62111 (fix wrong code: x += yield)
69 Python 2.5c1: 62121 (fix wrong lnotab with for loops and
70 storing constants that should have been removed)
71 Python 2.5c2: 62131 (fix wrong code: for x, in ... in listcomp/genexp)
72 Python 2.6a0: 62151 (peephole optimizations and STORE_MAP opcode)
73 Python 2.6a1: 62161 (WITH_CLEANUP optimization)
74 Python 2.7a0: 62171 (optimize list comprehensions/change LIST_APPEND)
75 Python 2.7a0: 62181 (optimize conditional branches:
76 introduce POP_JUMP_IF_FALSE and POP_JUMP_IF_TRUE)
77 Python 2.7a0 62191 (introduce SETUP_WITH)
78 .
79 */
80 #define MAGIC (62191 | ((long)'\r'<<16) | ((long)'\n'<<24))
81
82 /* Magic word as global; note that _PyImport_Init() can change the
83 value of this global to accommodate for alterations of how the
84 compiler works which are enabled by command line switches. */
85 static long pyc_magic = MAGIC;
86
87 /* See _PyImport_FixupExtension() below */
88 static PyObject *extensions = NULL;
89
90 /* This table is defined in config.c: */
91 extern struct _inittab _PyImport_Inittab[];
92
93 struct _inittab *PyImport_Inittab = _PyImport_Inittab;
94
95 /* these tables define the module suffixes that Python recognizes */
96 struct filedescr * _PyImport_Filetab = NULL;
97
98 #ifdef RISCOS
99 static const struct filedescr _PyImport_StandardFiletab[] = {
100 {"/py", "U", PY_SOURCE},
101 {"/pyc", "rb", PY_COMPILED},
102 {0, 0}
103 };
104 #else
105 static const struct filedescr _PyImport_StandardFiletab[] = {
106 {".py", "U", PY_SOURCE},
107 #ifdef MS_WINDOWS
108 {".pyw", "U", PY_SOURCE},
109 #endif
110 {".pyc", "rb", PY_COMPILED},
111 {0, 0}
112 };
113 #endif
114
115
116 /* Initialize things */
117
118 void
119 _PyImport_Init(void)
120 {
121 const struct filedescr *scan;
122 struct filedescr *filetab;
123 int countD = 0;
124 int countS = 0;
125
126 /* prepare _PyImport_Filetab: copy entries from
127 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
128 */
129 #ifdef HAVE_DYNAMIC_LOADING
130 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
131 ++countD;
132 #endif
133 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
134 ++countS;
135 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
136 if (filetab == NULL)
137 Py_FatalError("Can't initialize import file table.");
138 #ifdef HAVE_DYNAMIC_LOADING
139 memcpy(filetab, _PyImport_DynLoadFiletab,
140 countD * sizeof(struct filedescr));
141 #endif
142 memcpy(filetab + countD, _PyImport_StandardFiletab,
143 countS * sizeof(struct filedescr));
144 filetab[countD + countS].suffix = NULL;
145
146 _PyImport_Filetab = filetab;
147
148 if (Py_OptimizeFlag) {
149 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
150 for (; filetab->suffix != NULL; filetab++) {
151 #ifndef RISCOS
152 if (strcmp(filetab->suffix, ".pyc") == 0)
153 filetab->suffix = ".pyo";
154 #else
155 if (strcmp(filetab->suffix, "/pyc") == 0)
156 filetab->suffix = "/pyo";
157 #endif
158 }
159 }
160
161 if (Py_UnicodeFlag) {
162 /* Fix the pyc_magic so that byte compiled code created
163 using the all-Unicode method doesn't interfere with
164 code created in normal operation mode. */
165 pyc_magic = MAGIC + 1;
166 }
167 }
168
169 void
170 _PyImportHooks_Init(void)
171 {
172 PyObject *v, *path_hooks = NULL, *zimpimport;
173 int err = 0;
174
175 /* adding sys.path_hooks and sys.path_importer_cache, setting up
176 zipimport */
177 if (PyType_Ready(&PyNullImporter_Type) < 0)
178 goto error;
179
180 if (Py_VerboseFlag)
181 PySys_WriteStderr("# installing zipimport hook\n");
182
183 v = PyList_New(0);
184 if (v == NULL)
185 goto error;
186 err = PySys_SetObject("meta_path", v);
187 Py_DECREF(v);
188 if (err)
189 goto error;
190 v = PyDict_New();
191 if (v == NULL)
192 goto error;
193 err = PySys_SetObject("path_importer_cache", v);
194 Py_DECREF(v);
195 if (err)
196 goto error;
197 path_hooks = PyList_New(0);
198 if (path_hooks == NULL)
199 goto error;
200 err = PySys_SetObject("path_hooks", path_hooks);
201 if (err) {
202 error:
203 PyErr_Print();
204 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
205 "path_importer_cache, or NullImporter failed"
206 );
207 }
208
209 zimpimport = PyImport_ImportModule("zipimport");
210 if (zimpimport == NULL) {
211 PyErr_Clear(); /* No zip import module -- okay */
212 if (Py_VerboseFlag)
213 PySys_WriteStderr("# can't import zipimport\n");
214 }
215 else {
216 PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
217 "zipimporter");
218 Py_DECREF(zimpimport);
219 if (zipimporter == NULL) {
220 PyErr_Clear(); /* No zipimporter object -- okay */
221 if (Py_VerboseFlag)
222 PySys_WriteStderr(
223 "# can't import zipimport.zipimporter\n");
224 }
225 else {
226 /* sys.path_hooks.append(zipimporter) */
227 err = PyList_Append(path_hooks, zipimporter);
228 Py_DECREF(zipimporter);
229 if (err)
230 goto error;
231 if (Py_VerboseFlag)
232 PySys_WriteStderr(
233 "# installed zipimport hook\n");
234 }
235 }
236 Py_DECREF(path_hooks);
237 }
238
239 void
240 _PyImport_Fini(void)
241 {
242 Py_XDECREF(extensions);
243 extensions = NULL;
244 PyMem_DEL(_PyImport_Filetab);
245 _PyImport_Filetab = NULL;
246 }
247
248
249 /* Locking primitives to prevent parallel imports of the same module
250 in different threads to return with a partially loaded module.
251 These calls are serialized by the global interpreter lock. */
252
253 #ifdef WITH_THREAD
254
255 #include "pythread.h"
256
257 static PyThread_type_lock import_lock = 0;
258 static long import_lock_thread = -1;
259 static int import_lock_level = 0;
260
261 void
262 _PyImport_AcquireLock(void)
263 {
264 long me = PyThread_get_thread_ident();
265 if (me == -1)
266 return; /* Too bad */
267 if (import_lock == NULL) {
268 import_lock = PyThread_allocate_lock();
269 if (import_lock == NULL)
270 return; /* Nothing much we can do. */
271 }
272 if (import_lock_thread == me) {
273 import_lock_level++;
274 return;
275 }
276 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
277 {
278 PyThreadState *tstate = PyEval_SaveThread();
279 PyThread_acquire_lock(import_lock, 1);
280 PyEval_RestoreThread(tstate);
281 }
282 import_lock_thread = me;
283 import_lock_level = 1;
284 }
285
286 int
287 _PyImport_ReleaseLock(void)
288 {
289 long me = PyThread_get_thread_ident();
290 if (me == -1 || import_lock == NULL)
291 return 0; /* Too bad */
292 if (import_lock_thread != me)
293 return -1;
294 import_lock_level--;
295 if (import_lock_level == 0) {
296 import_lock_thread = -1;
297 PyThread_release_lock(import_lock);
298 }
299 return 1;
300 }
301
302 /* This function used to be called from PyOS_AfterFork to ensure that newly
303 created child processes do not share locks with the parent, but for some
304 reason only on AIX systems. Instead of re-initializing the lock, we now
305 acquire the import lock around fork() calls. */
306
307 void
308 _PyImport_ReInitLock(void)
309 {
310 }
311
312 #endif
313
314 static PyObject *
315 imp_lock_held(PyObject *self, PyObject *noargs)
316 {
317 #ifdef WITH_THREAD
318 return PyBool_FromLong(import_lock_thread != -1);
319 #else
320 return PyBool_FromLong(0);
321 #endif
322 }
323
324 static PyObject *
325 imp_acquire_lock(PyObject *self, PyObject *noargs)
326 {
327 #ifdef WITH_THREAD
328 _PyImport_AcquireLock();
329 #endif
330 Py_INCREF(Py_None);
331 return Py_None;
332 }
333
334 static PyObject *
335 imp_release_lock(PyObject *self, PyObject *noargs)
336 {
337 #ifdef WITH_THREAD
338 if (_PyImport_ReleaseLock() < 0) {
339 PyErr_SetString(PyExc_RuntimeError,
340 "not holding the import lock");
341 return NULL;
342 }
343 #endif
344 Py_INCREF(Py_None);
345 return Py_None;
346 }
347
348 static void
349 imp_modules_reloading_clear(void)
350 {
351 PyInterpreterState *interp = PyThreadState_Get()->interp;
352 if (interp->modules_reloading != NULL)
353 PyDict_Clear(interp->modules_reloading);
354 }
355
356 /* Helper for sys */
357
358 PyObject *
359 PyImport_GetModuleDict(void)
360 {
361 PyInterpreterState *interp = PyThreadState_GET()->interp;
362 if (interp->modules == NULL)
363 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
364 return interp->modules;
365 }
366
367
368 /* List of names to clear in sys */
369 static char* sys_deletes[] = {
370 "path", "argv", "ps1", "ps2", "exitfunc",
371 "exc_type", "exc_value", "exc_traceback",
372 "last_type", "last_value", "last_traceback",
373 "path_hooks", "path_importer_cache", "meta_path",
374 /* misc stuff */
375 "flags", "float_info",
376 NULL
377 };
378
379 static char* sys_files[] = {
380 "stdin", "__stdin__",
381 "stdout", "__stdout__",
382 "stderr", "__stderr__",
383 NULL
384 };
385
386
387 /* Un-initialize things, as good as we can */
388
389 void
390 PyImport_Cleanup(void)
391 {
392 Py_ssize_t pos, ndone;
393 char *name;
394 PyObject *key, *value, *dict;
395 PyInterpreterState *interp = PyThreadState_GET()->interp;
396 PyObject *modules = interp->modules;
397
398 if (modules == NULL)
399 return; /* Already done */
400
401 /* Delete some special variables first. These are common
402 places where user values hide and people complain when their
403 destructors fail. Since the modules containing them are
404 deleted *last* of all, they would come too late in the normal
405 destruction order. Sigh. */
406
407 value = PyDict_GetItemString(modules, "__builtin__");
408 if (value != NULL && PyModule_Check(value)) {
409 dict = PyModule_GetDict(value);
410 if (Py_VerboseFlag)
411 PySys_WriteStderr("# clear __builtin__._\n");
412 PyDict_SetItemString(dict, "_", Py_None);
413 }
414 value = PyDict_GetItemString(modules, "sys");
415 if (value != NULL && PyModule_Check(value)) {
416 char **p;
417 PyObject *v;
418 dict = PyModule_GetDict(value);
419 for (p = sys_deletes; *p != NULL; p++) {
420 if (Py_VerboseFlag)
421 PySys_WriteStderr("# clear sys.%s\n", *p);
422 PyDict_SetItemString(dict, *p, Py_None);
423 }
424 for (p = sys_files; *p != NULL; p+=2) {
425 if (Py_VerboseFlag)
426 PySys_WriteStderr("# restore sys.%s\n", *p);
427 v = PyDict_GetItemString(dict, *(p+1));
428 if (v == NULL)
429 v = Py_None;
430 PyDict_SetItemString(dict, *p, v);
431 }
432 }
433
434 /* First, delete __main__ */
435 value = PyDict_GetItemString(modules, "__main__");
436 if (value != NULL && PyModule_Check(value)) {
437 if (Py_VerboseFlag)
438 PySys_WriteStderr("# cleanup __main__\n");
439 _PyModule_Clear(value);
440 PyDict_SetItemString(modules, "__main__", Py_None);
441 }
442
443 /* The special treatment of __builtin__ here is because even
444 when it's not referenced as a module, its dictionary is
445 referenced by almost every module's __builtins__. Since
446 deleting a module clears its dictionary (even if there are
447 references left to it), we need to delete the __builtin__
448 module last. Likewise, we don't delete sys until the very
449 end because it is implicitly referenced (e.g. by print).
450
451 Also note that we 'delete' modules by replacing their entry
452 in the modules dict with None, rather than really deleting
453 them; this avoids a rehash of the modules dictionary and
454 also marks them as "non existent" so they won't be
455 re-imported. */
456
457 /* Next, repeatedly delete modules with a reference count of
458 one (skipping __builtin__ and sys) and delete them */
459 do {
460 ndone = 0;
461 pos = 0;
462 while (PyDict_Next(modules, &pos, &key, &value)) {
463 if (value->ob_refcnt != 1)
464 continue;
465 if (PyString_Check(key) && PyModule_Check(value)) {
466 name = PyString_AS_STRING(key);
467 if (strcmp(name, "__builtin__") == 0)
468 continue;
469 if (strcmp(name, "sys") == 0)
470 continue;
471 if (Py_VerboseFlag)
472 PySys_WriteStderr(
473 "# cleanup[1] %s\n", name);
474 _PyModule_Clear(value);
475 PyDict_SetItem(modules, key, Py_None);
476 ndone++;
477 }
478 }
479 } while (ndone > 0);
480
481 /* Next, delete all modules (still skipping __builtin__ and sys) */
482 pos = 0;
483 while (PyDict_Next(modules, &pos, &key, &value)) {
484 if (PyString_Check(key) && PyModule_Check(value)) {
485 name = PyString_AS_STRING(key);
486 if (strcmp(name, "__builtin__") == 0)
487 continue;
488 if (strcmp(name, "sys") == 0)
489 continue;
490 if (Py_VerboseFlag)
491 PySys_WriteStderr("# cleanup[2] %s\n", name);
492 _PyModule_Clear(value);
493 PyDict_SetItem(modules, key, Py_None);
494 }
495 }
496
497 /* Next, delete sys and __builtin__ (in that order) */
498 value = PyDict_GetItemString(modules, "sys");
499 if (value != NULL && PyModule_Check(value)) {
500 if (Py_VerboseFlag)
501 PySys_WriteStderr("# cleanup sys\n");
502 _PyModule_Clear(value);
503 PyDict_SetItemString(modules, "sys", Py_None);
504 }
505 value = PyDict_GetItemString(modules, "__builtin__");
506 if (value != NULL && PyModule_Check(value)) {
507 if (Py_VerboseFlag)
508 PySys_WriteStderr("# cleanup __builtin__\n");
509 _PyModule_Clear(value);
510 PyDict_SetItemString(modules, "__builtin__", Py_None);
511 }
512
513 /* Finally, clear and delete the modules directory */
514 PyDict_Clear(modules);
515 interp->modules = NULL;
516 Py_DECREF(modules);
517 Py_CLEAR(interp->modules_reloading);
518 }
519
520
521 /* Helper for pythonrun.c -- return magic number */
522
523 long
524 PyImport_GetMagicNumber(void)
525 {
526 return pyc_magic;
527 }
528
529
530 /* Magic for extension modules (built-in as well as dynamically
531 loaded). To prevent initializing an extension module more than
532 once, we keep a static dictionary 'extensions' keyed by module name
533 (for built-in modules) or by filename (for dynamically loaded
534 modules), containing these modules. A copy of the module's
535 dictionary is stored by calling _PyImport_FixupExtension()
536 immediately after the module initialization function succeeds. A
537 copy can be retrieved from there by calling
538 _PyImport_FindExtension(). */
539
540 PyObject *
541 _PyImport_FixupExtension(char *name, char *filename)
542 {
543 PyObject *modules, *mod, *dict, *copy;
544 if (extensions == NULL) {
545 extensions = PyDict_New();
546 if (extensions == NULL)
547 return NULL;
548 }
549 modules = PyImport_GetModuleDict();
550 mod = PyDict_GetItemString(modules, name);
551 if (mod == NULL || !PyModule_Check(mod)) {
552 PyErr_Format(PyExc_SystemError,
553 "_PyImport_FixupExtension: module %.200s not loaded", name);
554 return NULL;
555 }
556 dict = PyModule_GetDict(mod);
557 if (dict == NULL)
558 return NULL;
559 copy = PyDict_Copy(dict);
560 if (copy == NULL)
561 return NULL;
562 PyDict_SetItemString(extensions, filename, copy);
563 Py_DECREF(copy);
564 return copy;
565 }
566
567 PyObject *
568 _PyImport_FindExtension(char *name, char *filename)
569 {
570 PyObject *dict, *mod, *mdict;
571 if (extensions == NULL)
572 return NULL;
573 dict = PyDict_GetItemString(extensions, filename);
574 if (dict == NULL)
575 return NULL;
576 mod = PyImport_AddModule(name);
577 if (mod == NULL)
578 return NULL;
579 mdict = PyModule_GetDict(mod);
580 if (mdict == NULL)
581 return NULL;
582 if (PyDict_Update(mdict, dict))
583 return NULL;
584 if (Py_VerboseFlag)
585 PySys_WriteStderr("import %s # previously loaded (%s)\n",
586 name, filename);
587 return mod;
588 }
589
590
591 /* Get the module object corresponding to a module name.
592 First check the modules dictionary if there's one there,
593 if not, create a new one and insert it in the modules dictionary.
594 Because the former action is most common, THIS DOES NOT RETURN A
595 'NEW' REFERENCE! */
596
597 PyObject *
598 PyImport_AddModule(const char *name)
599 {
600 PyObject *modules = PyImport_GetModuleDict();
601 PyObject *m;
602
603 if ((m = PyDict_GetItemString(modules, name)) != NULL &&
604 PyModule_Check(m))
605 return m;
606 m = PyModule_New(name);
607 if (m == NULL)
608 return NULL;
609 if (PyDict_SetItemString(modules, name, m) != 0) {
610 Py_DECREF(m);
611 return NULL;
612 }
613 Py_DECREF(m); /* Yes, it still exists, in modules! */
614
615 return m;
616 }
617
618 /* Remove name from sys.modules, if it's there. */
619 static void
620 _RemoveModule(const char *name)
621 {
622 PyObject *modules = PyImport_GetModuleDict();
623 if (PyDict_GetItemString(modules, name) == NULL)
624 return;
625 if (PyDict_DelItemString(modules, name) < 0)
626 Py_FatalError("import: deleting existing key in"
627 "sys.modules failed");
628 }
629
630 /* Execute a code object in a module and return the module object
631 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
632 * removed from sys.modules, to avoid leaving damaged module objects
633 * in sys.modules. The caller may wish to restore the original
634 * module object (if any) in this case; PyImport_ReloadModule is an
635 * example.
636 */
637 PyObject *
638 PyImport_ExecCodeModule(char *name, PyObject *co)
639 {
640 return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
641 }
642
643 PyObject *
644 PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
645 {
646 PyObject *modules = PyImport_GetModuleDict();
647 PyObject *m, *d, *v;
648
649 m = PyImport_AddModule(name);
650 if (m == NULL)
651 return NULL;
652 /* If the module is being reloaded, we get the old module back
653 and re-use its dict to exec the new code. */
654 d = PyModule_GetDict(m);
655 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
656 if (PyDict_SetItemString(d, "__builtins__",
657 PyEval_GetBuiltins()) != 0)
658 goto error;
659 }
660 /* Remember the filename as the __file__ attribute */
661 v = NULL;
662 if (pathname != NULL) {
663 v = PyString_FromString(pathname);
664 if (v == NULL)
665 PyErr_Clear();
666 }
667 if (v == NULL) {
668 v = ((PyCodeObject *)co)->co_filename;
669 Py_INCREF(v);
670 }
671 if (PyDict_SetItemString(d, "__file__", v) != 0)
672 PyErr_Clear(); /* Not important enough to report */
673 Py_DECREF(v);
674
675 v = PyEval_EvalCode((PyCodeObject *)co, d, d);
676 if (v == NULL)
677 goto error;
678 Py_DECREF(v);
679
680 if ((m = PyDict_GetItemString(modules, name)) == NULL) {
681 PyErr_Format(PyExc_ImportError,
682 "Loaded module %.200s not found in sys.modules",
683 name);
684 return NULL;
685 }
686
687 Py_INCREF(m);
688
689 return m;
690
691 error:
692 _RemoveModule(name);
693 return NULL;
694 }
695
696
697 /* Given a pathname for a Python source file, fill a buffer with the
698 pathname for the corresponding compiled file. Return the pathname
699 for the compiled file, or NULL if there's no space in the buffer.
700 Doesn't set an exception. */
701
702 static char *
703 make_compiled_pathname(char *pathname, char *buf, size_t buflen)
704 {
705 size_t len = strlen(pathname);
706 if (len+2 > buflen)
707 return NULL;
708
709 #ifdef MS_WINDOWS
710 /* Treat .pyw as if it were .py. The case of ".pyw" must match
711 that used in _PyImport_StandardFiletab. */
712 if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
713 --len; /* pretend 'w' isn't there */
714 #endif
715 memcpy(buf, pathname, len);
716 buf[len] = Py_OptimizeFlag ? 'o' : 'c';
717 buf[len+1] = '\0';
718
719 return buf;
720 }
721
722
723 /* Given a pathname for a Python source file, its time of last
724 modification, and a pathname for a compiled file, check whether the
725 compiled file represents the same version of the source. If so,
726 return a FILE pointer for the compiled file, positioned just after
727 the header; if not, return NULL.
728 Doesn't set an exception. */
729
730 static FILE *
731 check_compiled_module(char *pathname, time_t mtime, char *cpathname)
732 {
733 FILE *fp;
734 long magic;
735 long pyc_mtime;
736
737 fp = fopen(cpathname, "rb");
738 if (fp == NULL)
739 return NULL;
740 magic = PyMarshal_ReadLongFromFile(fp);
741 if (magic != pyc_magic) {
742 if (Py_VerboseFlag)
743 PySys_WriteStderr("# %s has bad magic\n", cpathname);
744 fclose(fp);
745 return NULL;
746 }
747 pyc_mtime = PyMarshal_ReadLongFromFile(fp);
748 if (pyc_mtime != mtime) {
749 if (Py_VerboseFlag)
750 PySys_WriteStderr("# %s has bad mtime\n", cpathname);
751 fclose(fp);
752 return NULL;
753 }
754 if (Py_VerboseFlag)
755 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
756 return fp;
757 }
758
759
760 /* Read a code object from a file and check it for validity */
761
762 static PyCodeObject *
763 read_compiled_module(char *cpathname, FILE *fp)
764 {
765 PyObject *co;
766
767 co = PyMarshal_ReadLastObjectFromFile(fp);
768 if (co == NULL)
769 return NULL;
770 if (!PyCode_Check(co)) {
771 PyErr_Format(PyExc_ImportError,
772 "Non-code object in %.200s", cpathname);
773 Py_DECREF(co);
774 return NULL;
775 }
776 return (PyCodeObject *)co;
777 }
778
779
780 /* Load a module from a compiled file, execute it, and return its
781 module object WITH INCREMENTED REFERENCE COUNT */
782
783 static PyObject *
784 load_compiled_module(char *name, char *cpathname, FILE *fp)
785 {
786 long magic;
787 PyCodeObject *co;
788 PyObject *m;
789
790 magic = PyMarshal_ReadLongFromFile(fp);
791 if (magic != pyc_magic) {
792 PyErr_Format(PyExc_ImportError,
793 "Bad magic number in %.200s", cpathname);
794 return NULL;
795 }
796 (void) PyMarshal_ReadLongFromFile(fp);
797 co = read_compiled_module(cpathname, fp);
798 if (co == NULL)
799 return NULL;
800 if (Py_VerboseFlag)
801 PySys_WriteStderr("import %s # precompiled from %s\n",
802 name, cpathname);
803 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
804 Py_DECREF(co);
805
806 return m;
807 }
808
809 /* Parse a source file and return the corresponding code object */
810
811 static PyCodeObject *
812 parse_source_module(const char *pathname, FILE *fp)
813 {
814 PyCodeObject *co = NULL;
815 mod_ty mod;
816 PyCompilerFlags flags;
817 PyArena *arena = PyArena_New();
818 if (arena == NULL)
819 return NULL;
820
821 flags.cf_flags = 0;
822
823 mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, &flags,
824 NULL, arena);
825 if (mod) {
826 co = PyAST_Compile(mod, pathname, NULL, arena);
827 }
828 PyArena_Free(arena);
829 return co;
830 }
831
832
833 /* Helper to open a bytecode file for writing in exclusive mode */
834
835 static FILE *
836 open_exclusive(char *filename, mode_t mode)
837 {
838 #if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
839 /* Use O_EXCL to avoid a race condition when another process tries to
840 write the same file. When that happens, our open() call fails,
841 which is just fine (since it's only a cache).
842 XXX If the file exists and is writable but the directory is not
843 writable, the file will never be written. Oh well.
844 */
845 int fd;
846 (void) unlink(filename);
847 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
848 #ifdef O_BINARY
849 |O_BINARY /* necessary for Windows */
850 #endif
851 #ifdef __VMS
852 , mode, "ctxt=bin", "shr=nil"
853 #else
854 , mode
855 #endif
856 );
857 if (fd < 0)
858 return NULL;
859 return fdopen(fd, "wb");
860 #else
861 /* Best we can do -- on Windows this can't happen anyway */
862 return fopen(filename, "wb");
863 #endif
864 }
865
866
867 /* Write a compiled module to a file, placing the time of last
868 modification of its source into the header.
869 Errors are ignored, if a write error occurs an attempt is made to
870 remove the file. */
871
872 static void
873 write_compiled_module(PyCodeObject *co, char *cpathname, struct stat *srcstat)
874 {
875 FILE *fp;
876 time_t mtime = srcstat->st_mtime;
877 #ifdef MS_WINDOWS /* since Windows uses different permissions */
878 mode_t mode = srcstat->st_mode & ~S_IEXEC;
879 #else
880 mode_t mode = srcstat->st_mode & ~S_IXUSR & ~S_IXGRP & ~S_IXOTH;
881 #endif
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 *pathname, 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, pathname, fp);
1820 break;
1821
1822 case PY_COMPILED:
1823 m = load_compiled_module(name, pathname, fp);
1824 break;
1825
1826 #ifdef HAVE_DYNAMIC_LOADING
1827 case C_EXTENSION:
1828 m = _PyImport_LoadDynamicModule(name, pathname, fp);
1829 break;
1830 #endif
1831
1832 case PKG_DIRECTORY:
1833 m = load_package(name, pathname);
1834 break;
1835
1836 case C_BUILTIN:
1837 case PY_FROZEN:
1838 if (pathname != NULL && pathname[0] != '\0')
1839 name = pathname;
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 _PyImport_AcquireLock();
2182 result = import_module_level(name, globals, locals, fromlist, level);
2183 if (_PyImport_ReleaseLock() < 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 #ifndef MS_WINDOWS
3202 struct stat statbuf;
3203 int rv;
3204
3205 rv = stat(path, &statbuf);
3206 if (rv == 0) {
3207 /* it exists */
3208 if (S_ISDIR(statbuf.st_mode)) {
3209 /* it's a directory */
3210 PyErr_SetString(PyExc_ImportError,
3211 "existing directory");
3212 return -1;
3213 }
3214 }
3215 #else /* MS_WINDOWS */
3216 DWORD rv;
3217 /* see issue1293 and issue3677:
3218 * stat() on Windows doesn't recognise paths like
3219 * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs.
3220 */
3221 rv = GetFileAttributesA(path);
3222 if (rv != INVALID_FILE_ATTRIBUTES) {
3223 /* it exists */
3224 if (rv & FILE_ATTRIBUTE_DIRECTORY) {
3225 /* it's a directory */
3226 PyErr_SetString(PyExc_ImportError,
3227 "existing directory");
3228 return -1;
3229 }
3230 }
3231 #endif
3232 #else /* RISCOS */
3233 if (object_exists(path)) {
3234 /* it exists */
3235 if (isdir(path)) {
3236 /* it's a directory */
3237 PyErr_SetString(PyExc_ImportError,
3238 "existing directory");
3239 return -1;
3240 }
3241 }
3242 #endif
3243 }
3244 return 0;
3245 }
3246
3247 static PyObject *
3248 NullImporter_find_module(NullImporter *self, PyObject *args)
3249 {
3250 Py_RETURN_NONE;
3251 }
3252
3253 static PyMethodDef NullImporter_methods[] = {
3254 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS,
3255 "Always return None"
3256 },
3257 {NULL} /* Sentinel */
3258 };
3259
3260
3261 PyTypeObject PyNullImporter_Type = {
3262 PyVarObject_HEAD_INIT(NULL, 0)
3263 "imp.NullImporter", /*tp_name*/
3264 sizeof(NullImporter), /*tp_basicsize*/
3265 0, /*tp_itemsize*/
3266 0, /*tp_dealloc*/
3267 0, /*tp_print*/
3268 0, /*tp_getattr*/
3269 0, /*tp_setattr*/
3270 0, /*tp_compare*/
3271 0, /*tp_repr*/
3272 0, /*tp_as_number*/
3273 0, /*tp_as_sequence*/
3274 0, /*tp_as_mapping*/
3275 0, /*tp_hash */
3276 0, /*tp_call*/
3277 0, /*tp_str*/
3278 0, /*tp_getattro*/
3279 0, /*tp_setattro*/
3280 0, /*tp_as_buffer*/
3281 Py_TPFLAGS_DEFAULT, /*tp_flags*/
3282 "Null importer object", /* tp_doc */
3283 0, /* tp_traverse */
3284 0, /* tp_clear */
3285 0, /* tp_richcompare */
3286 0, /* tp_weaklistoffset */
3287 0, /* tp_iter */
3288 0, /* tp_iternext */
3289 NullImporter_methods, /* tp_methods */
3290 0, /* tp_members */
3291 0, /* tp_getset */
3292 0, /* tp_base */
3293 0, /* tp_dict */
3294 0, /* tp_descr_get */
3295 0, /* tp_descr_set */
3296 0, /* tp_dictoffset */
3297 (initproc)NullImporter_init, /* tp_init */
3298 0, /* tp_alloc */
3299 PyType_GenericNew /* tp_new */
3300 };
3301
3302
3303 PyMODINIT_FUNC
3304 initimp(void)
3305 {
3306 PyObject *m, *d;
3307
3308 if (PyType_Ready(&PyNullImporter_Type) < 0)
3309 goto failure;
3310
3311 m = Py_InitModule4("imp", imp_methods, doc_imp,
3312 NULL, PYTHON_API_VERSION);
3313 if (m == NULL)
3314 goto failure;
3315 d = PyModule_GetDict(m);
3316 if (d == NULL)
3317 goto failure;
3318
3319 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
3320 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
3321 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
3322 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
3323 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
3324 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
3325 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
3326 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
3327 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
3328 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
3329
3330 Py_INCREF(&PyNullImporter_Type);
3331 PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type);
3332 failure:
3333 ;
3334 }
3335
3336
3337 /* API for embedding applications that want to add their own entries
3338 to the table of built-in modules. This should normally be called
3339 *before* Py_Initialize(). When the table resize fails, -1 is
3340 returned and the existing table is unchanged.
3341
3342 After a similar function by Just van Rossum. */
3343
3344 int
3345 PyImport_ExtendInittab(struct _inittab *newtab)
3346 {
3347 static struct _inittab *our_copy = NULL;
3348 struct _inittab *p;
3349 int i, n;
3350
3351 /* Count the number of entries in both tables */
3352 for (n = 0; newtab[n].name != NULL; n++)
3353 ;
3354 if (n == 0)
3355 return 0; /* Nothing to do */
3356 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
3357 ;
3358
3359 /* Allocate new memory for the combined table */
3360 p = our_copy;
3361 PyMem_RESIZE(p, struct _inittab, i+n+1);
3362 if (p == NULL)
3363 return -1;
3364
3365 /* Copy the tables into the new memory */
3366 if (our_copy != PyImport_Inittab)
3367 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
3368 PyImport_Inittab = our_copy = p;
3369 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
3370
3371 return 0;
3372 }
3373
3374 /* Shorthand to add a single entry given a name and a function */
3375
3376 int
3377 PyImport_AppendInittab(const char *name, void (*initfunc)(void))
3378 {
3379 struct _inittab newtab[2];
3380
3381 memset(newtab, '\0', sizeof newtab);
3382
3383 newtab[0].name = (char *)name;
3384 newtab[0].initfunc = initfunc;
3385
3386 return PyImport_ExtendInittab(newtab);
3387 }
3388
3389 #ifdef __cplusplus
3390 }
3391 #endif
python git mirror