source: python/trunk/Python/import.c@ 6

Last change on this file since 6 was 2, checked in by Yuri Dario, 15 years ago

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