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