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 "errcode.h"
9 #include "marshal.h"
10 #include "code.h"
11 #include "frameobject.h"
12 #include "osdefs.h"
13 #include "importdl.h"
14
15 #ifdef HAVE_FCNTL_H
16 #include <fcntl.h>
17 #endif
18 #ifdef __cplusplus
19 extern "C" {
20 #endif
21
22 #define CACHEDIR "__pycache__"
23
24 /* See _PyImport_FixupExtensionObject() below */
25 static PyObject *extensions = NULL;
26
27 /* This table is defined in config.c: */
28 extern struct _inittab _PyImport_Inittab[];
29
30 struct _inittab *PyImport_Inittab = _PyImport_Inittab;
31
32 static PyObject *initstr = NULL;
33
34 /*[clinic input]
35 module _imp
36 [clinic start generated code]*/
37 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=9c332475d8686284]*/
38
39 #include "clinic/import.c.h"
40
41 /* Initialize things */
42
43 void
_PyImport_Init(void)44 _PyImport_Init(void)
45 {
46 PyInterpreterState *interp = PyThreadState_Get()->interp;
47 initstr = PyUnicode_InternFromString("__init__");
48 if (initstr == NULL)
49 Py_FatalError("Can't initialize import variables");
50 interp->builtins_copy = PyDict_Copy(interp->builtins);
51 if (interp->builtins_copy == NULL)
52 Py_FatalError("Can't backup builtins dict");
53 }
54
55 void
_PyImportHooks_Init(void)56 _PyImportHooks_Init(void)
57 {
58 PyObject *v, *path_hooks = NULL;
59 int err = 0;
60
61 /* adding sys.path_hooks and sys.path_importer_cache */
62 v = PyList_New(0);
63 if (v == NULL)
64 goto error;
65 err = PySys_SetObject("meta_path", v);
66 Py_DECREF(v);
67 if (err)
68 goto error;
69 v = PyDict_New();
70 if (v == NULL)
71 goto error;
72 err = PySys_SetObject("path_importer_cache", v);
73 Py_DECREF(v);
74 if (err)
75 goto error;
76 path_hooks = PyList_New(0);
77 if (path_hooks == NULL)
78 goto error;
79 err = PySys_SetObject("path_hooks", path_hooks);
80 if (err) {
81 error:
82 PyErr_Print();
83 Py_FatalError("initializing sys.meta_path, sys.path_hooks, "
84 "or path_importer_cache failed");
85 }
86 Py_DECREF(path_hooks);
87 }
88
89 void
_PyImportZip_Init(void)90 _PyImportZip_Init(void)
91 {
92 PyObject *path_hooks, *zimpimport;
93 int err = 0;
94
95 path_hooks = PySys_GetObject("path_hooks");
96 if (path_hooks == NULL) {
97 PyErr_SetString(PyExc_RuntimeError, "unable to get sys.path_hooks");
98 goto error;
99 }
100
101 if (Py_VerboseFlag)
102 PySys_WriteStderr("# installing zipimport hook\n");
103
104 zimpimport = PyImport_ImportModule("zipimport");
105 if (zimpimport == NULL) {
106 PyErr_Clear(); /* No zip import module -- okay */
107 if (Py_VerboseFlag)
108 PySys_WriteStderr("# can't import zipimport\n");
109 }
110 else {
111 _Py_IDENTIFIER(zipimporter);
112 PyObject *zipimporter = _PyObject_GetAttrId(zimpimport,
113 &PyId_zipimporter);
114 Py_DECREF(zimpimport);
115 if (zipimporter == NULL) {
116 PyErr_Clear(); /* No zipimporter object -- okay */
117 if (Py_VerboseFlag)
118 PySys_WriteStderr(
119 "# can't import zipimport.zipimporter\n");
120 }
121 else {
122 /* sys.path_hooks.insert(0, zipimporter) */
123 err = PyList_Insert(path_hooks, 0, zipimporter);
124 Py_DECREF(zipimporter);
125 if (err < 0) {
126 goto error;
127 }
128 if (Py_VerboseFlag)
129 PySys_WriteStderr(
130 "# installed zipimport hook\n");
131 }
132 }
133
134 return;
135
136 error:
137 PyErr_Print();
138 Py_FatalError("initializing zipimport failed");
139 }
140
141 /* Locking primitives to prevent parallel imports of the same module
142 in different threads to return with a partially loaded module.
143 These calls are serialized by the global interpreter lock. */
144
145 #ifdef WITH_THREAD
146
147 #include "pythread.h"
148
149 static PyThread_type_lock import_lock = 0;
150 static long import_lock_thread = -1;
151 static int import_lock_level = 0;
152
153 void
_PyImport_AcquireLock(void)154 _PyImport_AcquireLock(void)
155 {
156 long me = PyThread_get_thread_ident();
157 if (me == -1)
158 return; /* Too bad */
159 if (import_lock == NULL) {
160 import_lock = PyThread_allocate_lock();
161 if (import_lock == NULL)
162 return; /* Nothing much we can do. */
163 }
164 if (import_lock_thread == me) {
165 import_lock_level++;
166 return;
167 }
168 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
169 {
170 PyThreadState *tstate = PyEval_SaveThread();
171 PyThread_acquire_lock(import_lock, 1);
172 PyEval_RestoreThread(tstate);
173 }
174 assert(import_lock_level == 0);
175 import_lock_thread = me;
176 import_lock_level = 1;
177 }
178
179 int
_PyImport_ReleaseLock(void)180 _PyImport_ReleaseLock(void)
181 {
182 long me = PyThread_get_thread_ident();
183 if (me == -1 || import_lock == NULL)
184 return 0; /* Too bad */
185 if (import_lock_thread != me)
186 return -1;
187 import_lock_level--;
188 assert(import_lock_level >= 0);
189 if (import_lock_level == 0) {
190 import_lock_thread = -1;
191 PyThread_release_lock(import_lock);
192 }
193 return 1;
194 }
195
196 /* This function is called from PyOS_AfterFork to ensure that newly
197 created child processes do not share locks with the parent.
198 We now acquire the import lock around fork() calls but on some platforms
199 (Solaris 9 and earlier? see isue7242) that still left us with problems. */
200
201 void
_PyImport_ReInitLock(void)202 _PyImport_ReInitLock(void)
203 {
204 if (import_lock != NULL) {
205 import_lock = PyThread_allocate_lock();
206 if (import_lock == NULL) {
207 Py_FatalError("PyImport_ReInitLock failed to create a new lock");
208 }
209 }
210 if (import_lock_level > 1) {
211 /* Forked as a side effect of import */
212 long me = PyThread_get_thread_ident();
213 /* The following could fail if the lock is already held, but forking as
214 a side-effect of an import is a) rare, b) nuts, and c) difficult to
215 do thanks to the lock only being held when doing individual module
216 locks per import. */
217 PyThread_acquire_lock(import_lock, NOWAIT_LOCK);
218 import_lock_thread = me;
219 import_lock_level--;
220 } else {
221 import_lock_thread = -1;
222 import_lock_level = 0;
223 }
224 }
225
226 #endif
227
228 /*[clinic input]
229 _imp.lock_held
230
231 Return True if the import lock is currently held, else False.
232
233 On platforms without threads, return False.
234 [clinic start generated code]*/
235
236 static PyObject *
_imp_lock_held_impl(PyObject * module)237 _imp_lock_held_impl(PyObject *module)
238 /*[clinic end generated code: output=8b89384b5e1963fc input=9b088f9b217d9bdf]*/
239 {
240 #ifdef WITH_THREAD
241 return PyBool_FromLong(import_lock_thread != -1);
242 #else
243 return PyBool_FromLong(0);
244 #endif
245 }
246
247 /*[clinic input]
248 _imp.acquire_lock
249
250 Acquires the interpreter's import lock for the current thread.
251
252 This lock should be used by import hooks to ensure thread-safety when importing
253 modules. On platforms without threads, this function does nothing.
254 [clinic start generated code]*/
255
256 static PyObject *
_imp_acquire_lock_impl(PyObject * module)257 _imp_acquire_lock_impl(PyObject *module)
258 /*[clinic end generated code: output=1aff58cb0ee1b026 input=4a2d4381866d5fdc]*/
259 {
260 #ifdef WITH_THREAD
261 _PyImport_AcquireLock();
262 #endif
263 Py_INCREF(Py_None);
264 return Py_None;
265 }
266
267 /*[clinic input]
268 _imp.release_lock
269
270 Release the interpreter's import lock.
271
272 On platforms without threads, this function does nothing.
273 [clinic start generated code]*/
274
275 static PyObject *
_imp_release_lock_impl(PyObject * module)276 _imp_release_lock_impl(PyObject *module)
277 /*[clinic end generated code: output=7faab6d0be178b0a input=934fb11516dd778b]*/
278 {
279 #ifdef WITH_THREAD
280 if (_PyImport_ReleaseLock() < 0) {
281 PyErr_SetString(PyExc_RuntimeError,
282 "not holding the import lock");
283 return NULL;
284 }
285 #endif
286 Py_INCREF(Py_None);
287 return Py_None;
288 }
289
290 void
_PyImport_Fini(void)291 _PyImport_Fini(void)
292 {
293 Py_CLEAR(extensions);
294 #ifdef WITH_THREAD
295 if (import_lock != NULL) {
296 PyThread_free_lock(import_lock);
297 import_lock = NULL;
298 }
299 #endif
300 }
301
302 /* Helper for sys */
303
304 PyObject *
PyImport_GetModuleDict(void)305 PyImport_GetModuleDict(void)
306 {
307 PyInterpreterState *interp = PyThreadState_GET()->interp;
308 if (interp->modules == NULL)
309 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
310 return interp->modules;
311 }
312
313
314 /* List of names to clear in sys */
315 static const char * const sys_deletes[] = {
316 "path", "argv", "ps1", "ps2",
317 "last_type", "last_value", "last_traceback",
318 "path_hooks", "path_importer_cache", "meta_path",
319 "__interactivehook__",
320 /* misc stuff */
321 "flags", "float_info",
322 NULL
323 };
324
325 static const char * const sys_files[] = {
326 "stdin", "__stdin__",
327 "stdout", "__stdout__",
328 "stderr", "__stderr__",
329 NULL
330 };
331
332 /* Un-initialize things, as good as we can */
333
334 void
PyImport_Cleanup(void)335 PyImport_Cleanup(void)
336 {
337 Py_ssize_t pos;
338 PyObject *key, *value, *dict;
339 PyInterpreterState *interp = PyThreadState_GET()->interp;
340 PyObject *modules = interp->modules;
341 PyObject *weaklist = NULL;
342 const char * const *p;
343
344 if (modules == NULL)
345 return; /* Already done */
346
347 /* Delete some special variables first. These are common
348 places where user values hide and people complain when their
349 destructors fail. Since the modules containing them are
350 deleted *last* of all, they would come too late in the normal
351 destruction order. Sigh. */
352
353 /* XXX Perhaps these precautions are obsolete. Who knows? */
354
355 if (Py_VerboseFlag)
356 PySys_WriteStderr("# clear builtins._\n");
357 PyDict_SetItemString(interp->builtins, "_", Py_None);
358
359 for (p = sys_deletes; *p != NULL; p++) {
360 if (Py_VerboseFlag)
361 PySys_WriteStderr("# clear sys.%s\n", *p);
362 PyDict_SetItemString(interp->sysdict, *p, Py_None);
363 }
364 for (p = sys_files; *p != NULL; p+=2) {
365 if (Py_VerboseFlag)
366 PySys_WriteStderr("# restore sys.%s\n", *p);
367 value = PyDict_GetItemString(interp->sysdict, *(p+1));
368 if (value == NULL)
369 value = Py_None;
370 PyDict_SetItemString(interp->sysdict, *p, value);
371 }
372
373 /* We prepare a list which will receive (name, weakref) tuples of
374 modules when they are removed from sys.modules. The name is used
375 for diagnosis messages (in verbose mode), while the weakref helps
376 detect those modules which have been held alive. */
377 weaklist = PyList_New(0);
378 if (weaklist == NULL)
379 PyErr_Clear();
380
381 #define STORE_MODULE_WEAKREF(name, mod) \
382 if (weaklist != NULL) { \
383 PyObject *wr = PyWeakref_NewRef(mod, NULL); \
384 if (name && wr) { \
385 PyObject *tup = PyTuple_Pack(2, name, wr); \
386 PyList_Append(weaklist, tup); \
387 Py_XDECREF(tup); \
388 } \
389 Py_XDECREF(wr); \
390 if (PyErr_Occurred()) \
391 PyErr_Clear(); \
392 }
393
394 /* Remove all modules from sys.modules, hoping that garbage collection
395 can reclaim most of them. */
396 pos = 0;
397 while (PyDict_Next(modules, &pos, &key, &value)) {
398 if (PyModule_Check(value)) {
399 if (Py_VerboseFlag && PyUnicode_Check(key))
400 PySys_FormatStderr("# cleanup[2] removing %U\n", key);
401 STORE_MODULE_WEAKREF(key, value);
402 PyDict_SetItem(modules, key, Py_None);
403 }
404 }
405
406 /* Clear the modules dict. */
407 PyDict_Clear(modules);
408 /* Restore the original builtins dict, to ensure that any
409 user data gets cleared. */
410 dict = PyDict_Copy(interp->builtins);
411 if (dict == NULL)
412 PyErr_Clear();
413 PyDict_Clear(interp->builtins);
414 if (PyDict_Update(interp->builtins, interp->builtins_copy))
415 PyErr_Clear();
416 Py_XDECREF(dict);
417 /* Clear module dict copies stored in the interpreter state */
418 _PyState_ClearModules();
419 /* Collect references */
420 _PyGC_CollectNoFail();
421 /* Dump GC stats before it's too late, since it uses the warnings
422 machinery. */
423 _PyGC_DumpShutdownStats();
424
425 /* Now, if there are any modules left alive, clear their globals to
426 minimize potential leaks. All C extension modules actually end
427 up here, since they are kept alive in the interpreter state.
428
429 The special treatment of "builtins" here is because even
430 when it's not referenced as a module, its dictionary is
431 referenced by almost every module's __builtins__. Since
432 deleting a module clears its dictionary (even if there are
433 references left to it), we need to delete the "builtins"
434 module last. Likewise, we don't delete sys until the very
435 end because it is implicitly referenced (e.g. by print). */
436 if (weaklist != NULL) {
437 Py_ssize_t i, n;
438 n = PyList_GET_SIZE(weaklist);
439 for (i = 0; i < n; i++) {
440 PyObject *tup = PyList_GET_ITEM(weaklist, i);
441 PyObject *name = PyTuple_GET_ITEM(tup, 0);
442 PyObject *mod = PyWeakref_GET_OBJECT(PyTuple_GET_ITEM(tup, 1));
443 if (mod == Py_None)
444 continue;
445 assert(PyModule_Check(mod));
446 dict = PyModule_GetDict(mod);
447 if (dict == interp->builtins || dict == interp->sysdict)
448 continue;
449 Py_INCREF(mod);
450 if (Py_VerboseFlag && PyUnicode_Check(name))
451 PySys_FormatStderr("# cleanup[3] wiping %U\n", name);
452 _PyModule_Clear(mod);
453 Py_DECREF(mod);
454 }
455 Py_DECREF(weaklist);
456 }
457
458 /* Next, delete sys and builtins (in that order) */
459 if (Py_VerboseFlag)
460 PySys_FormatStderr("# cleanup[3] wiping sys\n");
461 _PyModule_ClearDict(interp->sysdict);
462 if (Py_VerboseFlag)
463 PySys_FormatStderr("# cleanup[3] wiping builtins\n");
464 _PyModule_ClearDict(interp->builtins);
465
466 /* Clear and delete the modules directory. Actual modules will
467 still be there only if imported during the execution of some
468 destructor. */
469 interp->modules = NULL;
470 Py_DECREF(modules);
471
472 /* Once more */
473 _PyGC_CollectNoFail();
474
475 #undef STORE_MODULE_WEAKREF
476 }
477
478
479 /* Helper for pythonrun.c -- return magic number and tag. */
480
481 long
PyImport_GetMagicNumber(void)482 PyImport_GetMagicNumber(void)
483 {
484 long res;
485 PyInterpreterState *interp = PyThreadState_Get()->interp;
486 PyObject *external, *pyc_magic;
487
488 external = PyObject_GetAttrString(interp->importlib, "_bootstrap_external");
489 if (external == NULL)
490 return -1;
491 pyc_magic = PyObject_GetAttrString(external, "_RAW_MAGIC_NUMBER");
492 Py_DECREF(external);
493 if (pyc_magic == NULL)
494 return -1;
495 res = PyLong_AsLong(pyc_magic);
496 Py_DECREF(pyc_magic);
497 return res;
498 }
499
500
501 extern const char * _PySys_ImplCacheTag;
502
503 const char *
PyImport_GetMagicTag(void)504 PyImport_GetMagicTag(void)
505 {
506 return _PySys_ImplCacheTag;
507 }
508
509
510 /* Magic for extension modules (built-in as well as dynamically
511 loaded). To prevent initializing an extension module more than
512 once, we keep a static dictionary 'extensions' keyed by the tuple
513 (module name, module name) (for built-in modules) or by
514 (filename, module name) (for dynamically loaded modules), containing these
515 modules. A copy of the module's dictionary is stored by calling
516 _PyImport_FixupExtensionObject() immediately after the module initialization
517 function succeeds. A copy can be retrieved from there by calling
518 _PyImport_FindExtensionObject().
519
520 Modules which do support multiple initialization set their m_size
521 field to a non-negative number (indicating the size of the
522 module-specific state). They are still recorded in the extensions
523 dictionary, to avoid loading shared libraries twice.
524 */
525
526 int
_PyImport_FixupExtensionObject(PyObject * mod,PyObject * name,PyObject * filename)527 _PyImport_FixupExtensionObject(PyObject *mod, PyObject *name,
528 PyObject *filename)
529 {
530 PyObject *modules, *dict, *key;
531 struct PyModuleDef *def;
532 int res;
533 if (extensions == NULL) {
534 extensions = PyDict_New();
535 if (extensions == NULL)
536 return -1;
537 }
538 if (mod == NULL || !PyModule_Check(mod)) {
539 PyErr_BadInternalCall();
540 return -1;
541 }
542 def = PyModule_GetDef(mod);
543 if (!def) {
544 PyErr_BadInternalCall();
545 return -1;
546 }
547 modules = PyImport_GetModuleDict();
548 if (PyDict_SetItem(modules, name, mod) < 0)
549 return -1;
550 if (_PyState_AddModule(mod, def) < 0) {
551 PyDict_DelItem(modules, name);
552 return -1;
553 }
554 if (def->m_size == -1) {
555 if (def->m_base.m_copy) {
556 /* Somebody already imported the module,
557 likely under a different name.
558 XXX this should really not happen. */
559 Py_CLEAR(def->m_base.m_copy);
560 }
561 dict = PyModule_GetDict(mod);
562 if (dict == NULL)
563 return -1;
564 def->m_base.m_copy = PyDict_Copy(dict);
565 if (def->m_base.m_copy == NULL)
566 return -1;
567 }
568 key = PyTuple_Pack(2, filename, name);
569 if (key == NULL)
570 return -1;
571 res = PyDict_SetItem(extensions, key, (PyObject *)def);
572 Py_DECREF(key);
573 if (res < 0)
574 return -1;
575 return 0;
576 }
577
578 int
_PyImport_FixupBuiltin(PyObject * mod,const char * name)579 _PyImport_FixupBuiltin(PyObject *mod, const char *name)
580 {
581 int res;
582 PyObject *nameobj;
583 nameobj = PyUnicode_InternFromString(name);
584 if (nameobj == NULL)
585 return -1;
586 res = _PyImport_FixupExtensionObject(mod, nameobj, nameobj);
587 Py_DECREF(nameobj);
588 return res;
589 }
590
591 PyObject *
_PyImport_FindExtensionObject(PyObject * name,PyObject * filename)592 _PyImport_FindExtensionObject(PyObject *name, PyObject *filename)
593 {
594 PyObject *mod, *mdict, *key;
595 PyModuleDef* def;
596 if (extensions == NULL)
597 return NULL;
598 key = PyTuple_Pack(2, filename, name);
599 if (key == NULL)
600 return NULL;
601 def = (PyModuleDef *)PyDict_GetItem(extensions, key);
602 Py_DECREF(key);
603 if (def == NULL)
604 return NULL;
605 if (def->m_size == -1) {
606 /* Module does not support repeated initialization */
607 if (def->m_base.m_copy == NULL)
608 return NULL;
609 mod = PyImport_AddModuleObject(name);
610 if (mod == NULL)
611 return NULL;
612 mdict = PyModule_GetDict(mod);
613 if (mdict == NULL)
614 return NULL;
615 if (PyDict_Update(mdict, def->m_base.m_copy))
616 return NULL;
617 }
618 else {
619 if (def->m_base.m_init == NULL)
620 return NULL;
621 mod = def->m_base.m_init();
622 if (mod == NULL)
623 return NULL;
624 if (PyDict_SetItem(PyImport_GetModuleDict(), name, mod) == -1) {
625 Py_DECREF(mod);
626 return NULL;
627 }
628 Py_DECREF(mod);
629 }
630 if (_PyState_AddModule(mod, def) < 0) {
631 PyDict_DelItem(PyImport_GetModuleDict(), name);
632 Py_DECREF(mod);
633 return NULL;
634 }
635 if (Py_VerboseFlag)
636 PySys_FormatStderr("import %U # previously loaded (%R)\n",
637 name, filename);
638 return mod;
639
640 }
641
642 PyObject *
_PyImport_FindBuiltin(const char * name)643 _PyImport_FindBuiltin(const char *name)
644 {
645 PyObject *res, *nameobj;
646 nameobj = PyUnicode_InternFromString(name);
647 if (nameobj == NULL)
648 return NULL;
649 res = _PyImport_FindExtensionObject(nameobj, nameobj);
650 Py_DECREF(nameobj);
651 return res;
652 }
653
654 /* Get the module object corresponding to a module name.
655 First check the modules dictionary if there's one there,
656 if not, create a new one and insert it in the modules dictionary.
657 Because the former action is most common, THIS DOES NOT RETURN A
658 'NEW' REFERENCE! */
659
660 PyObject *
PyImport_AddModuleObject(PyObject * name)661 PyImport_AddModuleObject(PyObject *name)
662 {
663 PyObject *modules = PyImport_GetModuleDict();
664 PyObject *m;
665
666 if ((m = PyDict_GetItemWithError(modules, name)) != NULL &&
667 PyModule_Check(m)) {
668 return m;
669 }
670 if (PyErr_Occurred()) {
671 return NULL;
672 }
673 m = PyModule_NewObject(name);
674 if (m == NULL)
675 return NULL;
676 if (PyDict_SetItem(modules, name, m) != 0) {
677 Py_DECREF(m);
678 return NULL;
679 }
680 Py_DECREF(m); /* Yes, it still exists, in modules! */
681
682 return m;
683 }
684
685 PyObject *
PyImport_AddModule(const char * name)686 PyImport_AddModule(const char *name)
687 {
688 PyObject *nameobj, *module;
689 nameobj = PyUnicode_FromString(name);
690 if (nameobj == NULL)
691 return NULL;
692 module = PyImport_AddModuleObject(nameobj);
693 Py_DECREF(nameobj);
694 return module;
695 }
696
697
698 /* Remove name from sys.modules, if it's there. */
699 static void
remove_module(PyObject * name)700 remove_module(PyObject *name)
701 {
702 PyObject *modules = PyImport_GetModuleDict();
703 if (PyDict_GetItem(modules, name) == NULL)
704 return;
705 if (PyDict_DelItem(modules, name) < 0)
706 Py_FatalError("import: deleting existing key in"
707 "sys.modules failed");
708 }
709
710
711 /* Execute a code object in a module and return the module object
712 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
713 * removed from sys.modules, to avoid leaving damaged module objects
714 * in sys.modules. The caller may wish to restore the original
715 * module object (if any) in this case; PyImport_ReloadModule is an
716 * example.
717 *
718 * Note that PyImport_ExecCodeModuleWithPathnames() is the preferred, richer
719 * interface. The other two exist primarily for backward compatibility.
720 */
721 PyObject *
PyImport_ExecCodeModule(const char * name,PyObject * co)722 PyImport_ExecCodeModule(const char *name, PyObject *co)
723 {
724 return PyImport_ExecCodeModuleWithPathnames(
725 name, co, (char *)NULL, (char *)NULL);
726 }
727
728 PyObject *
PyImport_ExecCodeModuleEx(const char * name,PyObject * co,const char * pathname)729 PyImport_ExecCodeModuleEx(const char *name, PyObject *co, const char *pathname)
730 {
731 return PyImport_ExecCodeModuleWithPathnames(
732 name, co, pathname, (char *)NULL);
733 }
734
735 PyObject *
PyImport_ExecCodeModuleWithPathnames(const char * name,PyObject * co,const char * pathname,const char * cpathname)736 PyImport_ExecCodeModuleWithPathnames(const char *name, PyObject *co,
737 const char *pathname,
738 const char *cpathname)
739 {
740 PyObject *m = NULL;
741 PyObject *nameobj, *pathobj = NULL, *cpathobj = NULL, *external= NULL;
742
743 nameobj = PyUnicode_FromString(name);
744 if (nameobj == NULL)
745 return NULL;
746
747 if (cpathname != NULL) {
748 cpathobj = PyUnicode_DecodeFSDefault(cpathname);
749 if (cpathobj == NULL)
750 goto error;
751 }
752 else
753 cpathobj = NULL;
754
755 if (pathname != NULL) {
756 pathobj = PyUnicode_DecodeFSDefault(pathname);
757 if (pathobj == NULL)
758 goto error;
759 }
760 else if (cpathobj != NULL) {
761 PyInterpreterState *interp = PyThreadState_GET()->interp;
762 _Py_IDENTIFIER(_get_sourcefile);
763
764 if (interp == NULL) {
765 Py_FatalError("PyImport_ExecCodeModuleWithPathnames: "
766 "no interpreter!");
767 }
768
769 external= PyObject_GetAttrString(interp->importlib,
770 "_bootstrap_external");
771 if (external != NULL) {
772 pathobj = _PyObject_CallMethodIdObjArgs(external,
773 &PyId__get_sourcefile, cpathobj,
774 NULL);
775 Py_DECREF(external);
776 }
777 if (pathobj == NULL)
778 PyErr_Clear();
779 }
780 else
781 pathobj = NULL;
782
783 m = PyImport_ExecCodeModuleObject(nameobj, co, pathobj, cpathobj);
784 error:
785 Py_DECREF(nameobj);
786 Py_XDECREF(pathobj);
787 Py_XDECREF(cpathobj);
788 return m;
789 }
790
791 static PyObject *
module_dict_for_exec(PyObject * name)792 module_dict_for_exec(PyObject *name)
793 {
794 PyObject *m, *d = NULL;
795
796 m = PyImport_AddModuleObject(name);
797 if (m == NULL)
798 return NULL;
799 /* If the module is being reloaded, we get the old module back
800 and re-use its dict to exec the new code. */
801 d = PyModule_GetDict(m);
802 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
803 if (PyDict_SetItemString(d, "__builtins__",
804 PyEval_GetBuiltins()) != 0) {
805 remove_module(name);
806 return NULL;
807 }
808 }
809
810 return d; /* Return a borrowed reference. */
811 }
812
813 static PyObject *
exec_code_in_module(PyObject * name,PyObject * module_dict,PyObject * code_object)814 exec_code_in_module(PyObject *name, PyObject *module_dict, PyObject *code_object)
815 {
816 PyObject *modules = PyImport_GetModuleDict();
817 PyObject *v, *m;
818
819 v = PyEval_EvalCode(code_object, module_dict, module_dict);
820 if (v == NULL) {
821 remove_module(name);
822 return NULL;
823 }
824 Py_DECREF(v);
825
826 if ((m = PyDict_GetItem(modules, name)) == NULL) {
827 PyErr_Format(PyExc_ImportError,
828 "Loaded module %R not found in sys.modules",
829 name);
830 return NULL;
831 }
832
833 Py_INCREF(m);
834
835 return m;
836 }
837
838 PyObject*
PyImport_ExecCodeModuleObject(PyObject * name,PyObject * co,PyObject * pathname,PyObject * cpathname)839 PyImport_ExecCodeModuleObject(PyObject *name, PyObject *co, PyObject *pathname,
840 PyObject *cpathname)
841 {
842 PyObject *d, *external, *res;
843 PyInterpreterState *interp = PyThreadState_GET()->interp;
844 _Py_IDENTIFIER(_fix_up_module);
845
846 d = module_dict_for_exec(name);
847 if (d == NULL) {
848 return NULL;
849 }
850
851 if (pathname == NULL) {
852 pathname = ((PyCodeObject *)co)->co_filename;
853 }
854 external = PyObject_GetAttrString(interp->importlib, "_bootstrap_external");
855 if (external == NULL)
856 return NULL;
857 res = _PyObject_CallMethodIdObjArgs(external,
858 &PyId__fix_up_module,
859 d, name, pathname, cpathname, NULL);
860 Py_DECREF(external);
861 if (res != NULL) {
862 Py_DECREF(res);
863 res = exec_code_in_module(name, d, co);
864 }
865 return res;
866 }
867
868
869 static void
update_code_filenames(PyCodeObject * co,PyObject * oldname,PyObject * newname)870 update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
871 {
872 PyObject *constants, *tmp;
873 Py_ssize_t i, n;
874
875 if (PyUnicode_Compare(co->co_filename, oldname))
876 return;
877
878 Py_INCREF(newname);
879 Py_XSETREF(co->co_filename, newname);
880
881 constants = co->co_consts;
882 n = PyTuple_GET_SIZE(constants);
883 for (i = 0; i < n; i++) {
884 tmp = PyTuple_GET_ITEM(constants, i);
885 if (PyCode_Check(tmp))
886 update_code_filenames((PyCodeObject *)tmp,
887 oldname, newname);
888 }
889 }
890
891 static void
update_compiled_module(PyCodeObject * co,PyObject * newname)892 update_compiled_module(PyCodeObject *co, PyObject *newname)
893 {
894 PyObject *oldname;
895
896 if (PyUnicode_Compare(co->co_filename, newname) == 0)
897 return;
898
899 oldname = co->co_filename;
900 Py_INCREF(oldname);
901 update_code_filenames(co, oldname, newname);
902 Py_DECREF(oldname);
903 }
904
905 /*[clinic input]
906 _imp._fix_co_filename
907
908 code: object(type="PyCodeObject *", subclass_of="&PyCode_Type")
909 Code object to change.
910
911 path: unicode
912 File path to use.
913 /
914
915 Changes code.co_filename to specify the passed-in file path.
916 [clinic start generated code]*/
917
918 static PyObject *
_imp__fix_co_filename_impl(PyObject * module,PyCodeObject * code,PyObject * path)919 _imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,
920 PyObject *path)
921 /*[clinic end generated code: output=1d002f100235587d input=895ba50e78b82f05]*/
922
923 {
924 update_compiled_module(code, path);
925
926 Py_RETURN_NONE;
927 }
928
929
930 /* Forward */
931 static const struct _frozen * find_frozen(PyObject *);
932
933
934 /* Helper to test for built-in module */
935
936 static int
is_builtin(PyObject * name)937 is_builtin(PyObject *name)
938 {
939 int i;
940 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
941 if (_PyUnicode_EqualToASCIIString(name, PyImport_Inittab[i].name)) {
942 if (PyImport_Inittab[i].initfunc == NULL)
943 return -1;
944 else
945 return 1;
946 }
947 }
948 return 0;
949 }
950
951
952 /* Return a finder object for a sys.path/pkg.__path__ item 'p',
953 possibly by fetching it from the path_importer_cache dict. If it
954 wasn't yet cached, traverse path_hooks until a hook is found
955 that can handle the path item. Return None if no hook could;
956 this tells our caller that the path based finder could not find
957 a finder for this path item. Cache the result in
958 path_importer_cache.
959 Returns a borrowed reference. */
960
961 static PyObject *
get_path_importer(PyObject * path_importer_cache,PyObject * path_hooks,PyObject * p)962 get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
963 PyObject *p)
964 {
965 PyObject *importer;
966 Py_ssize_t j, nhooks;
967
968 /* These conditions are the caller's responsibility: */
969 assert(PyList_Check(path_hooks));
970 assert(PyDict_Check(path_importer_cache));
971
972 nhooks = PyList_Size(path_hooks);
973 if (nhooks < 0)
974 return NULL; /* Shouldn't happen */
975
976 importer = PyDict_GetItem(path_importer_cache, p);
977 if (importer != NULL)
978 return importer;
979
980 /* set path_importer_cache[p] to None to avoid recursion */
981 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
982 return NULL;
983
984 for (j = 0; j < nhooks; j++) {
985 PyObject *hook = PyList_GetItem(path_hooks, j);
986 if (hook == NULL)
987 return NULL;
988 importer = PyObject_CallFunctionObjArgs(hook, p, NULL);
989 if (importer != NULL)
990 break;
991
992 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
993 return NULL;
994 }
995 PyErr_Clear();
996 }
997 if (importer == NULL) {
998 return Py_None;
999 }
1000 if (importer != NULL) {
1001 int err = PyDict_SetItem(path_importer_cache, p, importer);
1002 Py_DECREF(importer);
1003 if (err != 0)
1004 return NULL;
1005 }
1006 return importer;
1007 }
1008
1009 PyAPI_FUNC(PyObject *)
PyImport_GetImporter(PyObject * path)1010 PyImport_GetImporter(PyObject *path) {
1011 PyObject *importer=NULL, *path_importer_cache=NULL, *path_hooks=NULL;
1012
1013 path_importer_cache = PySys_GetObject("path_importer_cache");
1014 path_hooks = PySys_GetObject("path_hooks");
1015 if (path_importer_cache != NULL && path_hooks != NULL) {
1016 importer = get_path_importer(path_importer_cache,
1017 path_hooks, path);
1018 }
1019 Py_XINCREF(importer); /* get_path_importer returns a borrowed reference */
1020 return importer;
1021 }
1022
1023 /*[clinic input]
1024 _imp.create_builtin
1025
1026 spec: object
1027 /
1028
1029 Create an extension module.
1030 [clinic start generated code]*/
1031
1032 static PyObject *
_imp_create_builtin(PyObject * module,PyObject * spec)1033 _imp_create_builtin(PyObject *module, PyObject *spec)
1034 /*[clinic end generated code: output=ace7ff22271e6f39 input=37f966f890384e47]*/
1035 {
1036 struct _inittab *p;
1037 PyObject *name;
1038 char *namestr;
1039 PyObject *mod;
1040
1041 name = PyObject_GetAttrString(spec, "name");
1042 if (name == NULL) {
1043 return NULL;
1044 }
1045
1046 mod = _PyImport_FindExtensionObject(name, name);
1047 if (mod || PyErr_Occurred()) {
1048 Py_DECREF(name);
1049 Py_XINCREF(mod);
1050 return mod;
1051 }
1052
1053 namestr = PyUnicode_AsUTF8(name);
1054 if (namestr == NULL) {
1055 Py_DECREF(name);
1056 return NULL;
1057 }
1058
1059 for (p = PyImport_Inittab; p->name != NULL; p++) {
1060 PyModuleDef *def;
1061 if (_PyUnicode_EqualToASCIIString(name, p->name)) {
1062 if (p->initfunc == NULL) {
1063 /* Cannot re-init internal module ("sys" or "builtins") */
1064 mod = PyImport_AddModule(namestr);
1065 Py_DECREF(name);
1066 return mod;
1067 }
1068 mod = (*p->initfunc)();
1069 if (mod == NULL) {
1070 Py_DECREF(name);
1071 return NULL;
1072 }
1073 if (PyObject_TypeCheck(mod, &PyModuleDef_Type)) {
1074 Py_DECREF(name);
1075 return PyModule_FromDefAndSpec((PyModuleDef*)mod, spec);
1076 } else {
1077 /* Remember pointer to module init function. */
1078 def = PyModule_GetDef(mod);
1079 if (def == NULL) {
1080 Py_DECREF(name);
1081 return NULL;
1082 }
1083 def->m_base.m_init = p->initfunc;
1084 if (_PyImport_FixupExtensionObject(mod, name, name) < 0) {
1085 Py_DECREF(name);
1086 return NULL;
1087 }
1088 Py_DECREF(name);
1089 return mod;
1090 }
1091 }
1092 }
1093 Py_DECREF(name);
1094 Py_RETURN_NONE;
1095 }
1096
1097
1098 /* Frozen modules */
1099
1100 static const struct _frozen *
find_frozen(PyObject * name)1101 find_frozen(PyObject *name)
1102 {
1103 const struct _frozen *p;
1104
1105 if (name == NULL)
1106 return NULL;
1107
1108 for (p = PyImport_FrozenModules; ; p++) {
1109 if (p->name == NULL)
1110 return NULL;
1111 if (_PyUnicode_EqualToASCIIString(name, p->name))
1112 break;
1113 }
1114 return p;
1115 }
1116
1117 static PyObject *
get_frozen_object(PyObject * name)1118 get_frozen_object(PyObject *name)
1119 {
1120 const struct _frozen *p = find_frozen(name);
1121 int size;
1122
1123 if (p == NULL) {
1124 PyErr_Format(PyExc_ImportError,
1125 "No such frozen object named %R",
1126 name);
1127 return NULL;
1128 }
1129 if (p->code == NULL) {
1130 PyErr_Format(PyExc_ImportError,
1131 "Excluded frozen object named %R",
1132 name);
1133 return NULL;
1134 }
1135 size = p->size;
1136 if (size < 0)
1137 size = -size;
1138 return PyMarshal_ReadObjectFromString((const char *)p->code, size);
1139 }
1140
1141 static PyObject *
is_frozen_package(PyObject * name)1142 is_frozen_package(PyObject *name)
1143 {
1144 const struct _frozen *p = find_frozen(name);
1145 int size;
1146
1147 if (p == NULL) {
1148 PyErr_Format(PyExc_ImportError,
1149 "No such frozen object named %R",
1150 name);
1151 return NULL;
1152 }
1153
1154 size = p->size;
1155
1156 if (size < 0)
1157 Py_RETURN_TRUE;
1158 else
1159 Py_RETURN_FALSE;
1160 }
1161
1162
1163 /* Initialize a frozen module.
1164 Return 1 for success, 0 if the module is not found, and -1 with
1165 an exception set if the initialization failed.
1166 This function is also used from frozenmain.c */
1167
1168 int
PyImport_ImportFrozenModuleObject(PyObject * name)1169 PyImport_ImportFrozenModuleObject(PyObject *name)
1170 {
1171 const struct _frozen *p;
1172 PyObject *co, *m, *d;
1173 int ispackage;
1174 int size;
1175
1176 p = find_frozen(name);
1177
1178 if (p == NULL)
1179 return 0;
1180 if (p->code == NULL) {
1181 PyErr_Format(PyExc_ImportError,
1182 "Excluded frozen object named %R",
1183 name);
1184 return -1;
1185 }
1186 size = p->size;
1187 ispackage = (size < 0);
1188 if (ispackage)
1189 size = -size;
1190 co = PyMarshal_ReadObjectFromString((const char *)p->code, size);
1191 if (co == NULL)
1192 return -1;
1193 if (!PyCode_Check(co)) {
1194 PyErr_Format(PyExc_TypeError,
1195 "frozen object %R is not a code object",
1196 name);
1197 goto err_return;
1198 }
1199 if (ispackage) {
1200 /* Set __path__ to the empty list */
1201 PyObject *l;
1202 int err;
1203 m = PyImport_AddModuleObject(name);
1204 if (m == NULL)
1205 goto err_return;
1206 d = PyModule_GetDict(m);
1207 l = PyList_New(0);
1208 if (l == NULL) {
1209 goto err_return;
1210 }
1211 err = PyDict_SetItemString(d, "__path__", l);
1212 Py_DECREF(l);
1213 if (err != 0)
1214 goto err_return;
1215 }
1216 d = module_dict_for_exec(name);
1217 if (d == NULL) {
1218 goto err_return;
1219 }
1220 m = exec_code_in_module(name, d, co);
1221 if (m == NULL)
1222 goto err_return;
1223 Py_DECREF(co);
1224 Py_DECREF(m);
1225 return 1;
1226 err_return:
1227 Py_DECREF(co);
1228 return -1;
1229 }
1230
1231 int
PyImport_ImportFrozenModule(const char * name)1232 PyImport_ImportFrozenModule(const char *name)
1233 {
1234 PyObject *nameobj;
1235 int ret;
1236 nameobj = PyUnicode_InternFromString(name);
1237 if (nameobj == NULL)
1238 return -1;
1239 ret = PyImport_ImportFrozenModuleObject(nameobj);
1240 Py_DECREF(nameobj);
1241 return ret;
1242 }
1243
1244
1245 /* Import a module, either built-in, frozen, or external, and return
1246 its module object WITH INCREMENTED REFERENCE COUNT */
1247
1248 PyObject *
PyImport_ImportModule(const char * name)1249 PyImport_ImportModule(const char *name)
1250 {
1251 PyObject *pname;
1252 PyObject *result;
1253
1254 pname = PyUnicode_FromString(name);
1255 if (pname == NULL)
1256 return NULL;
1257 result = PyImport_Import(pname);
1258 Py_DECREF(pname);
1259 return result;
1260 }
1261
1262 /* Import a module without blocking
1263 *
1264 * At first it tries to fetch the module from sys.modules. If the module was
1265 * never loaded before it loads it with PyImport_ImportModule() unless another
1266 * thread holds the import lock. In the latter case the function raises an
1267 * ImportError instead of blocking.
1268 *
1269 * Returns the module object with incremented ref count.
1270 */
1271 PyObject *
PyImport_ImportModuleNoBlock(const char * name)1272 PyImport_ImportModuleNoBlock(const char *name)
1273 {
1274 return PyImport_ImportModule(name);
1275 }
1276
1277
1278 /* Remove importlib frames from the traceback,
1279 * except in Verbose mode. */
1280 static void
remove_importlib_frames(void)1281 remove_importlib_frames(void)
1282 {
1283 const char *importlib_filename = "<frozen importlib._bootstrap>";
1284 const char *external_filename = "<frozen importlib._bootstrap_external>";
1285 const char *remove_frames = "_call_with_frames_removed";
1286 int always_trim = 0;
1287 int in_importlib = 0;
1288 PyObject *exception, *value, *base_tb, *tb;
1289 PyObject **prev_link, **outer_link = NULL;
1290
1291 /* Synopsis: if it's an ImportError, we trim all importlib chunks
1292 from the traceback. We always trim chunks
1293 which end with a call to "_call_with_frames_removed". */
1294
1295 PyErr_Fetch(&exception, &value, &base_tb);
1296 if (!exception || Py_VerboseFlag)
1297 goto done;
1298 if (PyType_IsSubtype((PyTypeObject *) exception,
1299 (PyTypeObject *) PyExc_ImportError))
1300 always_trim = 1;
1301
1302 prev_link = &base_tb;
1303 tb = base_tb;
1304 while (tb != NULL) {
1305 PyTracebackObject *traceback = (PyTracebackObject *)tb;
1306 PyObject *next = (PyObject *) traceback->tb_next;
1307 PyFrameObject *frame = traceback->tb_frame;
1308 PyCodeObject *code = frame->f_code;
1309 int now_in_importlib;
1310
1311 assert(PyTraceBack_Check(tb));
1312 now_in_importlib = _PyUnicode_EqualToASCIIString(code->co_filename, importlib_filename) ||
1313 _PyUnicode_EqualToASCIIString(code->co_filename, external_filename);
1314 if (now_in_importlib && !in_importlib) {
1315 /* This is the link to this chunk of importlib tracebacks */
1316 outer_link = prev_link;
1317 }
1318 in_importlib = now_in_importlib;
1319
1320 if (in_importlib &&
1321 (always_trim ||
1322 _PyUnicode_EqualToASCIIString(code->co_name, remove_frames))) {
1323 Py_XINCREF(next);
1324 Py_XSETREF(*outer_link, next);
1325 prev_link = outer_link;
1326 }
1327 else {
1328 prev_link = (PyObject **) &traceback->tb_next;
1329 }
1330 tb = next;
1331 }
1332 done:
1333 PyErr_Restore(exception, value, base_tb);
1334 }
1335
1336
1337 static PyObject *
resolve_name(PyObject * name,PyObject * globals,int level)1338 resolve_name(PyObject *name, PyObject *globals, int level)
1339 {
1340 _Py_IDENTIFIER(__spec__);
1341 _Py_IDENTIFIER(__package__);
1342 _Py_IDENTIFIER(__path__);
1343 _Py_IDENTIFIER(__name__);
1344 _Py_IDENTIFIER(parent);
1345 PyObject *abs_name;
1346 PyObject *package = NULL;
1347 PyObject *spec;
1348 PyInterpreterState *interp = PyThreadState_GET()->interp;
1349 Py_ssize_t last_dot;
1350 PyObject *base;
1351 int level_up;
1352
1353 if (globals == NULL) {
1354 PyErr_SetString(PyExc_KeyError, "'__name__' not in globals");
1355 goto error;
1356 }
1357 if (!PyDict_Check(globals)) {
1358 PyErr_SetString(PyExc_TypeError, "globals must be a dict");
1359 goto error;
1360 }
1361 package = _PyDict_GetItemId(globals, &PyId___package__);
1362 if (package == Py_None) {
1363 package = NULL;
1364 }
1365 spec = _PyDict_GetItemId(globals, &PyId___spec__);
1366
1367 if (package != NULL) {
1368 Py_INCREF(package);
1369 if (!PyUnicode_Check(package)) {
1370 PyErr_SetString(PyExc_TypeError, "package must be a string");
1371 goto error;
1372 }
1373 else if (spec != NULL && spec != Py_None) {
1374 int equal;
1375 PyObject *parent = _PyObject_GetAttrId(spec, &PyId_parent);
1376 if (parent == NULL) {
1377 goto error;
1378 }
1379
1380 equal = PyObject_RichCompareBool(package, parent, Py_EQ);
1381 Py_DECREF(parent);
1382 if (equal < 0) {
1383 goto error;
1384 }
1385 else if (equal == 0) {
1386 if (PyErr_WarnEx(PyExc_ImportWarning,
1387 "__package__ != __spec__.parent", 1) < 0) {
1388 goto error;
1389 }
1390 }
1391 }
1392 }
1393 else if (spec != NULL && spec != Py_None) {
1394 package = _PyObject_GetAttrId(spec, &PyId_parent);
1395 if (package == NULL) {
1396 goto error;
1397 }
1398 else if (!PyUnicode_Check(package)) {
1399 PyErr_SetString(PyExc_TypeError,
1400 "__spec__.parent must be a string");
1401 goto error;
1402 }
1403 }
1404 else {
1405 if (PyErr_WarnEx(PyExc_ImportWarning,
1406 "can't resolve package from __spec__ or __package__, "
1407 "falling back on __name__ and __path__", 1) < 0) {
1408 goto error;
1409 }
1410
1411 package = _PyDict_GetItemId(globals, &PyId___name__);
1412 if (package == NULL) {
1413 PyErr_SetString(PyExc_KeyError, "'__name__' not in globals");
1414 goto error;
1415 }
1416
1417 Py_INCREF(package);
1418 if (!PyUnicode_Check(package)) {
1419 PyErr_SetString(PyExc_TypeError, "__name__ must be a string");
1420 goto error;
1421 }
1422
1423 if (_PyDict_GetItemId(globals, &PyId___path__) == NULL) {
1424 Py_ssize_t dot;
1425
1426 if (PyUnicode_READY(package) < 0) {
1427 goto error;
1428 }
1429
1430 dot = PyUnicode_FindChar(package, '.',
1431 0, PyUnicode_GET_LENGTH(package), -1);
1432 if (dot == -2) {
1433 goto error;
1434 }
1435
1436 if (dot >= 0) {
1437 PyObject *substr = PyUnicode_Substring(package, 0, dot);
1438 if (substr == NULL) {
1439 goto error;
1440 }
1441 Py_SETREF(package, substr);
1442 }
1443 }
1444 }
1445
1446 last_dot = PyUnicode_GET_LENGTH(package);
1447 if (last_dot == 0) {
1448 PyErr_SetString(PyExc_ImportError,
1449 "attempted relative import with no known parent package");
1450 goto error;
1451 }
1452 else if (PyDict_GetItem(interp->modules, package) == NULL) {
1453 PyErr_Format(PyExc_SystemError,
1454 "Parent module %R not loaded, cannot perform relative "
1455 "import", package);
1456 goto error;
1457 }
1458
1459 for (level_up = 1; level_up < level; level_up += 1) {
1460 last_dot = PyUnicode_FindChar(package, '.', 0, last_dot, -1);
1461 if (last_dot == -2) {
1462 goto error;
1463 }
1464 else if (last_dot == -1) {
1465 PyErr_SetString(PyExc_ValueError,
1466 "attempted relative import beyond top-level "
1467 "package");
1468 goto error;
1469 }
1470 }
1471
1472 base = PyUnicode_Substring(package, 0, last_dot);
1473 Py_DECREF(package);
1474 if (base == NULL || PyUnicode_GET_LENGTH(name) == 0) {
1475 return base;
1476 }
1477
1478 abs_name = PyUnicode_FromFormat("%U.%U", base, name);
1479 Py_DECREF(base);
1480 return abs_name;
1481
1482 error:
1483 Py_XDECREF(package);
1484 return NULL;
1485 }
1486
1487 PyObject *
PyImport_ImportModuleLevelObject(PyObject * name,PyObject * globals,PyObject * locals,PyObject * fromlist,int level)1488 PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
1489 PyObject *locals, PyObject *fromlist,
1490 int level)
1491 {
1492 _Py_IDENTIFIER(_find_and_load);
1493 _Py_IDENTIFIER(_handle_fromlist);
1494 PyObject *abs_name = NULL;
1495 PyObject *final_mod = NULL;
1496 PyObject *mod = NULL;
1497 PyObject *package = NULL;
1498 PyInterpreterState *interp = PyThreadState_GET()->interp;
1499 int has_from;
1500
1501 if (name == NULL) {
1502 PyErr_SetString(PyExc_ValueError, "Empty module name");
1503 goto error;
1504 }
1505
1506 /* The below code is importlib.__import__() & _gcd_import(), ported to C
1507 for added performance. */
1508
1509 if (!PyUnicode_Check(name)) {
1510 PyErr_SetString(PyExc_TypeError, "module name must be a string");
1511 goto error;
1512 }
1513 if (PyUnicode_READY(name) < 0) {
1514 goto error;
1515 }
1516 if (level < 0) {
1517 PyErr_SetString(PyExc_ValueError, "level must be >= 0");
1518 goto error;
1519 }
1520
1521 if (level > 0) {
1522 abs_name = resolve_name(name, globals, level);
1523 if (abs_name == NULL)
1524 goto error;
1525 }
1526 else { /* level == 0 */
1527 if (PyUnicode_GET_LENGTH(name) == 0) {
1528 PyErr_SetString(PyExc_ValueError, "Empty module name");
1529 goto error;
1530 }
1531 abs_name = name;
1532 Py_INCREF(abs_name);
1533 }
1534
1535 mod = PyDict_GetItem(interp->modules, abs_name);
1536 if (mod == Py_None) {
1537 PyObject *msg = PyUnicode_FromFormat("import of %R halted; "
1538 "None in sys.modules", abs_name);
1539 if (msg != NULL) {
1540 PyErr_SetImportErrorSubclass(PyExc_ModuleNotFoundError, msg,
1541 abs_name, NULL);
1542 Py_DECREF(msg);
1543 }
1544 mod = NULL;
1545 goto error;
1546 }
1547 else if (mod != NULL) {
1548 _Py_IDENTIFIER(__spec__);
1549 _Py_IDENTIFIER(_initializing);
1550 _Py_IDENTIFIER(_lock_unlock_module);
1551 PyObject *value = NULL;
1552 PyObject *spec;
1553 int initializing = 0;
1554
1555 Py_INCREF(mod);
1556 /* Optimization: only call _bootstrap._lock_unlock_module() if
1557 __spec__._initializing is true.
1558 NOTE: because of this, initializing must be set *before*
1559 stuffing the new module in sys.modules.
1560 */
1561 spec = _PyObject_GetAttrId(mod, &PyId___spec__);
1562 if (spec != NULL) {
1563 value = _PyObject_GetAttrId(spec, &PyId__initializing);
1564 Py_DECREF(spec);
1565 }
1566 if (value == NULL)
1567 PyErr_Clear();
1568 else {
1569 initializing = PyObject_IsTrue(value);
1570 Py_DECREF(value);
1571 if (initializing == -1)
1572 PyErr_Clear();
1573 if (initializing > 0) {
1574 #ifdef WITH_THREAD
1575 _PyImport_AcquireLock();
1576 #endif
1577 /* _bootstrap._lock_unlock_module() releases the import lock */
1578 value = _PyObject_CallMethodIdObjArgs(interp->importlib,
1579 &PyId__lock_unlock_module, abs_name,
1580 NULL);
1581 if (value == NULL)
1582 goto error;
1583 Py_DECREF(value);
1584 }
1585 }
1586 }
1587 else {
1588 #ifdef WITH_THREAD
1589 _PyImport_AcquireLock();
1590 #endif
1591 /* _bootstrap._find_and_load() releases the import lock */
1592 mod = _PyObject_CallMethodIdObjArgs(interp->importlib,
1593 &PyId__find_and_load, abs_name,
1594 interp->import_func, NULL);
1595 if (mod == NULL) {
1596 goto error;
1597 }
1598 }
1599
1600 has_from = 0;
1601 if (fromlist != NULL && fromlist != Py_None) {
1602 has_from = PyObject_IsTrue(fromlist);
1603 if (has_from < 0)
1604 goto error;
1605 }
1606 if (!has_from) {
1607 Py_ssize_t len = PyUnicode_GET_LENGTH(name);
1608 if (level == 0 || len > 0) {
1609 Py_ssize_t dot;
1610
1611 dot = PyUnicode_FindChar(name, '.', 0, len, 1);
1612 if (dot == -2) {
1613 goto error;
1614 }
1615
1616 if (dot == -1) {
1617 /* No dot in module name, simple exit */
1618 final_mod = mod;
1619 Py_INCREF(mod);
1620 goto error;
1621 }
1622
1623 if (level == 0) {
1624 PyObject *front = PyUnicode_Substring(name, 0, dot);
1625 if (front == NULL) {
1626 goto error;
1627 }
1628
1629 final_mod = PyImport_ImportModuleLevelObject(front, NULL, NULL, NULL, 0);
1630 Py_DECREF(front);
1631 }
1632 else {
1633 Py_ssize_t cut_off = len - dot;
1634 Py_ssize_t abs_name_len = PyUnicode_GET_LENGTH(abs_name);
1635 PyObject *to_return = PyUnicode_Substring(abs_name, 0,
1636 abs_name_len - cut_off);
1637 if (to_return == NULL) {
1638 goto error;
1639 }
1640
1641 final_mod = PyDict_GetItem(interp->modules, to_return);
1642 Py_DECREF(to_return);
1643 if (final_mod == NULL) {
1644 PyErr_Format(PyExc_KeyError,
1645 "%R not in sys.modules as expected",
1646 to_return);
1647 goto error;
1648 }
1649 Py_INCREF(final_mod);
1650 }
1651 }
1652 else {
1653 final_mod = mod;
1654 Py_INCREF(mod);
1655 }
1656 }
1657 else {
1658 final_mod = _PyObject_CallMethodIdObjArgs(interp->importlib,
1659 &PyId__handle_fromlist, mod,
1660 fromlist, interp->import_func,
1661 NULL);
1662 }
1663
1664 error:
1665 Py_XDECREF(abs_name);
1666 Py_XDECREF(mod);
1667 Py_XDECREF(package);
1668 if (final_mod == NULL)
1669 remove_importlib_frames();
1670 return final_mod;
1671 }
1672
1673 PyObject *
PyImport_ImportModuleLevel(const char * name,PyObject * globals,PyObject * locals,PyObject * fromlist,int level)1674 PyImport_ImportModuleLevel(const char *name, PyObject *globals, PyObject *locals,
1675 PyObject *fromlist, int level)
1676 {
1677 PyObject *nameobj, *mod;
1678 nameobj = PyUnicode_FromString(name);
1679 if (nameobj == NULL)
1680 return NULL;
1681 mod = PyImport_ImportModuleLevelObject(nameobj, globals, locals,
1682 fromlist, level);
1683 Py_DECREF(nameobj);
1684 return mod;
1685 }
1686
1687
1688 /* Re-import a module of any kind and return its module object, WITH
1689 INCREMENTED REFERENCE COUNT */
1690
1691 PyObject *
PyImport_ReloadModule(PyObject * m)1692 PyImport_ReloadModule(PyObject *m)
1693 {
1694 _Py_IDENTIFIER(reload);
1695 PyObject *reloaded_module = NULL;
1696 PyObject *modules = PyImport_GetModuleDict();
1697 PyObject *imp = PyDict_GetItemString(modules, "imp");
1698 if (imp == NULL) {
1699 imp = PyImport_ImportModule("imp");
1700 if (imp == NULL) {
1701 return NULL;
1702 }
1703 }
1704 else {
1705 Py_INCREF(imp);
1706 }
1707
1708 reloaded_module = _PyObject_CallMethodId(imp, &PyId_reload, "O", m);
1709 Py_DECREF(imp);
1710 return reloaded_module;
1711 }
1712
1713
1714 /* Higher-level import emulator which emulates the "import" statement
1715 more accurately -- it invokes the __import__() function from the
1716 builtins of the current globals. This means that the import is
1717 done using whatever import hooks are installed in the current
1718 environment.
1719 A dummy list ["__doc__"] is passed as the 4th argument so that
1720 e.g. PyImport_Import(PyUnicode_FromString("win32com.client.gencache"))
1721 will return <module "gencache"> instead of <module "win32com">. */
1722
1723 PyObject *
PyImport_Import(PyObject * module_name)1724 PyImport_Import(PyObject *module_name)
1725 {
1726 static PyObject *silly_list = NULL;
1727 static PyObject *builtins_str = NULL;
1728 static PyObject *import_str = NULL;
1729 PyObject *globals = NULL;
1730 PyObject *import = NULL;
1731 PyObject *builtins = NULL;
1732 PyObject *modules = NULL;
1733 PyObject *r = NULL;
1734
1735 /* Initialize constant string objects */
1736 if (silly_list == NULL) {
1737 import_str = PyUnicode_InternFromString("__import__");
1738 if (import_str == NULL)
1739 return NULL;
1740 builtins_str = PyUnicode_InternFromString("__builtins__");
1741 if (builtins_str == NULL)
1742 return NULL;
1743 silly_list = PyList_New(0);
1744 if (silly_list == NULL)
1745 return NULL;
1746 }
1747
1748 /* Get the builtins from current globals */
1749 globals = PyEval_GetGlobals();
1750 if (globals != NULL) {
1751 Py_INCREF(globals);
1752 builtins = PyObject_GetItem(globals, builtins_str);
1753 if (builtins == NULL)
1754 goto err;
1755 }
1756 else {
1757 /* No globals -- use standard builtins, and fake globals */
1758 builtins = PyImport_ImportModuleLevel("builtins",
1759 NULL, NULL, NULL, 0);
1760 if (builtins == NULL)
1761 return NULL;
1762 globals = Py_BuildValue("{OO}", builtins_str, builtins);
1763 if (globals == NULL)
1764 goto err;
1765 }
1766
1767 /* Get the __import__ function from the builtins */
1768 if (PyDict_Check(builtins)) {
1769 import = PyObject_GetItem(builtins, import_str);
1770 if (import == NULL)
1771 PyErr_SetObject(PyExc_KeyError, import_str);
1772 }
1773 else
1774 import = PyObject_GetAttr(builtins, import_str);
1775 if (import == NULL)
1776 goto err;
1777
1778 /* Call the __import__ function with the proper argument list
1779 Always use absolute import here.
1780 Calling for side-effect of import. */
1781 r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
1782 globals, silly_list, 0, NULL);
1783 if (r == NULL)
1784 goto err;
1785 Py_DECREF(r);
1786
1787 modules = PyImport_GetModuleDict();
1788 r = PyDict_GetItem(modules, module_name);
1789 if (r != NULL)
1790 Py_INCREF(r);
1791
1792 err:
1793 Py_XDECREF(globals);
1794 Py_XDECREF(builtins);
1795 Py_XDECREF(import);
1796
1797 return r;
1798 }
1799
1800 /*[clinic input]
1801 _imp.extension_suffixes
1802
1803 Returns the list of file suffixes used to identify extension modules.
1804 [clinic start generated code]*/
1805
1806 static PyObject *
_imp_extension_suffixes_impl(PyObject * module)1807 _imp_extension_suffixes_impl(PyObject *module)
1808 /*[clinic end generated code: output=0bf346e25a8f0cd3 input=ecdeeecfcb6f839e]*/
1809 {
1810 PyObject *list;
1811 const char *suffix;
1812 unsigned int index = 0;
1813
1814 list = PyList_New(0);
1815 if (list == NULL)
1816 return NULL;
1817 #ifdef HAVE_DYNAMIC_LOADING
1818 while ((suffix = _PyImport_DynLoadFiletab[index])) {
1819 PyObject *item = PyUnicode_FromString(suffix);
1820 if (item == NULL) {
1821 Py_DECREF(list);
1822 return NULL;
1823 }
1824 if (PyList_Append(list, item) < 0) {
1825 Py_DECREF(list);
1826 Py_DECREF(item);
1827 return NULL;
1828 }
1829 Py_DECREF(item);
1830 index += 1;
1831 }
1832 #endif
1833 return list;
1834 }
1835
1836 /*[clinic input]
1837 _imp.init_frozen
1838
1839 name: unicode
1840 /
1841
1842 Initializes a frozen module.
1843 [clinic start generated code]*/
1844
1845 static PyObject *
_imp_init_frozen_impl(PyObject * module,PyObject * name)1846 _imp_init_frozen_impl(PyObject *module, PyObject *name)
1847 /*[clinic end generated code: output=fc0511ed869fd69c input=13019adfc04f3fb3]*/
1848 {
1849 int ret;
1850 PyObject *m;
1851
1852 ret = PyImport_ImportFrozenModuleObject(name);
1853 if (ret < 0)
1854 return NULL;
1855 if (ret == 0) {
1856 Py_INCREF(Py_None);
1857 return Py_None;
1858 }
1859 m = PyImport_AddModuleObject(name);
1860 Py_XINCREF(m);
1861 return m;
1862 }
1863
1864 /*[clinic input]
1865 _imp.get_frozen_object
1866
1867 name: unicode
1868 /
1869
1870 Create a code object for a frozen module.
1871 [clinic start generated code]*/
1872
1873 static PyObject *
_imp_get_frozen_object_impl(PyObject * module,PyObject * name)1874 _imp_get_frozen_object_impl(PyObject *module, PyObject *name)
1875 /*[clinic end generated code: output=2568cc5b7aa0da63 input=ed689bc05358fdbd]*/
1876 {
1877 return get_frozen_object(name);
1878 }
1879
1880 /*[clinic input]
1881 _imp.is_frozen_package
1882
1883 name: unicode
1884 /
1885
1886 Returns True if the module name is of a frozen package.
1887 [clinic start generated code]*/
1888
1889 static PyObject *
_imp_is_frozen_package_impl(PyObject * module,PyObject * name)1890 _imp_is_frozen_package_impl(PyObject *module, PyObject *name)
1891 /*[clinic end generated code: output=e70cbdb45784a1c9 input=81b6cdecd080fbb8]*/
1892 {
1893 return is_frozen_package(name);
1894 }
1895
1896 /*[clinic input]
1897 _imp.is_builtin
1898
1899 name: unicode
1900 /
1901
1902 Returns True if the module name corresponds to a built-in module.
1903 [clinic start generated code]*/
1904
1905 static PyObject *
_imp_is_builtin_impl(PyObject * module,PyObject * name)1906 _imp_is_builtin_impl(PyObject *module, PyObject *name)
1907 /*[clinic end generated code: output=3bfd1162e2d3be82 input=86befdac021dd1c7]*/
1908 {
1909 return PyLong_FromLong(is_builtin(name));
1910 }
1911
1912 /*[clinic input]
1913 _imp.is_frozen
1914
1915 name: unicode
1916 /
1917
1918 Returns True if the module name corresponds to a frozen module.
1919 [clinic start generated code]*/
1920
1921 static PyObject *
_imp_is_frozen_impl(PyObject * module,PyObject * name)1922 _imp_is_frozen_impl(PyObject *module, PyObject *name)
1923 /*[clinic end generated code: output=01f408f5ec0f2577 input=7301dbca1897d66b]*/
1924 {
1925 const struct _frozen *p;
1926
1927 p = find_frozen(name);
1928 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
1929 }
1930
1931 /* Common implementation for _imp.exec_dynamic and _imp.exec_builtin */
1932 static int
exec_builtin_or_dynamic(PyObject * mod)1933 exec_builtin_or_dynamic(PyObject *mod) {
1934 PyModuleDef *def;
1935 void *state;
1936
1937 if (!PyModule_Check(mod)) {
1938 return 0;
1939 }
1940
1941 def = PyModule_GetDef(mod);
1942 if (def == NULL) {
1943 return 0;
1944 }
1945
1946 state = PyModule_GetState(mod);
1947 if (state) {
1948 /* Already initialized; skip reload */
1949 return 0;
1950 }
1951
1952 return PyModule_ExecDef(mod, def);
1953 }
1954
1955 #ifdef HAVE_DYNAMIC_LOADING
1956
1957 /*[clinic input]
1958 _imp.create_dynamic
1959
1960 spec: object
1961 file: object = NULL
1962 /
1963
1964 Create an extension module.
1965 [clinic start generated code]*/
1966
1967 static PyObject *
_imp_create_dynamic_impl(PyObject * module,PyObject * spec,PyObject * file)1968 _imp_create_dynamic_impl(PyObject *module, PyObject *spec, PyObject *file)
1969 /*[clinic end generated code: output=83249b827a4fde77 input=c31b954f4cf4e09d]*/
1970 {
1971 PyObject *mod, *name, *path;
1972 FILE *fp;
1973
1974 name = PyObject_GetAttrString(spec, "name");
1975 if (name == NULL) {
1976 return NULL;
1977 }
1978
1979 path = PyObject_GetAttrString(spec, "origin");
1980 if (path == NULL) {
1981 Py_DECREF(name);
1982 return NULL;
1983 }
1984
1985 mod = _PyImport_FindExtensionObject(name, path);
1986 if (mod != NULL) {
1987 Py_DECREF(name);
1988 Py_DECREF(path);
1989 Py_INCREF(mod);
1990 return mod;
1991 }
1992
1993 if (file != NULL) {
1994 fp = _Py_fopen_obj(path, "r");
1995 if (fp == NULL) {
1996 Py_DECREF(name);
1997 Py_DECREF(path);
1998 return NULL;
1999 }
2000 }
2001 else
2002 fp = NULL;
2003
2004 mod = _PyImport_LoadDynamicModuleWithSpec(spec, fp);
2005
2006 Py_DECREF(name);
2007 Py_DECREF(path);
2008 if (fp)
2009 fclose(fp);
2010 return mod;
2011 }
2012
2013 /*[clinic input]
2014 _imp.exec_dynamic -> int
2015
2016 mod: object
2017 /
2018
2019 Initialize an extension module.
2020 [clinic start generated code]*/
2021
2022 static int
_imp_exec_dynamic_impl(PyObject * module,PyObject * mod)2023 _imp_exec_dynamic_impl(PyObject *module, PyObject *mod)
2024 /*[clinic end generated code: output=f5720ac7b465877d input=9fdbfcb250280d3a]*/
2025 {
2026 return exec_builtin_or_dynamic(mod);
2027 }
2028
2029
2030 #endif /* HAVE_DYNAMIC_LOADING */
2031
2032 /*[clinic input]
2033 _imp.exec_builtin -> int
2034
2035 mod: object
2036 /
2037
2038 Initialize a built-in module.
2039 [clinic start generated code]*/
2040
2041 static int
_imp_exec_builtin_impl(PyObject * module,PyObject * mod)2042 _imp_exec_builtin_impl(PyObject *module, PyObject *mod)
2043 /*[clinic end generated code: output=0262447b240c038e input=7beed5a2f12a60ca]*/
2044 {
2045 return exec_builtin_or_dynamic(mod);
2046 }
2047
2048 /*[clinic input]
2049 dump buffer
2050 [clinic start generated code]*/
2051 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=524ce2e021e4eba6]*/
2052
2053
2054 PyDoc_STRVAR(doc_imp,
2055 "(Extremely) low-level import machinery bits as used by importlib and imp.");
2056
2057 static PyMethodDef imp_methods[] = {
2058 _IMP_EXTENSION_SUFFIXES_METHODDEF
2059 _IMP_LOCK_HELD_METHODDEF
2060 _IMP_ACQUIRE_LOCK_METHODDEF
2061 _IMP_RELEASE_LOCK_METHODDEF
2062 _IMP_GET_FROZEN_OBJECT_METHODDEF
2063 _IMP_IS_FROZEN_PACKAGE_METHODDEF
2064 _IMP_CREATE_BUILTIN_METHODDEF
2065 _IMP_INIT_FROZEN_METHODDEF
2066 _IMP_IS_BUILTIN_METHODDEF
2067 _IMP_IS_FROZEN_METHODDEF
2068 _IMP_CREATE_DYNAMIC_METHODDEF
2069 _IMP_EXEC_DYNAMIC_METHODDEF
2070 _IMP_EXEC_BUILTIN_METHODDEF
2071 _IMP__FIX_CO_FILENAME_METHODDEF
2072 {NULL, NULL} /* sentinel */
2073 };
2074
2075
2076 static struct PyModuleDef impmodule = {
2077 PyModuleDef_HEAD_INIT,
2078 "_imp",
2079 doc_imp,
2080 0,
2081 imp_methods,
2082 NULL,
2083 NULL,
2084 NULL,
2085 NULL
2086 };
2087
2088 PyMODINIT_FUNC
PyInit_imp(void)2089 PyInit_imp(void)
2090 {
2091 PyObject *m, *d;
2092
2093 m = PyModule_Create(&impmodule);
2094 if (m == NULL)
2095 goto failure;
2096 d = PyModule_GetDict(m);
2097 if (d == NULL)
2098 goto failure;
2099
2100 return m;
2101 failure:
2102 Py_XDECREF(m);
2103 return NULL;
2104 }
2105
2106
2107 /* API for embedding applications that want to add their own entries
2108 to the table of built-in modules. This should normally be called
2109 *before* Py_Initialize(). When the table resize fails, -1 is
2110 returned and the existing table is unchanged.
2111
2112 After a similar function by Just van Rossum. */
2113
2114 int
PyImport_ExtendInittab(struct _inittab * newtab)2115 PyImport_ExtendInittab(struct _inittab *newtab)
2116 {
2117 static struct _inittab *our_copy = NULL;
2118 struct _inittab *p;
2119 int i, n;
2120
2121 /* Count the number of entries in both tables */
2122 for (n = 0; newtab[n].name != NULL; n++)
2123 ;
2124 if (n == 0)
2125 return 0; /* Nothing to do */
2126 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
2127 ;
2128
2129 /* Allocate new memory for the combined table */
2130 p = our_copy;
2131 PyMem_RESIZE(p, struct _inittab, i+n+1);
2132 if (p == NULL)
2133 return -1;
2134
2135 /* Copy the tables into the new memory */
2136 if (our_copy != PyImport_Inittab)
2137 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
2138 PyImport_Inittab = our_copy = p;
2139 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
2140
2141 return 0;
2142 }
2143
2144 /* Shorthand to add a single entry given a name and a function */
2145
2146 int
PyImport_AppendInittab(const char * name,PyObject * (* initfunc)(void))2147 PyImport_AppendInittab(const char *name, PyObject* (*initfunc)(void))
2148 {
2149 struct _inittab newtab[2];
2150
2151 memset(newtab, '\0', sizeof newtab);
2152
2153 newtab[0].name = name;
2154 newtab[0].initfunc = initfunc;
2155
2156 return PyImport_ExtendInittab(newtab);
2157 }
2158
2159 #ifdef __cplusplus
2160 }
2161 #endif
2162