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