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