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#ifdef WITH_THREAD 2068 long me; 2069#endif 2070 2071 /* Try to get the module from sys.modules[name] */ 2072 modules = PyImport_GetModuleDict(); 2073 if (modules == NULL) 2074 return NULL; 2075 2076 result = PyDict_GetItemString(modules, name); 2077 if (result != NULL) { 2078 Py_INCREF(result); 2079 return result; 2080 } 2081 else { 2082 PyErr_Clear(); 2083 } 2084#ifdef WITH_THREAD 2085 /* check the import lock 2086 * me might be -1 but I ignore the error here, the lock function 2087 * takes care of the problem */ 2088 me = PyThread_get_thread_ident(); 2089 if (import_lock_thread == -1 || import_lock_thread == me) { 2090 /* no thread or me is holding the lock */ 2091 return PyImport_ImportModule(name); 2092 } 2093 else { 2094 PyErr_Format(PyExc_ImportError, 2095 "Failed to import %.200s because the import lock" 2096 "is held by another thread.", 2097 name); 2098 return NULL; 2099 } 2100#else 2101 return PyImport_ImportModule(name); 2102#endif 2103} 2104 2105/* Forward declarations for helper routines */ 2106static PyObject *get_parent(PyObject *globals, char *buf, 2107 Py_ssize_t *p_buflen, int level); 2108static PyObject *load_next(PyObject *mod, PyObject *altmod, 2109 char **p_name, char *buf, Py_ssize_t *p_buflen); 2110static int mark_miss(char *name); 2111static int ensure_fromlist(PyObject *mod, PyObject *fromlist, 2112 char *buf, Py_ssize_t buflen, int recursive); 2113static PyObject * import_submodule(PyObject *mod, char *name, char *fullname); 2114 2115/* The Magnum Opus of dotted-name import :-) */ 2116 2117static PyObject * 2118import_module_level(char *name, PyObject *globals, PyObject *locals, 2119 PyObject *fromlist, int level) 2120{ 2121 char buf[MAXPATHLEN+1]; 2122 Py_ssize_t buflen = 0; 2123 PyObject *parent, *head, *next, *tail; 2124 2125 if (strchr(name, '/') != NULL 2126#ifdef MS_WINDOWS 2127 || strchr(name, '\\') != NULL 2128#endif 2129 ) { 2130 PyErr_SetString(PyExc_ImportError, 2131 "Import by filename is not supported."); 2132 return NULL; 2133 } 2134 2135 parent = get_parent(globals, buf, &buflen, level); 2136 if (parent == NULL) 2137 return NULL; 2138 2139 head = load_next(parent, level < 0 ? Py_None : parent, &name, buf, 2140 &buflen); 2141 if (head == NULL) 2142 return NULL; 2143 2144 tail = head; 2145 Py_INCREF(tail); 2146 while (name) { 2147 next = load_next(tail, tail, &name, buf, &buflen); 2148 Py_DECREF(tail); 2149 if (next == NULL) { 2150 Py_DECREF(head); 2151 return NULL; 2152 } 2153 tail = next; 2154 } 2155 if (tail == Py_None) { 2156 /* If tail is Py_None, both get_parent and load_next found 2157 an empty module name: someone called __import__("") or 2158 doctored faulty bytecode */ 2159 Py_DECREF(tail); 2160 Py_DECREF(head); 2161 PyErr_SetString(PyExc_ValueError, 2162 "Empty module name"); 2163 return NULL; 2164 } 2165 2166 if (fromlist != NULL) { 2167 if (fromlist == Py_None || !PyObject_IsTrue(fromlist)) 2168 fromlist = NULL; 2169 } 2170 2171 if (fromlist == NULL) { 2172 Py_DECREF(tail); 2173 return head; 2174 } 2175 2176 Py_DECREF(head); 2177 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) { 2178 Py_DECREF(tail); 2179 return NULL; 2180 } 2181 2182 return tail; 2183} 2184 2185PyObject * 2186PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals, 2187 PyObject *fromlist, int level) 2188{ 2189 PyObject *result; 2190 _PyImport_AcquireLock(); 2191 result = import_module_level(name, globals, locals, fromlist, level); 2192 if (_PyImport_ReleaseLock() < 0) { 2193 Py_XDECREF(result); 2194 PyErr_SetString(PyExc_RuntimeError, 2195 "not holding the import lock"); 2196 return NULL; 2197 } 2198 return result; 2199} 2200 2201/* Return the package that an import is being performed in. If globals comes 2202 from the module foo.bar.bat (not itself a package), this returns the 2203 sys.modules entry for foo.bar. If globals is from a package's __init__.py, 2204 the package's entry in sys.modules is returned, as a borrowed reference. 2205 2206 The *name* of the returned package is returned in buf, with the length of 2207 the name in *p_buflen. 2208 2209 If globals doesn't come from a package or a module in a package, or a 2210 corresponding entry is not found in sys.modules, Py_None is returned. 2211*/ 2212static PyObject * 2213get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level) 2214{ 2215 static PyObject *namestr = NULL; 2216 static PyObject *pathstr = NULL; 2217 static PyObject *pkgstr = NULL; 2218 PyObject *pkgname, *modname, *modpath, *modules, *parent; 2219 int orig_level = level; 2220 2221 if (globals == NULL || !PyDict_Check(globals) || !level) 2222 return Py_None; 2223 2224 if (namestr == NULL) { 2225 namestr = PyString_InternFromString("__name__"); 2226 if (namestr == NULL) 2227 return NULL; 2228 } 2229 if (pathstr == NULL) { 2230 pathstr = PyString_InternFromString("__path__"); 2231 if (pathstr == NULL) 2232 return NULL; 2233 } 2234 if (pkgstr == NULL) { 2235 pkgstr = PyString_InternFromString("__package__"); 2236 if (pkgstr == NULL) 2237 return NULL; 2238 } 2239 2240 *buf = '\0'; 2241 *p_buflen = 0; 2242 pkgname = PyDict_GetItem(globals, pkgstr); 2243 2244 if ((pkgname != NULL) && (pkgname != Py_None)) { 2245 /* __package__ is set, so use it */ 2246 Py_ssize_t len; 2247 if (!PyString_Check(pkgname)) { 2248 PyErr_SetString(PyExc_ValueError, 2249 "__package__ set to non-string"); 2250 return NULL; 2251 } 2252 len = PyString_GET_SIZE(pkgname); 2253 if (len == 0) { 2254 if (level > 0) { 2255 PyErr_SetString(PyExc_ValueError, 2256 "Attempted relative import in non-package"); 2257 return NULL; 2258 } 2259 return Py_None; 2260 } 2261 if (len > MAXPATHLEN) { 2262 PyErr_SetString(PyExc_ValueError, 2263 "Package name too long"); 2264 return NULL; 2265 } 2266 strcpy(buf, PyString_AS_STRING(pkgname)); 2267 } else { 2268 /* __package__ not set, so figure it out and set it */ 2269 modname = PyDict_GetItem(globals, namestr); 2270 if (modname == NULL || !PyString_Check(modname)) 2271 return Py_None; 2272 2273 modpath = PyDict_GetItem(globals, pathstr); 2274 if (modpath != NULL) { 2275 /* __path__ is set, so modname is already the package name */ 2276 Py_ssize_t len = PyString_GET_SIZE(modname); 2277 int error; 2278 if (len > MAXPATHLEN) { 2279 PyErr_SetString(PyExc_ValueError, 2280 "Module name too long"); 2281 return NULL; 2282 } 2283 strcpy(buf, PyString_AS_STRING(modname)); 2284 error = PyDict_SetItem(globals, pkgstr, modname); 2285 if (error) { 2286 PyErr_SetString(PyExc_ValueError, 2287 "Could not set __package__"); 2288 return NULL; 2289 } 2290 } else { 2291 /* Normal module, so work out the package name if any */ 2292 char *start = PyString_AS_STRING(modname); 2293 char *lastdot = strrchr(start, '.'); 2294 size_t len; 2295 int error; 2296 if (lastdot == NULL && level > 0) { 2297 PyErr_SetString(PyExc_ValueError, 2298 "Attempted relative import in non-package"); 2299 return NULL; 2300 } 2301 if (lastdot == NULL) { 2302 error = PyDict_SetItem(globals, pkgstr, Py_None); 2303 if (error) { 2304 PyErr_SetString(PyExc_ValueError, 2305 "Could not set __package__"); 2306 return NULL; 2307 } 2308 return Py_None; 2309 } 2310 len = lastdot - start; 2311 if (len >= MAXPATHLEN) { 2312 PyErr_SetString(PyExc_ValueError, 2313 "Module name too long"); 2314 return NULL; 2315 } 2316 strncpy(buf, start, len); 2317 buf[len] = '\0'; 2318 pkgname = PyString_FromString(buf); 2319 if (pkgname == NULL) { 2320 return NULL; 2321 } 2322 error = PyDict_SetItem(globals, pkgstr, pkgname); 2323 Py_DECREF(pkgname); 2324 if (error) { 2325 PyErr_SetString(PyExc_ValueError, 2326 "Could not set __package__"); 2327 return NULL; 2328 } 2329 } 2330 } 2331 while (--level > 0) { 2332 char *dot = strrchr(buf, '.'); 2333 if (dot == NULL) { 2334 PyErr_SetString(PyExc_ValueError, 2335 "Attempted relative import beyond " 2336 "toplevel package"); 2337 return NULL; 2338 } 2339 *dot = '\0'; 2340 } 2341 *p_buflen = strlen(buf); 2342 2343 modules = PyImport_GetModuleDict(); 2344 parent = PyDict_GetItemString(modules, buf); 2345 if (parent == NULL) { 2346 if (orig_level < 1) { 2347 PyObject *err_msg = PyString_FromFormat( 2348 "Parent module '%.200s' not found " 2349 "while handling absolute import", buf); 2350 if (err_msg == NULL) { 2351 return NULL; 2352 } 2353 if (!PyErr_WarnEx(PyExc_RuntimeWarning, 2354 PyString_AsString(err_msg), 1)) { 2355 *buf = '\0'; 2356 *p_buflen = 0; 2357 parent = Py_None; 2358 } 2359 Py_DECREF(err_msg); 2360 } else { 2361 PyErr_Format(PyExc_SystemError, 2362 "Parent module '%.200s' not loaded, " 2363 "cannot perform relative import", buf); 2364 } 2365 } 2366 return parent; 2367 /* We expect, but can't guarantee, if parent != None, that: 2368 - parent.__name__ == buf 2369 - parent.__dict__ is globals 2370 If this is violated... Who cares? */ 2371} 2372 2373/* altmod is either None or same as mod */ 2374static PyObject * 2375load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf, 2376 Py_ssize_t *p_buflen) 2377{ 2378 char *name = *p_name; 2379 char *dot = strchr(name, '.'); 2380 size_t len; 2381 char *p; 2382 PyObject *result; 2383 2384 if (strlen(name) == 0) { 2385 /* completely empty module name should only happen in 2386 'from . import' (or '__import__("")')*/ 2387 Py_INCREF(mod); 2388 *p_name = NULL; 2389 return mod; 2390 } 2391 2392 if (dot == NULL) { 2393 *p_name = NULL; 2394 len = strlen(name); 2395 } 2396 else { 2397 *p_name = dot+1; 2398 len = dot-name; 2399 } 2400 if (len == 0) { 2401 PyErr_SetString(PyExc_ValueError, 2402 "Empty module name"); 2403 return NULL; 2404 } 2405 2406 p = buf + *p_buflen; 2407 if (p != buf) 2408 *p++ = '.'; 2409 if (p+len-buf >= MAXPATHLEN) { 2410 PyErr_SetString(PyExc_ValueError, 2411 "Module name too long"); 2412 return NULL; 2413 } 2414 strncpy(p, name, len); 2415 p[len] = '\0'; 2416 *p_buflen = p+len-buf; 2417 2418 result = import_submodule(mod, p, buf); 2419 if (result == Py_None && altmod != mod) { 2420 Py_DECREF(result); 2421 /* Here, altmod must be None and mod must not be None */ 2422 result = import_submodule(altmod, p, p); 2423 if (result != NULL && result != Py_None) { 2424 if (mark_miss(buf) != 0) { 2425 Py_DECREF(result); 2426 return NULL; 2427 } 2428 strncpy(buf, name, len); 2429 buf[len] = '\0'; 2430 *p_buflen = len; 2431 } 2432 } 2433 if (result == NULL) 2434 return NULL; 2435 2436 if (result == Py_None) { 2437 Py_DECREF(result); 2438 PyErr_Format(PyExc_ImportError, 2439 "No module named %.200s", name); 2440 return NULL; 2441 } 2442 2443 return result; 2444} 2445 2446static int 2447mark_miss(char *name) 2448{ 2449 PyObject *modules = PyImport_GetModuleDict(); 2450 return PyDict_SetItemString(modules, name, Py_None); 2451} 2452 2453static int 2454ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen, 2455 int recursive) 2456{ 2457 int i; 2458 2459 if (!PyObject_HasAttrString(mod, "__path__")) 2460 return 1; 2461 2462 for (i = 0; ; i++) { 2463 PyObject *item = PySequence_GetItem(fromlist, i); 2464 int hasit; 2465 if (item == NULL) { 2466 if (PyErr_ExceptionMatches(PyExc_IndexError)) { 2467 PyErr_Clear(); 2468 return 1; 2469 } 2470 return 0; 2471 } 2472 if (!PyString_Check(item)) { 2473 PyErr_SetString(PyExc_TypeError, 2474 "Item in ``from list'' not a string"); 2475 Py_DECREF(item); 2476 return 0; 2477 } 2478 if (PyString_AS_STRING(item)[0] == '*') { 2479 PyObject *all; 2480 Py_DECREF(item); 2481 /* See if the package defines __all__ */ 2482 if (recursive) 2483 continue; /* Avoid endless recursion */ 2484 all = PyObject_GetAttrString(mod, "__all__"); 2485 if (all == NULL) 2486 PyErr_Clear(); 2487 else { 2488 int ret = ensure_fromlist(mod, all, buf, buflen, 1); 2489 Py_DECREF(all); 2490 if (!ret) 2491 return 0; 2492 } 2493 continue; 2494 } 2495 hasit = PyObject_HasAttr(mod, item); 2496 if (!hasit) { 2497 char *subname = PyString_AS_STRING(item); 2498 PyObject *submod; 2499 char *p; 2500 if (buflen + strlen(subname) >= MAXPATHLEN) { 2501 PyErr_SetString(PyExc_ValueError, 2502 "Module name too long"); 2503 Py_DECREF(item); 2504 return 0; 2505 } 2506 p = buf + buflen; 2507 *p++ = '.'; 2508 strcpy(p, subname); 2509 submod = import_submodule(mod, subname, buf); 2510 Py_XDECREF(submod); 2511 if (submod == NULL) { 2512 Py_DECREF(item); 2513 return 0; 2514 } 2515 } 2516 Py_DECREF(item); 2517 } 2518 2519 /* NOTREACHED */ 2520} 2521 2522static int 2523add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname, 2524 PyObject *modules) 2525{ 2526 if (mod == Py_None) 2527 return 1; 2528 /* Irrespective of the success of this load, make a 2529 reference to it in the parent package module. A copy gets 2530 saved in the modules dictionary under the full name, so get a 2531 reference from there, if need be. (The exception is when the 2532 load failed with a SyntaxError -- then there's no trace in 2533 sys.modules. In that case, of course, do nothing extra.) */ 2534 if (submod == NULL) { 2535 submod = PyDict_GetItemString(modules, fullname); 2536 if (submod == NULL) 2537 return 1; 2538 } 2539 if (PyModule_Check(mod)) { 2540 /* We can't use setattr here since it can give a 2541 * spurious warning if the submodule name shadows a 2542 * builtin name */ 2543 PyObject *dict = PyModule_GetDict(mod); 2544 if (!dict) 2545 return 0; 2546 if (PyDict_SetItemString(dict, subname, submod) < 0) 2547 return 0; 2548 } 2549 else { 2550 if (PyObject_SetAttrString(mod, subname, submod) < 0) 2551 return 0; 2552 } 2553 return 1; 2554} 2555 2556static PyObject * 2557import_submodule(PyObject *mod, char *subname, char *fullname) 2558{ 2559 PyObject *modules = PyImport_GetModuleDict(); 2560 PyObject *m = NULL; 2561 2562 /* Require: 2563 if mod == None: subname == fullname 2564 else: mod.__name__ + "." + subname == fullname 2565 */ 2566 2567 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) { 2568 Py_INCREF(m); 2569 } 2570 else { 2571 PyObject *path, *loader = NULL; 2572 char buf[MAXPATHLEN+1]; 2573 struct filedescr *fdp; 2574 FILE *fp = NULL; 2575 2576 if (mod == Py_None) 2577 path = NULL; 2578 else { 2579 path = PyObject_GetAttrString(mod, "__path__"); 2580 if (path == NULL) { 2581 PyErr_Clear(); 2582 Py_INCREF(Py_None); 2583 return Py_None; 2584 } 2585 } 2586 2587 buf[0] = '\0'; 2588 fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1, 2589 &fp, &loader); 2590 Py_XDECREF(path); 2591 if (fdp == NULL) { 2592 if (!PyErr_ExceptionMatches(PyExc_ImportError)) 2593 return NULL; 2594 PyErr_Clear(); 2595 Py_INCREF(Py_None); 2596 return Py_None; 2597 } 2598 m = load_module(fullname, fp, buf, fdp->type, loader); 2599 Py_XDECREF(loader); 2600 if (fp) 2601 fclose(fp); 2602 if (!add_submodule(mod, m, fullname, subname, modules)) { 2603 Py_XDECREF(m); 2604 m = NULL; 2605 } 2606 } 2607 2608 return m; 2609} 2610 2611 2612/* Re-import a module of any kind and return its module object, WITH 2613 INCREMENTED REFERENCE COUNT */ 2614 2615PyObject * 2616PyImport_ReloadModule(PyObject *m) 2617{ 2618 PyInterpreterState *interp = PyThreadState_Get()->interp; 2619 PyObject *modules_reloading = interp->modules_reloading; 2620 PyObject *modules = PyImport_GetModuleDict(); 2621 PyObject *path = NULL, *loader = NULL, *existing_m = NULL; 2622 char *name, *subname; 2623 char buf[MAXPATHLEN+1]; 2624 struct filedescr *fdp; 2625 FILE *fp = NULL; 2626 PyObject *newm; 2627 2628 if (modules_reloading == NULL) { 2629 Py_FatalError("PyImport_ReloadModule: " 2630 "no modules_reloading dictionary!"); 2631 return NULL; 2632 } 2633 2634 if (m == NULL || !PyModule_Check(m)) { 2635 PyErr_SetString(PyExc_TypeError, 2636 "reload() argument must be module"); 2637 return NULL; 2638 } 2639 name = PyModule_GetName(m); 2640 if (name == NULL) 2641 return NULL; 2642 if (m != PyDict_GetItemString(modules, name)) { 2643 PyErr_Format(PyExc_ImportError, 2644 "reload(): module %.200s not in sys.modules", 2645 name); 2646 return NULL; 2647 } 2648 existing_m = PyDict_GetItemString(modules_reloading, name); 2649 if (existing_m != NULL) { 2650 /* Due to a recursive reload, this module is already 2651 being reloaded. */ 2652 Py_INCREF(existing_m); 2653 return existing_m; 2654 } 2655 if (PyDict_SetItemString(modules_reloading, name, m) < 0) 2656 return NULL; 2657 2658 subname = strrchr(name, '.'); 2659 if (subname == NULL) 2660 subname = name; 2661 else { 2662 PyObject *parentname, *parent; 2663 parentname = PyString_FromStringAndSize(name, (subname-name)); 2664 if (parentname == NULL) { 2665 imp_modules_reloading_clear(); 2666 return NULL; 2667 } 2668 parent = PyDict_GetItem(modules, parentname); 2669 if (parent == NULL) { 2670 PyErr_Format(PyExc_ImportError, 2671 "reload(): parent %.200s not in sys.modules", 2672 PyString_AS_STRING(parentname)); 2673 Py_DECREF(parentname); 2674 imp_modules_reloading_clear(); 2675 return NULL; 2676 } 2677 Py_DECREF(parentname); 2678 subname++; 2679 path = PyObject_GetAttrString(parent, "__path__"); 2680 if (path == NULL) 2681 PyErr_Clear(); 2682 } 2683 buf[0] = '\0'; 2684 fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader); 2685 Py_XDECREF(path); 2686 2687 if (fdp == NULL) { 2688 Py_XDECREF(loader); 2689 imp_modules_reloading_clear(); 2690 return NULL; 2691 } 2692 2693 newm = load_module(name, fp, buf, fdp->type, loader); 2694 Py_XDECREF(loader); 2695 2696 if (fp) 2697 fclose(fp); 2698 if (newm == NULL) { 2699 /* load_module probably removed name from modules because of 2700 * the error. Put back the original module object. We're 2701 * going to return NULL in this case regardless of whether 2702 * replacing name succeeds, so the return value is ignored. 2703 */ 2704 PyDict_SetItemString(modules, name, m); 2705 } 2706 imp_modules_reloading_clear(); 2707 return newm; 2708} 2709 2710 2711/* Higher-level import emulator which emulates the "import" statement 2712 more accurately -- it invokes the __import__() function from the 2713 builtins of the current globals. This means that the import is 2714 done using whatever import hooks are installed in the current 2715 environment, e.g. by "rexec". 2716 A dummy list ["__doc__"] is passed as the 4th argument so that 2717 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache")) 2718 will return <module "gencache"> instead of <module "win32com">. */ 2719 2720PyObject * 2721PyImport_Import(PyObject *module_name) 2722{ 2723 static PyObject *silly_list = NULL; 2724 static PyObject *builtins_str = NULL; 2725 static PyObject *import_str = NULL; 2726 PyObject *globals = NULL; 2727 PyObject *import = NULL; 2728 PyObject *builtins = NULL; 2729 PyObject *r = NULL; 2730 2731 /* Initialize constant string objects */ 2732 if (silly_list == NULL) { 2733 import_str = PyString_InternFromString("__import__"); 2734 if (import_str == NULL) 2735 return NULL; 2736 builtins_str = PyString_InternFromString("__builtins__"); 2737 if (builtins_str == NULL) 2738 return NULL; 2739 silly_list = Py_BuildValue("[s]", "__doc__"); 2740 if (silly_list == NULL) 2741 return NULL; 2742 } 2743 2744 /* Get the builtins from current globals */ 2745 globals = PyEval_GetGlobals(); 2746 if (globals != NULL) { 2747 Py_INCREF(globals); 2748 builtins = PyObject_GetItem(globals, builtins_str); 2749 if (builtins == NULL) 2750 goto err; 2751 } 2752 else { 2753 /* No globals -- use standard builtins, and fake globals */ 2754 builtins = PyImport_ImportModuleLevel("__builtin__", 2755 NULL, NULL, NULL, 0); 2756 if (builtins == NULL) 2757 return NULL; 2758 globals = Py_BuildValue("{OO}", builtins_str, builtins); 2759 if (globals == NULL) 2760 goto err; 2761 } 2762 2763 /* Get the __import__ function from the builtins */ 2764 if (PyDict_Check(builtins)) { 2765 import = PyObject_GetItem(builtins, import_str); 2766 if (import == NULL) 2767 PyErr_SetObject(PyExc_KeyError, import_str); 2768 } 2769 else 2770 import = PyObject_GetAttr(builtins, import_str); 2771 if (import == NULL) 2772 goto err; 2773 2774 /* Call the __import__ function with the proper argument list 2775 * Always use absolute import here. */ 2776 r = PyObject_CallFunction(import, "OOOOi", module_name, globals, 2777 globals, silly_list, 0, NULL); 2778 2779 err: 2780 Py_XDECREF(globals); 2781 Py_XDECREF(builtins); 2782 Py_XDECREF(import); 2783 2784 return r; 2785} 2786 2787 2788/* Module 'imp' provides Python access to the primitives used for 2789 importing modules. 2790*/ 2791 2792static PyObject * 2793imp_get_magic(PyObject *self, PyObject *noargs) 2794{ 2795 char buf[4]; 2796 2797 buf[0] = (char) ((pyc_magic >> 0) & 0xff); 2798 buf[1] = (char) ((pyc_magic >> 8) & 0xff); 2799 buf[2] = (char) ((pyc_magic >> 16) & 0xff); 2800 buf[3] = (char) ((pyc_magic >> 24) & 0xff); 2801 2802 return PyString_FromStringAndSize(buf, 4); 2803} 2804 2805static PyObject * 2806imp_get_suffixes(PyObject *self, PyObject *noargs) 2807{ 2808 PyObject *list; 2809 struct filedescr *fdp; 2810 2811 list = PyList_New(0); 2812 if (list == NULL) 2813 return NULL; 2814 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) { 2815 PyObject *item = Py_BuildValue("ssi", 2816 fdp->suffix, fdp->mode, fdp->type); 2817 if (item == NULL) { 2818 Py_DECREF(list); 2819 return NULL; 2820 } 2821 if (PyList_Append(list, item) < 0) { 2822 Py_DECREF(list); 2823 Py_DECREF(item); 2824 return NULL; 2825 } 2826 Py_DECREF(item); 2827 } 2828 return list; 2829} 2830 2831static PyObject * 2832call_find_module(char *name, PyObject *path) 2833{ 2834 extern int fclose(FILE *); 2835 PyObject *fob, *ret; 2836 struct filedescr *fdp; 2837 char pathname[MAXPATHLEN+1]; 2838 FILE *fp = NULL; 2839 2840 pathname[0] = '\0'; 2841 if (path == Py_None) 2842 path = NULL; 2843 fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL); 2844 if (fdp == NULL) 2845 return NULL; 2846 if (fp != NULL) { 2847 fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose); 2848 if (fob == NULL) { 2849 fclose(fp); 2850 return NULL; 2851 } 2852 } 2853 else { 2854 fob = Py_None; 2855 Py_INCREF(fob); 2856 } 2857 ret = Py_BuildValue("Os(ssi)", 2858 fob, pathname, fdp->suffix, fdp->mode, fdp->type); 2859 Py_DECREF(fob); 2860 return ret; 2861} 2862 2863static PyObject * 2864imp_find_module(PyObject *self, PyObject *args) 2865{ 2866 char *name; 2867 PyObject *path = NULL; 2868 if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path)) 2869 return NULL; 2870 return call_find_module(name, path); 2871} 2872 2873static PyObject * 2874imp_init_builtin(PyObject *self, PyObject *args) 2875{ 2876 char *name; 2877 int ret; 2878 PyObject *m; 2879 if (!PyArg_ParseTuple(args, "s:init_builtin", &name)) 2880 return NULL; 2881 ret = init_builtin(name); 2882 if (ret < 0) 2883 return NULL; 2884 if (ret == 0) { 2885 Py_INCREF(Py_None); 2886 return Py_None; 2887 } 2888 m = PyImport_AddModule(name); 2889 Py_XINCREF(m); 2890 return m; 2891} 2892 2893static PyObject * 2894imp_init_frozen(PyObject *self, PyObject *args) 2895{ 2896 char *name; 2897 int ret; 2898 PyObject *m; 2899 if (!PyArg_ParseTuple(args, "s:init_frozen", &name)) 2900 return NULL; 2901 ret = PyImport_ImportFrozenModule(name); 2902 if (ret < 0) 2903 return NULL; 2904 if (ret == 0) { 2905 Py_INCREF(Py_None); 2906 return Py_None; 2907 } 2908 m = PyImport_AddModule(name); 2909 Py_XINCREF(m); 2910 return m; 2911} 2912 2913static PyObject * 2914imp_get_frozen_object(PyObject *self, PyObject *args) 2915{ 2916 char *name; 2917 2918 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name)) 2919 return NULL; 2920 return get_frozen_object(name); 2921} 2922 2923static PyObject * 2924imp_is_builtin(PyObject *self, PyObject *args) 2925{ 2926 char *name; 2927 if (!PyArg_ParseTuple(args, "s:is_builtin", &name)) 2928 return NULL; 2929 return PyInt_FromLong(is_builtin(name)); 2930} 2931 2932static PyObject * 2933imp_is_frozen(PyObject *self, PyObject *args) 2934{ 2935 char *name; 2936 struct _frozen *p; 2937 if (!PyArg_ParseTuple(args, "s:is_frozen", &name)) 2938 return NULL; 2939 p = find_frozen(name); 2940 return PyBool_FromLong((long) (p == NULL ? 0 : p->size)); 2941} 2942 2943static FILE * 2944get_file(char *pathname, PyObject *fob, char *mode) 2945{ 2946 FILE *fp; 2947 if (fob == NULL) { 2948 if (mode[0] == 'U') 2949 mode = "r" PY_STDIOTEXTMODE; 2950 fp = fopen(pathname, mode); 2951 if (fp == NULL) 2952 PyErr_SetFromErrno(PyExc_IOError); 2953 } 2954 else { 2955 fp = PyFile_AsFile(fob); 2956 if (fp == NULL) 2957 PyErr_SetString(PyExc_ValueError, 2958 "bad/closed file object"); 2959 } 2960 return fp; 2961} 2962 2963static PyObject * 2964imp_load_compiled(PyObject *self, PyObject *args) 2965{ 2966 char *name; 2967 char *pathname; 2968 PyObject *fob = NULL; 2969 PyObject *m; 2970 FILE *fp; 2971 if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname, 2972 &PyFile_Type, &fob)) 2973 return NULL; 2974 fp = get_file(pathname, fob, "rb"); 2975 if (fp == NULL) 2976 return NULL; 2977 m = load_compiled_module(name, pathname, fp); 2978 if (fob == NULL) 2979 fclose(fp); 2980 return m; 2981} 2982 2983#ifdef HAVE_DYNAMIC_LOADING 2984 2985static PyObject * 2986imp_load_dynamic(PyObject *self, PyObject *args) 2987{ 2988 char *name; 2989 char *pathname; 2990 PyObject *fob = NULL; 2991 PyObject *m; 2992 FILE *fp = NULL; 2993 if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname, 2994 &PyFile_Type, &fob)) 2995 return NULL; 2996 if (fob) { 2997 fp = get_file(pathname, fob, "r"); 2998 if (fp == NULL) 2999 return NULL; 3000 } 3001 m = _PyImport_LoadDynamicModule(name, pathname, fp); 3002 return m; 3003} 3004 3005#endif /* HAVE_DYNAMIC_LOADING */ 3006 3007static PyObject * 3008imp_load_source(PyObject *self, PyObject *args) 3009{ 3010 char *name; 3011 char *pathname; 3012 PyObject *fob = NULL; 3013 PyObject *m; 3014 FILE *fp; 3015 if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname, 3016 &PyFile_Type, &fob)) 3017 return NULL; 3018 fp = get_file(pathname, fob, "r"); 3019 if (fp == NULL) 3020 return NULL; 3021 m = load_source_module(name, pathname, fp); 3022 if (fob == NULL) 3023 fclose(fp); 3024 return m; 3025} 3026 3027static PyObject * 3028imp_load_module(PyObject *self, PyObject *args) 3029{ 3030 char *name; 3031 PyObject *fob; 3032 char *pathname; 3033 char *suffix; /* Unused */ 3034 char *mode; 3035 int type; 3036 FILE *fp; 3037 3038 if (!PyArg_ParseTuple(args, "sOs(ssi):load_module", 3039 &name, &fob, &pathname, 3040 &suffix, &mode, &type)) 3041 return NULL; 3042 if (*mode) { 3043 /* Mode must start with 'r' or 'U' and must not contain '+'. 3044 Implicit in this test is the assumption that the mode 3045 may contain other modifiers like 'b' or 't'. */ 3046 3047 if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) { 3048 PyErr_Format(PyExc_ValueError, 3049 "invalid file open mode %.200s", mode); 3050 return NULL; 3051 } 3052 } 3053 if (fob == Py_None) 3054 fp = NULL; 3055 else { 3056 if (!PyFile_Check(fob)) { 3057 PyErr_SetString(PyExc_ValueError, 3058 "load_module arg#2 should be a file or None"); 3059 return NULL; 3060 } 3061 fp = get_file(pathname, fob, mode); 3062 if (fp == NULL) 3063 return NULL; 3064 } 3065 return load_module(name, fp, pathname, type, NULL); 3066} 3067 3068static PyObject * 3069imp_load_package(PyObject *self, PyObject *args) 3070{ 3071 char *name; 3072 char *pathname; 3073 if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname)) 3074 return NULL; 3075 return load_package(name, pathname); 3076} 3077 3078static PyObject * 3079imp_new_module(PyObject *self, PyObject *args) 3080{ 3081 char *name; 3082 if (!PyArg_ParseTuple(args, "s:new_module", &name)) 3083 return NULL; 3084 return PyModule_New(name); 3085} 3086 3087static PyObject * 3088imp_reload(PyObject *self, PyObject *v) 3089{ 3090 return PyImport_ReloadModule(v); 3091} 3092 3093 3094/* Doc strings */ 3095 3096PyDoc_STRVAR(doc_imp, 3097"This module provides the components needed to build your own\n\ 3098__import__ function. Undocumented functions are obsolete."); 3099 3100PyDoc_STRVAR(doc_reload, 3101"reload(module) -> module\n\ 3102\n\ 3103Reload the module. The module must have been successfully imported before."); 3104 3105PyDoc_STRVAR(doc_find_module, 3106"find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\ 3107Search for a module. If path is omitted or None, search for a\n\ 3108built-in, frozen or special module and continue search in sys.path.\n\ 3109The module name cannot contain '.'; to search for a submodule of a\n\ 3110package, pass the submodule name and the package's __path__."); 3111 3112PyDoc_STRVAR(doc_load_module, 3113"load_module(name, file, filename, (suffix, mode, type)) -> module\n\ 3114Load a module, given information returned by find_module().\n\ 3115The module name must include the full package name, if any."); 3116 3117PyDoc_STRVAR(doc_get_magic, 3118"get_magic() -> string\n\ 3119Return the magic number for .pyc or .pyo files."); 3120 3121PyDoc_STRVAR(doc_get_suffixes, 3122"get_suffixes() -> [(suffix, mode, type), ...]\n\ 3123Return a list of (suffix, mode, type) tuples describing the files\n\ 3124that find_module() looks for."); 3125 3126PyDoc_STRVAR(doc_new_module, 3127"new_module(name) -> module\n\ 3128Create a new module. Do not enter it in sys.modules.\n\ 3129The module name must include the full package name, if any."); 3130 3131PyDoc_STRVAR(doc_lock_held, 3132"lock_held() -> boolean\n\ 3133Return True if the import lock is currently held, else False.\n\ 3134On platforms without threads, return False."); 3135 3136PyDoc_STRVAR(doc_acquire_lock, 3137"acquire_lock() -> None\n\ 3138Acquires the interpreter's import lock for the current thread.\n\ 3139This lock should be used by import hooks to ensure thread-safety\n\ 3140when importing modules.\n\ 3141On platforms without threads, this function does nothing."); 3142 3143PyDoc_STRVAR(doc_release_lock, 3144"release_lock() -> None\n\ 3145Release the interpreter's import lock.\n\ 3146On platforms without threads, this function does nothing."); 3147 3148static PyMethodDef imp_methods[] = { 3149 {"reload", imp_reload, METH_O, doc_reload}, 3150 {"find_module", imp_find_module, METH_VARARGS, doc_find_module}, 3151 {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic}, 3152 {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes}, 3153 {"load_module", imp_load_module, METH_VARARGS, doc_load_module}, 3154 {"new_module", imp_new_module, METH_VARARGS, doc_new_module}, 3155 {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held}, 3156 {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock}, 3157 {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock}, 3158 /* The rest are obsolete */ 3159 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS}, 3160 {"init_builtin", imp_init_builtin, METH_VARARGS}, 3161 {"init_frozen", imp_init_frozen, METH_VARARGS}, 3162 {"is_builtin", imp_is_builtin, METH_VARARGS}, 3163 {"is_frozen", imp_is_frozen, METH_VARARGS}, 3164 {"load_compiled", imp_load_compiled, METH_VARARGS}, 3165#ifdef HAVE_DYNAMIC_LOADING 3166 {"load_dynamic", imp_load_dynamic, METH_VARARGS}, 3167#endif 3168 {"load_package", imp_load_package, METH_VARARGS}, 3169 {"load_source", imp_load_source, METH_VARARGS}, 3170 {NULL, NULL} /* sentinel */ 3171}; 3172 3173static int 3174setint(PyObject *d, char *name, int value) 3175{ 3176 PyObject *v; 3177 int err; 3178 3179 v = PyInt_FromLong((long)value); 3180 err = PyDict_SetItemString(d, name, v); 3181 Py_XDECREF(v); 3182 return err; 3183} 3184 3185typedef struct { 3186 PyObject_HEAD 3187} NullImporter; 3188 3189static int 3190NullImporter_init(NullImporter *self, PyObject *args, PyObject *kwds) 3191{ 3192 char *path; 3193 Py_ssize_t pathlen; 3194 3195 if (!_PyArg_NoKeywords("NullImporter()", kwds)) 3196 return -1; 3197 3198 if (!PyArg_ParseTuple(args, "s:NullImporter", 3199 &path)) 3200 return -1; 3201 3202 pathlen = strlen(path); 3203 if (pathlen == 0) { 3204 PyErr_SetString(PyExc_ImportError, "empty pathname"); 3205 return -1; 3206 } else { 3207#ifndef RISCOS 3208#ifndef MS_WINDOWS 3209 struct stat statbuf; 3210 int rv; 3211 3212 rv = stat(path, &statbuf); 3213 if (rv == 0) { 3214 /* it exists */ 3215 if (S_ISDIR(statbuf.st_mode)) { 3216 /* it's a directory */ 3217 PyErr_SetString(PyExc_ImportError, 3218 "existing directory"); 3219 return -1; 3220 } 3221 } 3222#else /* MS_WINDOWS */ 3223 DWORD rv; 3224 /* see issue1293 and issue3677: 3225 * stat() on Windows doesn't recognise paths like 3226 * "e:\\shared\\" and "\\\\whiterab-c2znlh\\shared" as dirs. 3227 */ 3228 rv = GetFileAttributesA(path); 3229 if (rv != INVALID_FILE_ATTRIBUTES) { 3230 /* it exists */ 3231 if (rv & FILE_ATTRIBUTE_DIRECTORY) { 3232 /* it's a directory */ 3233 PyErr_SetString(PyExc_ImportError, 3234 "existing directory"); 3235 return -1; 3236 } 3237 } 3238#endif 3239#else /* RISCOS */ 3240 if (object_exists(path)) { 3241 /* it exists */ 3242 if (isdir(path)) { 3243 /* it's a directory */ 3244 PyErr_SetString(PyExc_ImportError, 3245 "existing directory"); 3246 return -1; 3247 } 3248 } 3249#endif 3250 } 3251 return 0; 3252} 3253 3254static PyObject * 3255NullImporter_find_module(NullImporter *self, PyObject *args) 3256{ 3257 Py_RETURN_NONE; 3258} 3259 3260static PyMethodDef NullImporter_methods[] = { 3261 {"find_module", (PyCFunction)NullImporter_find_module, METH_VARARGS, 3262 "Always return None" 3263 }, 3264 {NULL} /* Sentinel */ 3265}; 3266 3267 3268PyTypeObject PyNullImporter_Type = { 3269 PyVarObject_HEAD_INIT(NULL, 0) 3270 "imp.NullImporter", /*tp_name*/ 3271 sizeof(NullImporter), /*tp_basicsize*/ 3272 0, /*tp_itemsize*/ 3273 0, /*tp_dealloc*/ 3274 0, /*tp_print*/ 3275 0, /*tp_getattr*/ 3276 0, /*tp_setattr*/ 3277 0, /*tp_compare*/ 3278 0, /*tp_repr*/ 3279 0, /*tp_as_number*/ 3280 0, /*tp_as_sequence*/ 3281 0, /*tp_as_mapping*/ 3282 0, /*tp_hash */ 3283 0, /*tp_call*/ 3284 0, /*tp_str*/ 3285 0, /*tp_getattro*/ 3286 0, /*tp_setattro*/ 3287 0, /*tp_as_buffer*/ 3288 Py_TPFLAGS_DEFAULT, /*tp_flags*/ 3289 "Null importer object", /* tp_doc */ 3290 0, /* tp_traverse */ 3291 0, /* tp_clear */ 3292 0, /* tp_richcompare */ 3293 0, /* tp_weaklistoffset */ 3294 0, /* tp_iter */ 3295 0, /* tp_iternext */ 3296 NullImporter_methods, /* tp_methods */ 3297 0, /* tp_members */ 3298 0, /* tp_getset */ 3299 0, /* tp_base */ 3300 0, /* tp_dict */ 3301 0, /* tp_descr_get */ 3302 0, /* tp_descr_set */ 3303 0, /* tp_dictoffset */ 3304 (initproc)NullImporter_init, /* tp_init */ 3305 0, /* tp_alloc */ 3306 PyType_GenericNew /* tp_new */ 3307}; 3308 3309 3310PyMODINIT_FUNC 3311initimp(void) 3312{ 3313 PyObject *m, *d; 3314 3315 if (PyType_Ready(&PyNullImporter_Type) < 0) 3316 goto failure; 3317 3318 m = Py_InitModule4("imp", imp_methods, doc_imp, 3319 NULL, PYTHON_API_VERSION); 3320 if (m == NULL) 3321 goto failure; 3322 d = PyModule_GetDict(m); 3323 if (d == NULL) 3324 goto failure; 3325 3326 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure; 3327 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure; 3328 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure; 3329 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure; 3330 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure; 3331 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure; 3332 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure; 3333 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure; 3334 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure; 3335 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure; 3336 3337 Py_INCREF(&PyNullImporter_Type); 3338 PyModule_AddObject(m, "NullImporter", (PyObject *)&PyNullImporter_Type); 3339 failure: 3340 ; 3341} 3342 3343 3344/* API for embedding applications that want to add their own entries 3345 to the table of built-in modules. This should normally be called 3346 *before* Py_Initialize(). When the table resize fails, -1 is 3347 returned and the existing table is unchanged. 3348 3349 After a similar function by Just van Rossum. */ 3350 3351int 3352PyImport_ExtendInittab(struct _inittab *newtab) 3353{ 3354 static struct _inittab *our_copy = NULL; 3355 struct _inittab *p; 3356 int i, n; 3357 3358 /* Count the number of entries in both tables */ 3359 for (n = 0; newtab[n].name != NULL; n++) 3360 ; 3361 if (n == 0) 3362 return 0; /* Nothing to do */ 3363 for (i = 0; PyImport_Inittab[i].name != NULL; i++) 3364 ; 3365 3366 /* Allocate new memory for the combined table */ 3367 p = our_copy; 3368 PyMem_RESIZE(p, struct _inittab, i+n+1); 3369 if (p == NULL) 3370 return -1; 3371 3372 /* Copy the tables into the new memory */ 3373 if (our_copy != PyImport_Inittab) 3374 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab)); 3375 PyImport_Inittab = our_copy = p; 3376 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab)); 3377 3378 return 0; 3379} 3380 3381/* Shorthand to add a single entry given a name and a function */ 3382 3383int 3384PyImport_AppendInittab(const char *name, void (*initfunc)(void)) 3385{ 3386 struct _inittab newtab[2]; 3387 3388 memset(newtab, '\0', sizeof newtab); 3389 3390 newtab[0].name = (char *)name; 3391 newtab[0].initfunc = initfunc; 3392 3393 return PyImport_ExtendInittab(newtab); 3394} 3395 3396#ifdef __cplusplus 3397} 3398#endif 3399