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