import.c revision 8ab04b4d65586829887822a78d038a33ee7a69fd
1 2/* Module definition and import implementation */ 3 4#include "Python.h" 5 6#include "node.h" 7#include "token.h" 8#include "errcode.h" 9#include "marshal.h" 10#include "compile.h" 11#include "eval.h" 12#include "osdefs.h" 13#include "importdl.h" 14#ifdef macintosh 15#include "macglue.h" 16#endif 17 18#ifdef HAVE_FCNTL_H 19#include <fcntl.h> 20#endif 21 22extern time_t PyOS_GetLastModificationTime(char *, FILE *); 23 /* In getmtime.c */ 24 25/* Magic word to reject .pyc files generated by other Python versions */ 26/* Change for each incompatible change */ 27/* The value of CR and LF is incorporated so if you ever read or write 28 a .pyc file in text mode the magic number will be wrong; also, the 29 Apple MPW compiler swaps their values, botching string constants. 30 XXX That probably isn't important anymore. 31*/ 32/* XXX Perhaps the magic number should be frozen and a version field 33 added to the .pyc file header? */ 34/* New way to come up with the low 16 bits of the magic number: 35 (YEAR-1995) * 10000 + MONTH * 100 + DAY 36 where MONTH and DAY are 1-based. 37 XXX Whatever the "old way" may have been isn't documented. 38 XXX This scheme breaks in 2002, as (2002-1995)*10000 = 70000 doesn't 39 fit in 16 bits. 40 XXX Later, sometimes 1 gets added to MAGIC in order to record that 41 the Unicode -U option is in use. IMO (Tim's), that's a Bad Idea 42 (quite apart from that the -U option doesn't work so isn't used 43 anyway). 44 45 XXX MAL, 2002-02-07: I had to modify the MAGIC due to a fix of the 46 UTF-8 encoder (it previously produced invalid UTF-8 for unpaired 47 high surrogates), so I simply bumped the month value to 20 (invalid 48 month) and set the day to 1. This should be recognizable by any 49 algorithm relying on the above scheme. Perhaps we should simply 50 start counting in increments of 10 from now on ?! 51 52 Known values: 53 Python 1.5: 20121 54 Python 1.5.1: 20121 55 Python 1.5.2: 20121 56 Python 2.0: 50823 57 Python 2.0.1: 50823 58 Python 2.1: 60202 59 Python 2.1.1: 60202 60 Python 2.1.2: 60202 61 Python 2.2: 60717 62 Python 2.3a0: 62001 63*/ 64#define MAGIC (62001 | ((long)'\r'<<16) | ((long)'\n'<<24)) 65 66/* Magic word as global; note that _PyImport_Init() can change the 67 value of this global to accommodate for alterations of how the 68 compiler works which are enabled by command line switches. */ 69static long pyc_magic = MAGIC; 70 71/* See _PyImport_FixupExtension() below */ 72static PyObject *extensions = NULL; 73 74/* This table is defined in config.c: */ 75extern struct _inittab _PyImport_Inittab[]; 76 77struct _inittab *PyImport_Inittab = _PyImport_Inittab; 78 79/* these tables define the module suffixes that Python recognizes */ 80struct filedescr * _PyImport_Filetab = NULL; 81 82#ifdef RISCOS 83static const struct filedescr _PyImport_StandardFiletab[] = { 84 {"/py", "r", PY_SOURCE}, 85 {"/pyc", "rb", PY_COMPILED}, 86 {0, 0} 87}; 88#else 89static const struct filedescr _PyImport_StandardFiletab[] = { 90 {".py", "r", PY_SOURCE}, 91#ifdef MS_WIN32 92 {".pyw", "r", PY_SOURCE}, 93#endif 94 {".pyc", "rb", PY_COMPILED}, 95 {0, 0} 96}; 97#endif 98 99/* Initialize things */ 100 101void 102_PyImport_Init(void) 103{ 104 const struct filedescr *scan; 105 struct filedescr *filetab; 106 int countD = 0; 107 int countS = 0; 108 109 /* prepare _PyImport_Filetab: copy entries from 110 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab. 111 */ 112 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan) 113 ++countD; 114 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan) 115 ++countS; 116 filetab = PyMem_NEW(struct filedescr, countD + countS + 1); 117 memcpy(filetab, _PyImport_DynLoadFiletab, 118 countD * sizeof(struct filedescr)); 119 memcpy(filetab + countD, _PyImport_StandardFiletab, 120 countS * sizeof(struct filedescr)); 121 filetab[countD + countS].suffix = NULL; 122 123 _PyImport_Filetab = filetab; 124 125 if (Py_OptimizeFlag) { 126 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */ 127 for (; filetab->suffix != NULL; filetab++) { 128#ifndef RISCOS 129 if (strcmp(filetab->suffix, ".pyc") == 0) 130 filetab->suffix = ".pyo"; 131#else 132 if (strcmp(filetab->suffix, "/pyc") == 0) 133 filetab->suffix = "/pyo"; 134#endif 135 } 136 } 137 138 if (Py_UnicodeFlag) { 139 /* Fix the pyc_magic so that byte compiled code created 140 using the all-Unicode method doesn't interfere with 141 code created in normal operation mode. */ 142 pyc_magic = MAGIC + 1; 143 } 144} 145 146void 147_PyImport_Fini(void) 148{ 149 Py_XDECREF(extensions); 150 extensions = NULL; 151 PyMem_DEL(_PyImport_Filetab); 152 _PyImport_Filetab = NULL; 153} 154 155 156/* Locking primitives to prevent parallel imports of the same module 157 in different threads to return with a partially loaded module. 158 These calls are serialized by the global interpreter lock. */ 159 160#ifdef WITH_THREAD 161 162#include "pythread.h" 163 164static PyThread_type_lock import_lock = 0; 165static long import_lock_thread = -1; 166static int import_lock_level = 0; 167 168static void 169lock_import(void) 170{ 171 long me = PyThread_get_thread_ident(); 172 if (me == -1) 173 return; /* Too bad */ 174 if (import_lock == NULL) 175 import_lock = PyThread_allocate_lock(); 176 if (import_lock_thread == me) { 177 import_lock_level++; 178 return; 179 } 180 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0)) { 181 PyThreadState *tstate = PyEval_SaveThread(); 182 PyThread_acquire_lock(import_lock, 1); 183 PyEval_RestoreThread(tstate); 184 } 185 import_lock_thread = me; 186 import_lock_level = 1; 187} 188 189static void 190unlock_import(void) 191{ 192 long me = PyThread_get_thread_ident(); 193 if (me == -1) 194 return; /* Too bad */ 195 if (import_lock_thread != me) 196 Py_FatalError("unlock_import: not holding the import lock"); 197 import_lock_level--; 198 if (import_lock_level == 0) { 199 import_lock_thread = -1; 200 PyThread_release_lock(import_lock); 201 } 202} 203 204#else 205 206#define lock_import() 207#define unlock_import() 208 209#endif 210 211static PyObject * 212imp_lock_held(PyObject *self, PyObject *args) 213{ 214 if (!PyArg_ParseTuple(args, ":lock_held")) 215 return NULL; 216#ifdef WITH_THREAD 217 return PyBool_FromLong(import_lock_thread != -1); 218#else 219 return PyBool_FromLong(0); 220#endif 221} 222 223/* Helper for sys */ 224 225PyObject * 226PyImport_GetModuleDict(void) 227{ 228 PyInterpreterState *interp = PyThreadState_Get()->interp; 229 if (interp->modules == NULL) 230 Py_FatalError("PyImport_GetModuleDict: no module dictionary!"); 231 return interp->modules; 232} 233 234 235/* List of names to clear in sys */ 236static char* sys_deletes[] = { 237 "path", "argv", "ps1", "ps2", "exitfunc", 238 "exc_type", "exc_value", "exc_traceback", 239 "last_type", "last_value", "last_traceback", 240 NULL 241}; 242 243static char* sys_files[] = { 244 "stdin", "__stdin__", 245 "stdout", "__stdout__", 246 "stderr", "__stderr__", 247 NULL 248}; 249 250 251/* Un-initialize things, as good as we can */ 252 253void 254PyImport_Cleanup(void) 255{ 256 int pos, ndone; 257 char *name; 258 PyObject *key, *value, *dict; 259 PyInterpreterState *interp = PyThreadState_Get()->interp; 260 PyObject *modules = interp->modules; 261 262 if (modules == NULL) 263 return; /* Already done */ 264 265 /* Delete some special variables first. These are common 266 places where user values hide and people complain when their 267 destructors fail. Since the modules containing them are 268 deleted *last* of all, they would come too late in the normal 269 destruction order. Sigh. */ 270 271 value = PyDict_GetItemString(modules, "__builtin__"); 272 if (value != NULL && PyModule_Check(value)) { 273 dict = PyModule_GetDict(value); 274 if (Py_VerboseFlag) 275 PySys_WriteStderr("# clear __builtin__._\n"); 276 PyDict_SetItemString(dict, "_", Py_None); 277 } 278 value = PyDict_GetItemString(modules, "sys"); 279 if (value != NULL && PyModule_Check(value)) { 280 char **p; 281 PyObject *v; 282 dict = PyModule_GetDict(value); 283 for (p = sys_deletes; *p != NULL; p++) { 284 if (Py_VerboseFlag) 285 PySys_WriteStderr("# clear sys.%s\n", *p); 286 PyDict_SetItemString(dict, *p, Py_None); 287 } 288 for (p = sys_files; *p != NULL; p+=2) { 289 if (Py_VerboseFlag) 290 PySys_WriteStderr("# restore sys.%s\n", *p); 291 v = PyDict_GetItemString(dict, *(p+1)); 292 if (v == NULL) 293 v = Py_None; 294 PyDict_SetItemString(dict, *p, v); 295 } 296 } 297 298 /* First, delete __main__ */ 299 value = PyDict_GetItemString(modules, "__main__"); 300 if (value != NULL && PyModule_Check(value)) { 301 if (Py_VerboseFlag) 302 PySys_WriteStderr("# cleanup __main__\n"); 303 _PyModule_Clear(value); 304 PyDict_SetItemString(modules, "__main__", Py_None); 305 } 306 307 /* The special treatment of __builtin__ here is because even 308 when it's not referenced as a module, its dictionary is 309 referenced by almost every module's __builtins__. Since 310 deleting a module clears its dictionary (even if there are 311 references left to it), we need to delete the __builtin__ 312 module last. Likewise, we don't delete sys until the very 313 end because it is implicitly referenced (e.g. by print). 314 315 Also note that we 'delete' modules by replacing their entry 316 in the modules dict with None, rather than really deleting 317 them; this avoids a rehash of the modules dictionary and 318 also marks them as "non existent" so they won't be 319 re-imported. */ 320 321 /* Next, repeatedly delete modules with a reference count of 322 one (skipping __builtin__ and sys) and delete them */ 323 do { 324 ndone = 0; 325 pos = 0; 326 while (PyDict_Next(modules, &pos, &key, &value)) { 327 if (value->ob_refcnt != 1) 328 continue; 329 if (PyString_Check(key) && PyModule_Check(value)) { 330 name = PyString_AS_STRING(key); 331 if (strcmp(name, "__builtin__") == 0) 332 continue; 333 if (strcmp(name, "sys") == 0) 334 continue; 335 if (Py_VerboseFlag) 336 PySys_WriteStderr( 337 "# cleanup[1] %s\n", name); 338 _PyModule_Clear(value); 339 PyDict_SetItem(modules, key, Py_None); 340 ndone++; 341 } 342 } 343 } while (ndone > 0); 344 345 /* Next, delete all modules (still skipping __builtin__ and sys) */ 346 pos = 0; 347 while (PyDict_Next(modules, &pos, &key, &value)) { 348 if (PyString_Check(key) && PyModule_Check(value)) { 349 name = PyString_AS_STRING(key); 350 if (strcmp(name, "__builtin__") == 0) 351 continue; 352 if (strcmp(name, "sys") == 0) 353 continue; 354 if (Py_VerboseFlag) 355 PySys_WriteStderr("# cleanup[2] %s\n", name); 356 _PyModule_Clear(value); 357 PyDict_SetItem(modules, key, Py_None); 358 } 359 } 360 361 /* Next, delete sys and __builtin__ (in that order) */ 362 value = PyDict_GetItemString(modules, "sys"); 363 if (value != NULL && PyModule_Check(value)) { 364 if (Py_VerboseFlag) 365 PySys_WriteStderr("# cleanup sys\n"); 366 _PyModule_Clear(value); 367 PyDict_SetItemString(modules, "sys", Py_None); 368 } 369 value = PyDict_GetItemString(modules, "__builtin__"); 370 if (value != NULL && PyModule_Check(value)) { 371 if (Py_VerboseFlag) 372 PySys_WriteStderr("# cleanup __builtin__\n"); 373 _PyModule_Clear(value); 374 PyDict_SetItemString(modules, "__builtin__", Py_None); 375 } 376 377 /* Finally, clear and delete the modules directory */ 378 PyDict_Clear(modules); 379 interp->modules = NULL; 380 Py_DECREF(modules); 381} 382 383 384/* Helper for pythonrun.c -- return magic number */ 385 386long 387PyImport_GetMagicNumber(void) 388{ 389 return pyc_magic; 390} 391 392 393/* Magic for extension modules (built-in as well as dynamically 394 loaded). To prevent initializing an extension module more than 395 once, we keep a static dictionary 'extensions' keyed by module name 396 (for built-in modules) or by filename (for dynamically loaded 397 modules), containing these modules. A copy of the module's 398 dictionary is stored by calling _PyImport_FixupExtension() 399 immediately after the module initialization function succeeds. A 400 copy can be retrieved from there by calling 401 _PyImport_FindExtension(). */ 402 403PyObject * 404_PyImport_FixupExtension(char *name, char *filename) 405{ 406 PyObject *modules, *mod, *dict, *copy; 407 if (extensions == NULL) { 408 extensions = PyDict_New(); 409 if (extensions == NULL) 410 return NULL; 411 } 412 modules = PyImport_GetModuleDict(); 413 mod = PyDict_GetItemString(modules, name); 414 if (mod == NULL || !PyModule_Check(mod)) { 415 PyErr_Format(PyExc_SystemError, 416 "_PyImport_FixupExtension: module %.200s not loaded", name); 417 return NULL; 418 } 419 dict = PyModule_GetDict(mod); 420 if (dict == NULL) 421 return NULL; 422 copy = PyDict_Copy(dict); 423 if (copy == NULL) 424 return NULL; 425 PyDict_SetItemString(extensions, filename, copy); 426 Py_DECREF(copy); 427 return copy; 428} 429 430PyObject * 431_PyImport_FindExtension(char *name, char *filename) 432{ 433 PyObject *dict, *mod, *mdict; 434 if (extensions == NULL) 435 return NULL; 436 dict = PyDict_GetItemString(extensions, filename); 437 if (dict == NULL) 438 return NULL; 439 mod = PyImport_AddModule(name); 440 if (mod == NULL) 441 return NULL; 442 mdict = PyModule_GetDict(mod); 443 if (mdict == NULL) 444 return NULL; 445 if (PyDict_Update(mdict, dict)) 446 return NULL; 447 if (Py_VerboseFlag) 448 PySys_WriteStderr("import %s # previously loaded (%s)\n", 449 name, filename); 450 return mod; 451} 452 453 454/* Get the module object corresponding to a module name. 455 First check the modules dictionary if there's one there, 456 if not, create a new one and insert in in the modules dictionary. 457 Because the former action is most common, THIS DOES NOT RETURN A 458 'NEW' REFERENCE! */ 459 460PyObject * 461PyImport_AddModule(char *name) 462{ 463 PyObject *modules = PyImport_GetModuleDict(); 464 PyObject *m; 465 466 if ((m = PyDict_GetItemString(modules, name)) != NULL && 467 PyModule_Check(m)) 468 return m; 469 m = PyModule_New(name); 470 if (m == NULL) 471 return NULL; 472 if (PyDict_SetItemString(modules, name, m) != 0) { 473 Py_DECREF(m); 474 return NULL; 475 } 476 Py_DECREF(m); /* Yes, it still exists, in modules! */ 477 478 return m; 479} 480 481 482/* Execute a code object in a module and return the module object 483 WITH INCREMENTED REFERENCE COUNT */ 484 485PyObject * 486PyImport_ExecCodeModule(char *name, PyObject *co) 487{ 488 return PyImport_ExecCodeModuleEx(name, co, (char *)NULL); 489} 490 491PyObject * 492PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname) 493{ 494 PyObject *modules = PyImport_GetModuleDict(); 495 PyObject *m, *d, *v; 496 497 m = PyImport_AddModule(name); 498 if (m == NULL) 499 return NULL; 500 d = PyModule_GetDict(m); 501 if (PyDict_GetItemString(d, "__builtins__") == NULL) { 502 if (PyDict_SetItemString(d, "__builtins__", 503 PyEval_GetBuiltins()) != 0) 504 return NULL; 505 } 506 /* Remember the filename as the __file__ attribute */ 507 v = NULL; 508 if (pathname != NULL) { 509 v = PyString_FromString(pathname); 510 if (v == NULL) 511 PyErr_Clear(); 512 } 513 if (v == NULL) { 514 v = ((PyCodeObject *)co)->co_filename; 515 Py_INCREF(v); 516 } 517 if (PyDict_SetItemString(d, "__file__", v) != 0) 518 PyErr_Clear(); /* Not important enough to report */ 519 Py_DECREF(v); 520 521 v = PyEval_EvalCode((PyCodeObject *)co, d, d); 522 if (v == NULL) 523 return NULL; 524 Py_DECREF(v); 525 526 if ((m = PyDict_GetItemString(modules, name)) == NULL) { 527 PyErr_Format(PyExc_ImportError, 528 "Loaded module %.200s not found in sys.modules", 529 name); 530 return NULL; 531 } 532 533 Py_INCREF(m); 534 535 return m; 536} 537 538 539/* Given a pathname for a Python source file, fill a buffer with the 540 pathname for the corresponding compiled file. Return the pathname 541 for the compiled file, or NULL if there's no space in the buffer. 542 Doesn't set an exception. */ 543 544static char * 545make_compiled_pathname(char *pathname, char *buf, size_t buflen) 546{ 547 size_t len = strlen(pathname); 548 if (len+2 > buflen) 549 return NULL; 550 551#ifdef MS_WIN32 552 /* Treat .pyw as if it were .py. The case of ".pyw" must match 553 that used in _PyImport_StandardFiletab. */ 554 if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0) 555 --len; /* pretend 'w' isn't there */ 556#endif 557 memcpy(buf, pathname, len); 558 buf[len] = Py_OptimizeFlag ? 'o' : 'c'; 559 buf[len+1] = '\0'; 560 561 return buf; 562} 563 564 565/* Given a pathname for a Python source file, its time of last 566 modification, and a pathname for a compiled file, check whether the 567 compiled file represents the same version of the source. If so, 568 return a FILE pointer for the compiled file, positioned just after 569 the header; if not, return NULL. 570 Doesn't set an exception. */ 571 572static FILE * 573check_compiled_module(char *pathname, long mtime, char *cpathname) 574{ 575 FILE *fp; 576 long magic; 577 long pyc_mtime; 578 579 fp = fopen(cpathname, "rb"); 580 if (fp == NULL) 581 return NULL; 582 magic = PyMarshal_ReadLongFromFile(fp); 583 if (magic != pyc_magic) { 584 if (Py_VerboseFlag) 585 PySys_WriteStderr("# %s has bad magic\n", cpathname); 586 fclose(fp); 587 return NULL; 588 } 589 pyc_mtime = PyMarshal_ReadLongFromFile(fp); 590 if (pyc_mtime != mtime) { 591 if (Py_VerboseFlag) 592 PySys_WriteStderr("# %s has bad mtime\n", cpathname); 593 fclose(fp); 594 return NULL; 595 } 596 if (Py_VerboseFlag) 597 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname); 598 return fp; 599} 600 601 602/* Read a code object from a file and check it for validity */ 603 604static PyCodeObject * 605read_compiled_module(char *cpathname, FILE *fp) 606{ 607 PyObject *co; 608 609 co = PyMarshal_ReadLastObjectFromFile(fp); 610 /* Ugly: rd_object() may return NULL with or without error */ 611 if (co == NULL || !PyCode_Check(co)) { 612 if (!PyErr_Occurred()) 613 PyErr_Format(PyExc_ImportError, 614 "Non-code object in %.200s", cpathname); 615 Py_XDECREF(co); 616 return NULL; 617 } 618 return (PyCodeObject *)co; 619} 620 621 622/* Load a module from a compiled file, execute it, and return its 623 module object WITH INCREMENTED REFERENCE COUNT */ 624 625static PyObject * 626load_compiled_module(char *name, char *cpathname, FILE *fp) 627{ 628 long magic; 629 PyCodeObject *co; 630 PyObject *m; 631 632 magic = PyMarshal_ReadLongFromFile(fp); 633 if (magic != pyc_magic) { 634 PyErr_Format(PyExc_ImportError, 635 "Bad magic number in %.200s", cpathname); 636 return NULL; 637 } 638 (void) PyMarshal_ReadLongFromFile(fp); 639 co = read_compiled_module(cpathname, fp); 640 if (co == NULL) 641 return NULL; 642 if (Py_VerboseFlag) 643 PySys_WriteStderr("import %s # precompiled from %s\n", 644 name, cpathname); 645 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname); 646 Py_DECREF(co); 647 648 return m; 649} 650 651/* Parse a source file and return the corresponding code object */ 652 653static PyCodeObject * 654parse_source_module(char *pathname, FILE *fp) 655{ 656 PyCodeObject *co; 657 node *n; 658 659 n = PyParser_SimpleParseFile(fp, pathname, Py_file_input); 660 if (n == NULL) 661 return NULL; 662 co = PyNode_Compile(n, pathname); 663 PyNode_Free(n); 664 665 return co; 666} 667 668 669/* Helper to open a bytecode file for writing in exclusive mode */ 670 671static FILE * 672open_exclusive(char *filename) 673{ 674#if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC) 675 /* Use O_EXCL to avoid a race condition when another process tries to 676 write the same file. When that happens, our open() call fails, 677 which is just fine (since it's only a cache). 678 XXX If the file exists and is writable but the directory is not 679 writable, the file will never be written. Oh well. 680 */ 681 int fd; 682 (void) unlink(filename); 683 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC 684#ifdef O_BINARY 685 |O_BINARY /* necessary for Windows */ 686#endif 687 688 , 0666); 689 if (fd < 0) 690 return NULL; 691 return fdopen(fd, "wb"); 692#else 693 /* Best we can do -- on Windows this can't happen anyway */ 694 return fopen(filename, "wb"); 695#endif 696} 697 698 699/* Write a compiled module to a file, placing the time of last 700 modification of its source into the header. 701 Errors are ignored, if a write error occurs an attempt is made to 702 remove the file. */ 703 704static void 705write_compiled_module(PyCodeObject *co, char *cpathname, long mtime) 706{ 707 FILE *fp; 708 709 fp = open_exclusive(cpathname); 710 if (fp == NULL) { 711 if (Py_VerboseFlag) 712 PySys_WriteStderr( 713 "# can't create %s\n", cpathname); 714 return; 715 } 716 PyMarshal_WriteLongToFile(pyc_magic, fp); 717 /* First write a 0 for mtime */ 718 PyMarshal_WriteLongToFile(0L, fp); 719 PyMarshal_WriteObjectToFile((PyObject *)co, fp); 720 if (ferror(fp)) { 721 if (Py_VerboseFlag) 722 PySys_WriteStderr("# can't write %s\n", cpathname); 723 /* Don't keep partial file */ 724 fclose(fp); 725 (void) unlink(cpathname); 726 return; 727 } 728 /* Now write the true mtime */ 729 fseek(fp, 4L, 0); 730 PyMarshal_WriteLongToFile(mtime, fp); 731 fflush(fp); 732 fclose(fp); 733 if (Py_VerboseFlag) 734 PySys_WriteStderr("# wrote %s\n", cpathname); 735#ifdef macintosh 736 PyMac_setfiletype(cpathname, 'Pyth', 'PYC '); 737#endif 738} 739 740 741/* Load a source module from a given file and return its module 742 object WITH INCREMENTED REFERENCE COUNT. If there's a matching 743 byte-compiled file, use that instead. */ 744 745static PyObject * 746load_source_module(char *name, char *pathname, FILE *fp) 747{ 748 time_t mtime; 749 FILE *fpc; 750 char buf[MAXPATHLEN+1]; 751 char *cpathname; 752 PyCodeObject *co; 753 PyObject *m; 754 755 mtime = PyOS_GetLastModificationTime(pathname, fp); 756 if (mtime == (time_t)(-1)) 757 return NULL; 758#if SIZEOF_TIME_T > 4 759 /* Python's .pyc timestamp handling presumes that the timestamp fits 760 in 4 bytes. This will be fine until sometime in the year 2038, 761 when a 4-byte signed time_t will overflow. 762 */ 763 if (mtime >> 32) { 764 PyErr_SetString(PyExc_OverflowError, 765 "modification time overflows a 4 byte field"); 766 return NULL; 767 } 768#endif 769 cpathname = make_compiled_pathname(pathname, buf, 770 (size_t)MAXPATHLEN + 1); 771 if (cpathname != NULL && 772 (fpc = check_compiled_module(pathname, mtime, cpathname))) { 773 co = read_compiled_module(cpathname, fpc); 774 fclose(fpc); 775 if (co == NULL) 776 return NULL; 777 if (Py_VerboseFlag) 778 PySys_WriteStderr("import %s # precompiled from %s\n", 779 name, cpathname); 780 pathname = cpathname; 781 } 782 else { 783 co = parse_source_module(pathname, fp); 784 if (co == NULL) 785 return NULL; 786 if (Py_VerboseFlag) 787 PySys_WriteStderr("import %s # from %s\n", 788 name, pathname); 789 write_compiled_module(co, cpathname, mtime); 790 } 791 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname); 792 Py_DECREF(co); 793 794 return m; 795} 796 797 798/* Forward */ 799static PyObject *load_module(char *, FILE *, char *, int); 800static struct filedescr *find_module(char *, PyObject *, 801 char *, size_t, FILE **); 802static struct _frozen *find_frozen(char *name); 803 804/* Load a package and return its module object WITH INCREMENTED 805 REFERENCE COUNT */ 806 807static PyObject * 808load_package(char *name, char *pathname) 809{ 810 PyObject *m, *d, *file, *path; 811 int err; 812 char buf[MAXPATHLEN+1]; 813 FILE *fp = NULL; 814 struct filedescr *fdp; 815 816 m = PyImport_AddModule(name); 817 if (m == NULL) 818 return NULL; 819 if (Py_VerboseFlag) 820 PySys_WriteStderr("import %s # directory %s\n", 821 name, pathname); 822 d = PyModule_GetDict(m); 823 file = PyString_FromString(pathname); 824 if (file == NULL) 825 return NULL; 826 path = Py_BuildValue("[O]", file); 827 if (path == NULL) { 828 Py_DECREF(file); 829 return NULL; 830 } 831 err = PyDict_SetItemString(d, "__file__", file); 832 if (err == 0) 833 err = PyDict_SetItemString(d, "__path__", path); 834 if (err != 0) { 835 m = NULL; 836 goto cleanup; 837 } 838 buf[0] = '\0'; 839 fdp = find_module("__init__", path, buf, sizeof(buf), &fp); 840 if (fdp == NULL) { 841 if (PyErr_ExceptionMatches(PyExc_ImportError)) { 842 PyErr_Clear(); 843 } 844 else 845 m = NULL; 846 goto cleanup; 847 } 848 m = load_module(name, fp, buf, fdp->type); 849 if (fp != NULL) 850 fclose(fp); 851 cleanup: 852 Py_XDECREF(path); 853 Py_XDECREF(file); 854 return m; 855} 856 857 858/* Helper to test for built-in module */ 859 860static int 861is_builtin(char *name) 862{ 863 int i; 864 for (i = 0; PyImport_Inittab[i].name != NULL; i++) { 865 if (strcmp(name, PyImport_Inittab[i].name) == 0) { 866 if (PyImport_Inittab[i].initfunc == NULL) 867 return -1; 868 else 869 return 1; 870 } 871 } 872 return 0; 873} 874 875 876/* Search the path (default sys.path) for a module. Return the 877 corresponding filedescr struct, and (via return arguments) the 878 pathname and an open file. Return NULL if the module is not found. */ 879 880#ifdef MS_COREDLL 881extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **, 882 char *, int); 883#endif 884 885static int case_ok(char *, int, int, char *); 886static int find_init_module(char *); /* Forward */ 887 888static struct filedescr * 889find_module(char *realname, PyObject *path, char *buf, size_t buflen, 890 FILE **p_fp) 891{ 892 int i, npath; 893 size_t len, namelen; 894 struct filedescr *fdp = NULL; 895 FILE *fp = NULL; 896#ifndef RISCOS 897 struct stat statbuf; 898#endif 899 static struct filedescr fd_frozen = {"", "", PY_FROZEN}; 900 static struct filedescr fd_builtin = {"", "", C_BUILTIN}; 901 static struct filedescr fd_package = {"", "", PKG_DIRECTORY}; 902 char name[MAXPATHLEN+1]; 903#if defined(PYOS_OS2) 904 size_t saved_len; 905 size_t saved_namelen; 906 char *saved_buf = NULL; 907#endif 908 909 if (strlen(realname) > MAXPATHLEN) { 910 PyErr_SetString(PyExc_OverflowError, 911 "module name is too long"); 912 return NULL; 913 } 914 strcpy(name, realname); 915 916 if (path != NULL && PyString_Check(path)) { 917 /* The only type of submodule allowed inside a "frozen" 918 package are other frozen modules or packages. */ 919 if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) { 920 PyErr_SetString(PyExc_ImportError, 921 "full frozen module name too long"); 922 return NULL; 923 } 924 strcpy(buf, PyString_AsString(path)); 925 strcat(buf, "."); 926 strcat(buf, name); 927 strcpy(name, buf); 928#ifdef macintosh 929 /* Freezing on the mac works different, and the modules are 930 ** actually on sys.path. So we don't take the quick exit but 931 ** continue with the normal flow. 932 */ 933 path = NULL; 934#else 935 if (find_frozen(name) != NULL) { 936 strcpy(buf, name); 937 return &fd_frozen; 938 } 939 PyErr_Format(PyExc_ImportError, 940 "No frozen submodule named %.200s", name); 941 return NULL; 942#endif 943 } 944 if (path == NULL) { 945 if (is_builtin(name)) { 946 strcpy(buf, name); 947 return &fd_builtin; 948 } 949 if ((find_frozen(name)) != NULL) { 950 strcpy(buf, name); 951 return &fd_frozen; 952 } 953 954#ifdef MS_COREDLL 955 fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen); 956 if (fp != NULL) { 957 *p_fp = fp; 958 return fdp; 959 } 960#endif 961 path = PySys_GetObject("path"); 962 } 963 if (path == NULL || !PyList_Check(path)) { 964 PyErr_SetString(PyExc_ImportError, 965 "sys.path must be a list of directory names"); 966 return NULL; 967 } 968 npath = PyList_Size(path); 969 namelen = strlen(name); 970 for (i = 0; i < npath; i++) { 971 PyObject *v = PyList_GetItem(path, i); 972 if (!PyString_Check(v)) 973 continue; 974 len = PyString_Size(v); 975 if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) 976 continue; /* Too long */ 977 strcpy(buf, PyString_AsString(v)); 978 if (strlen(buf) != len) 979 continue; /* v contains '\0' */ 980#ifdef macintosh 981 /* 982 ** Speedup: each sys.path item is interned, and 983 ** FindResourceModule remembers which items refer to 984 ** folders (so we don't have to bother trying to look 985 ** into them for resources). 986 */ 987 PyString_InternInPlace(&PyList_GET_ITEM(path, i)); 988 v = PyList_GET_ITEM(path, i); 989 if (PyMac_FindResourceModule((PyStringObject *)v, name, buf)) { 990 static struct filedescr resfiledescr = 991 {"", "", PY_RESOURCE}; 992 993 return &resfiledescr; 994 } 995 if (PyMac_FindCodeResourceModule((PyStringObject *)v, name, buf)) { 996 static struct filedescr resfiledescr = 997 {"", "", PY_CODERESOURCE}; 998 999 return &resfiledescr; 1000 } 1001#endif 1002 if (len > 0 && buf[len-1] != SEP 1003#ifdef ALTSEP 1004 && buf[len-1] != ALTSEP 1005#endif 1006 ) 1007 buf[len++] = SEP; 1008 strcpy(buf+len, name); 1009 len += namelen; 1010 1011 /* Check for package import (buf holds a directory name, 1012 and there's an __init__ module in that directory */ 1013#ifdef HAVE_STAT 1014 if (stat(buf, &statbuf) == 0 && /* it exists */ 1015 S_ISDIR(statbuf.st_mode) && /* it's a directory */ 1016 find_init_module(buf) && /* it has __init__.py */ 1017 case_ok(buf, len, namelen, name)) /* and case matches */ 1018 return &fd_package; 1019#else 1020 /* XXX How are you going to test for directories? */ 1021#ifdef RISCOS 1022 if (isdir(buf) && 1023 find_init_module(buf) && 1024 case_ok(buf, len, namelen, name)) 1025 return &fd_package; 1026#endif 1027#endif 1028#ifdef macintosh 1029 fdp = PyMac_FindModuleExtension(buf, &len, name); 1030 if (fdp) { 1031#else 1032#if defined(PYOS_OS2) 1033 /* take a snapshot of the module spec for restoration 1034 * after the 8 character DLL hackery 1035 */ 1036 saved_buf = strdup(buf); 1037 saved_len = len; 1038 saved_namelen = namelen; 1039#endif /* PYOS_OS2 */ 1040 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) { 1041#if defined(PYOS_OS2) 1042 /* OS/2 limits DLLs to 8 character names (w/o extension) 1043 * so if the name is longer than that and its a 1044 * dynamically loaded module we're going to try, 1045 * truncate the name before trying 1046 */ 1047 if (strlen(realname) > 8) { 1048 /* is this an attempt to load a C extension? */ 1049 const struct filedescr *scan = _PyImport_DynLoadFiletab; 1050 while (scan->suffix != NULL) { 1051 if (strcmp(scan->suffix, fdp->suffix) == 0) 1052 break; 1053 else 1054 scan++; 1055 } 1056 if (scan->suffix != NULL) { 1057 /* yes, so truncate the name */ 1058 namelen = 8; 1059 len -= strlen(realname) - namelen; 1060 buf[len] = '\0'; 1061 } 1062 } 1063#endif /* PYOS_OS2 */ 1064 strcpy(buf+len, fdp->suffix); 1065 if (Py_VerboseFlag > 1) 1066 PySys_WriteStderr("# trying %s\n", buf); 1067#endif /* !macintosh */ 1068 fp = fopen(buf, fdp->mode); 1069 if (fp != NULL) { 1070 if (case_ok(buf, len, namelen, name)) 1071 break; 1072 else { /* continue search */ 1073 fclose(fp); 1074 fp = NULL; 1075 } 1076 } 1077#if defined(PYOS_OS2) 1078 /* restore the saved snapshot */ 1079 strcpy(buf, saved_buf); 1080 len = saved_len; 1081 namelen = saved_namelen; 1082#endif 1083 } 1084#if defined(PYOS_OS2) 1085 /* don't need/want the module name snapshot anymore */ 1086 if (saved_buf) 1087 { 1088 free(saved_buf); 1089 saved_buf = NULL; 1090 } 1091#endif 1092 if (fp != NULL) 1093 break; 1094 } 1095 if (fp == NULL) { 1096 PyErr_Format(PyExc_ImportError, 1097 "No module named %.200s", name); 1098 return NULL; 1099 } 1100 *p_fp = fp; 1101 return fdp; 1102} 1103 1104/* case_ok(char* buf, int len, int namelen, char* name) 1105 * The arguments here are tricky, best shown by example: 1106 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0 1107 * ^ ^ ^ ^ 1108 * |--------------------- buf ---------------------| 1109 * |------------------- len ------------------| 1110 * |------ name -------| 1111 * |----- namelen -----| 1112 * buf is the full path, but len only counts up to (& exclusive of) the 1113 * extension. name is the module name, also exclusive of extension. 1114 * 1115 * We've already done a successful stat() or fopen() on buf, so know that 1116 * there's some match, possibly case-insensitive. 1117 * 1118 * case_ok() is to return 1 if there's a case-sensitive match for 1119 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK 1120 * exists. 1121 * 1122 * case_ok() is used to implement case-sensitive import semantics even 1123 * on platforms with case-insensitive filesystems. It's trivial to implement 1124 * for case-sensitive filesystems. It's pretty much a cross-platform 1125 * nightmare for systems with case-insensitive filesystems. 1126 */ 1127 1128/* First we may need a pile of platform-specific header files; the sequence 1129 * of #if's here should match the sequence in the body of case_ok(). 1130 */ 1131#if defined(MS_WIN32) || defined(__CYGWIN__) 1132#include <windows.h> 1133#ifdef __CYGWIN__ 1134#include <sys/cygwin.h> 1135#endif 1136 1137#elif defined(DJGPP) 1138#include <dir.h> 1139 1140#elif defined(macintosh) 1141#include <TextUtils.h> 1142 1143#elif defined(__MACH__) && defined(__APPLE__) && defined(HAVE_DIRENT_H) 1144#include <sys/types.h> 1145#include <dirent.h> 1146 1147#elif defined(PYOS_OS2) 1148#define INCL_DOS 1149#define INCL_DOSERRORS 1150#define INCL_NOPMAPI 1151#include <os2.h> 1152 1153#elif defined(RISCOS) 1154#include "oslib/osfscontrol.h" 1155#endif 1156 1157static int 1158case_ok(char *buf, int len, int namelen, char *name) 1159{ 1160/* Pick a platform-specific implementation; the sequence of #if's here should 1161 * match the sequence just above. 1162 */ 1163 1164/* MS_WIN32 || __CYGWIN__ */ 1165#if defined(MS_WIN32) || defined(__CYGWIN__) 1166 WIN32_FIND_DATA data; 1167 HANDLE h; 1168#ifdef __CYGWIN__ 1169 char tempbuf[MAX_PATH]; 1170#endif 1171 1172 if (Py_GETENV("PYTHONCASEOK") != NULL) 1173 return 1; 1174 1175#ifdef __CYGWIN__ 1176 cygwin32_conv_to_win32_path(buf, tempbuf); 1177 h = FindFirstFile(tempbuf, &data); 1178#else 1179 h = FindFirstFile(buf, &data); 1180#endif 1181 if (h == INVALID_HANDLE_VALUE) { 1182 PyErr_Format(PyExc_NameError, 1183 "Can't find file for module %.100s\n(filename %.300s)", 1184 name, buf); 1185 return 0; 1186 } 1187 FindClose(h); 1188 return strncmp(data.cFileName, name, namelen) == 0; 1189 1190/* DJGPP */ 1191#elif defined(DJGPP) 1192 struct ffblk ffblk; 1193 int done; 1194 1195 if (Py_GETENV("PYTHONCASEOK") != NULL) 1196 return 1; 1197 1198 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC); 1199 if (done) { 1200 PyErr_Format(PyExc_NameError, 1201 "Can't find file for module %.100s\n(filename %.300s)", 1202 name, buf); 1203 return 0; 1204 } 1205 return strncmp(ffblk.ff_name, name, namelen) == 0; 1206 1207/* macintosh */ 1208#elif defined(macintosh) 1209 FSSpec fss; 1210 OSErr err; 1211 1212 if (Py_GETENV("PYTHONCASEOK") != NULL) 1213 return 1; 1214 1215 err = FSMakeFSSpec(0, 0, Pstring(buf), &fss); 1216 if (err) { 1217 PyErr_Format(PyExc_NameError, 1218 "Can't find file for module %.100s\n(filename %.300s)", 1219 name, buf); 1220 return 0; 1221 } 1222 return fss.name[0] >= namelen && 1223 strncmp(name, (char *)fss.name+1, namelen) == 0; 1224 1225/* new-fangled macintosh (macosx) */ 1226#elif defined(__MACH__) && defined(__APPLE__) && defined(HAVE_DIRENT_H) 1227 DIR *dirp; 1228 struct dirent *dp; 1229 char dirname[MAXPATHLEN + 1]; 1230 const int dirlen = len - namelen - 1; /* don't want trailing SEP */ 1231 1232 if (Py_GETENV("PYTHONCASEOK") != NULL) 1233 return 1; 1234 1235 /* Copy the dir component into dirname; substitute "." if empty */ 1236 if (dirlen <= 0) { 1237 dirname[0] = '.'; 1238 dirname[1] = '\0'; 1239 } 1240 else { 1241 assert(dirlen <= MAXPATHLEN); 1242 memcpy(dirname, buf, dirlen); 1243 dirname[dirlen] = '\0'; 1244 } 1245 /* Open the directory and search the entries for an exact match. */ 1246 dirp = opendir(dirname); 1247 if (dirp) { 1248 char *nameWithExt = buf + len - namelen; 1249 while ((dp = readdir(dirp)) != NULL) { 1250 const int thislen = 1251#ifdef _DIRENT_HAVE_D_NAMELEN 1252 dp->d_namlen; 1253#else 1254 strlen(dp->d_name); 1255#endif 1256 if (thislen >= namelen && 1257 strcmp(dp->d_name, nameWithExt) == 0) { 1258 (void)closedir(dirp); 1259 return 1; /* Found */ 1260 } 1261 } 1262 (void)closedir(dirp); 1263 } 1264 return 0 ; /* Not found */ 1265 1266/* RISC OS */ 1267#elif defined(RISCOS) 1268 char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */ 1269 char buf2[MAXPATHLEN+2]; 1270 char *nameWithExt = buf+len-namelen; 1271 int canonlen; 1272 os_error *e; 1273 1274 if (Py_GETENV("PYTHONCASEOK") != NULL) 1275 return 1; 1276 1277 /* workaround: 1278 append wildcard, otherwise case of filename wouldn't be touched */ 1279 strcpy(buf2, buf); 1280 strcat(buf2, "*"); 1281 1282 e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen); 1283 canonlen = MAXPATHLEN+1-canonlen; 1284 if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) ) 1285 return 0; 1286 if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0) 1287 return 1; /* match */ 1288 1289 return 0; 1290 1291/* OS/2 */ 1292#elif defined(PYOS_OS2) 1293 HDIR hdir = 1; 1294 ULONG srchcnt = 1; 1295 FILEFINDBUF3 ffbuf; 1296 APIRET rc; 1297 1298 if (getenv("PYTHONCASEOK") != NULL) 1299 return 1; 1300 1301 rc = DosFindFirst(buf, 1302 &hdir, 1303 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY, 1304 &ffbuf, sizeof(ffbuf), 1305 &srchcnt, 1306 FIL_STANDARD); 1307 if (rc != NO_ERROR) 1308 return 0; 1309 return strncmp(ffbuf.achName, name, namelen) == 0; 1310 1311/* assuming it's a case-sensitive filesystem, so there's nothing to do! */ 1312#else 1313 return 1; 1314 1315#endif 1316} 1317 1318 1319#ifdef HAVE_STAT 1320/* Helper to look for __init__.py or __init__.py[co] in potential package */ 1321static int 1322find_init_module(char *buf) 1323{ 1324 const size_t save_len = strlen(buf); 1325 size_t i = save_len; 1326 char *pname; /* pointer to start of __init__ */ 1327 struct stat statbuf; 1328 1329/* For calling case_ok(buf, len, namelen, name): 1330 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0 1331 * ^ ^ ^ ^ 1332 * |--------------------- buf ---------------------| 1333 * |------------------- len ------------------| 1334 * |------ name -------| 1335 * |----- namelen -----| 1336 */ 1337 if (save_len + 13 >= MAXPATHLEN) 1338 return 0; 1339 buf[i++] = SEP; 1340 pname = buf + i; 1341 strcpy(pname, "__init__.py"); 1342 if (stat(buf, &statbuf) == 0) { 1343 if (case_ok(buf, 1344 save_len + 9, /* len("/__init__") */ 1345 8, /* len("__init__") */ 1346 pname)) { 1347 buf[save_len] = '\0'; 1348 return 1; 1349 } 1350 } 1351 i += strlen(pname); 1352 strcpy(buf+i, Py_OptimizeFlag ? "o" : "c"); 1353 if (stat(buf, &statbuf) == 0) { 1354 if (case_ok(buf, 1355 save_len + 9, /* len("/__init__") */ 1356 8, /* len("__init__") */ 1357 pname)) { 1358 buf[save_len] = '\0'; 1359 return 1; 1360 } 1361 } 1362 buf[save_len] = '\0'; 1363 return 0; 1364} 1365 1366#else 1367 1368#ifdef RISCOS 1369static int 1370find_init_module(buf) 1371 char *buf; 1372{ 1373 int save_len = strlen(buf); 1374 int i = save_len; 1375 1376 if (save_len + 13 >= MAXPATHLEN) 1377 return 0; 1378 buf[i++] = SEP; 1379 strcpy(buf+i, "__init__/py"); 1380 if (isfile(buf)) { 1381 buf[save_len] = '\0'; 1382 return 1; 1383 } 1384 1385 if (Py_OptimizeFlag) 1386 strcpy(buf+i, "o"); 1387 else 1388 strcpy(buf+i, "c"); 1389 if (isfile(buf)) { 1390 buf[save_len] = '\0'; 1391 return 1; 1392 } 1393 buf[save_len] = '\0'; 1394 return 0; 1395} 1396#endif /*RISCOS*/ 1397 1398#endif /* HAVE_STAT */ 1399 1400 1401static int init_builtin(char *); /* Forward */ 1402 1403/* Load an external module using the default search path and return 1404 its module object WITH INCREMENTED REFERENCE COUNT */ 1405 1406static PyObject * 1407load_module(char *name, FILE *fp, char *buf, int type) 1408{ 1409 PyObject *modules; 1410 PyObject *m; 1411 int err; 1412 1413 /* First check that there's an open file (if we need one) */ 1414 switch (type) { 1415 case PY_SOURCE: 1416 case PY_COMPILED: 1417 if (fp == NULL) { 1418 PyErr_Format(PyExc_ValueError, 1419 "file object required for import (type code %d)", 1420 type); 1421 return NULL; 1422 } 1423 } 1424 1425 switch (type) { 1426 1427 case PY_SOURCE: 1428 m = load_source_module(name, buf, fp); 1429 break; 1430 1431 case PY_COMPILED: 1432 m = load_compiled_module(name, buf, fp); 1433 break; 1434 1435#ifdef HAVE_DYNAMIC_LOADING 1436 case C_EXTENSION: 1437 m = _PyImport_LoadDynamicModule(name, buf, fp); 1438 break; 1439#endif 1440 1441#ifdef macintosh 1442 case PY_RESOURCE: 1443 m = PyMac_LoadResourceModule(name, buf); 1444 break; 1445 case PY_CODERESOURCE: 1446 m = PyMac_LoadCodeResourceModule(name, buf); 1447 break; 1448#endif 1449 1450 case PKG_DIRECTORY: 1451 m = load_package(name, buf); 1452 break; 1453 1454 case C_BUILTIN: 1455 case PY_FROZEN: 1456 if (buf != NULL && buf[0] != '\0') 1457 name = buf; 1458 if (type == C_BUILTIN) 1459 err = init_builtin(name); 1460 else 1461 err = PyImport_ImportFrozenModule(name); 1462 if (err < 0) 1463 return NULL; 1464 if (err == 0) { 1465 PyErr_Format(PyExc_ImportError, 1466 "Purported %s module %.200s not found", 1467 type == C_BUILTIN ? 1468 "builtin" : "frozen", 1469 name); 1470 return NULL; 1471 } 1472 modules = PyImport_GetModuleDict(); 1473 m = PyDict_GetItemString(modules, name); 1474 if (m == NULL) { 1475 PyErr_Format( 1476 PyExc_ImportError, 1477 "%s module %.200s not properly initialized", 1478 type == C_BUILTIN ? 1479 "builtin" : "frozen", 1480 name); 1481 return NULL; 1482 } 1483 Py_INCREF(m); 1484 break; 1485 1486 default: 1487 PyErr_Format(PyExc_ImportError, 1488 "Don't know how to import %.200s (type code %d)", 1489 name, type); 1490 m = NULL; 1491 1492 } 1493 1494 return m; 1495} 1496 1497 1498/* Initialize a built-in module. 1499 Return 1 for succes, 0 if the module is not found, and -1 with 1500 an exception set if the initialization failed. */ 1501 1502static int 1503init_builtin(char *name) 1504{ 1505 struct _inittab *p; 1506 1507 if (_PyImport_FindExtension(name, name) != NULL) 1508 return 1; 1509 1510 for (p = PyImport_Inittab; p->name != NULL; p++) { 1511 if (strcmp(name, p->name) == 0) { 1512 if (p->initfunc == NULL) { 1513 PyErr_Format(PyExc_ImportError, 1514 "Cannot re-init internal module %.200s", 1515 name); 1516 return -1; 1517 } 1518 if (Py_VerboseFlag) 1519 PySys_WriteStderr("import %s # builtin\n", name); 1520 (*p->initfunc)(); 1521 if (PyErr_Occurred()) 1522 return -1; 1523 if (_PyImport_FixupExtension(name, name) == NULL) 1524 return -1; 1525 return 1; 1526 } 1527 } 1528 return 0; 1529} 1530 1531 1532/* Frozen modules */ 1533 1534static struct _frozen * 1535find_frozen(char *name) 1536{ 1537 struct _frozen *p; 1538 1539 for (p = PyImport_FrozenModules; ; p++) { 1540 if (p->name == NULL) 1541 return NULL; 1542 if (strcmp(p->name, name) == 0) 1543 break; 1544 } 1545 return p; 1546} 1547 1548static PyObject * 1549get_frozen_object(char *name) 1550{ 1551 struct _frozen *p = find_frozen(name); 1552 int size; 1553 1554 if (p == NULL) { 1555 PyErr_Format(PyExc_ImportError, 1556 "No such frozen object named %.200s", 1557 name); 1558 return NULL; 1559 } 1560 if (p->code == NULL) { 1561 PyErr_Format(PyExc_ImportError, 1562 "Excluded frozen object named %.200s", 1563 name); 1564 return NULL; 1565 } 1566 size = p->size; 1567 if (size < 0) 1568 size = -size; 1569 return PyMarshal_ReadObjectFromString((char *)p->code, size); 1570} 1571 1572/* Initialize a frozen module. 1573 Return 1 for succes, 0 if the module is not found, and -1 with 1574 an exception set if the initialization failed. 1575 This function is also used from frozenmain.c */ 1576 1577int 1578PyImport_ImportFrozenModule(char *name) 1579{ 1580 struct _frozen *p = find_frozen(name); 1581 PyObject *co; 1582 PyObject *m; 1583 int ispackage; 1584 int size; 1585 1586 if (p == NULL) 1587 return 0; 1588 if (p->code == NULL) { 1589 PyErr_Format(PyExc_ImportError, 1590 "Excluded frozen object named %.200s", 1591 name); 1592 return -1; 1593 } 1594 size = p->size; 1595 ispackage = (size < 0); 1596 if (ispackage) 1597 size = -size; 1598 if (Py_VerboseFlag) 1599 PySys_WriteStderr("import %s # frozen%s\n", 1600 name, ispackage ? " package" : ""); 1601 co = PyMarshal_ReadObjectFromString((char *)p->code, size); 1602 if (co == NULL) 1603 return -1; 1604 if (!PyCode_Check(co)) { 1605 Py_DECREF(co); 1606 PyErr_Format(PyExc_TypeError, 1607 "frozen object %.200s is not a code object", 1608 name); 1609 return -1; 1610 } 1611 if (ispackage) { 1612 /* Set __path__ to the package name */ 1613 PyObject *d, *s; 1614 int err; 1615 m = PyImport_AddModule(name); 1616 if (m == NULL) 1617 return -1; 1618 d = PyModule_GetDict(m); 1619 s = PyString_InternFromString(name); 1620 if (s == NULL) 1621 return -1; 1622 err = PyDict_SetItemString(d, "__path__", s); 1623 Py_DECREF(s); 1624 if (err != 0) 1625 return err; 1626 } 1627 m = PyImport_ExecCodeModuleEx(name, co, "<frozen>"); 1628 Py_DECREF(co); 1629 if (m == NULL) 1630 return -1; 1631 Py_DECREF(m); 1632 return 1; 1633} 1634 1635 1636/* Import a module, either built-in, frozen, or external, and return 1637 its module object WITH INCREMENTED REFERENCE COUNT */ 1638 1639PyObject * 1640PyImport_ImportModule(char *name) 1641{ 1642 PyObject *pname; 1643 PyObject *result; 1644 1645 pname = PyString_FromString(name); 1646 result = PyImport_Import(pname); 1647 Py_DECREF(pname); 1648 return result; 1649} 1650 1651/* Forward declarations for helper routines */ 1652static PyObject *get_parent(PyObject *globals, char *buf, int *p_buflen); 1653static PyObject *load_next(PyObject *mod, PyObject *altmod, 1654 char **p_name, char *buf, int *p_buflen); 1655static int mark_miss(char *name); 1656static int ensure_fromlist(PyObject *mod, PyObject *fromlist, 1657 char *buf, int buflen, int recursive); 1658static PyObject * import_submodule(PyObject *mod, char *name, char *fullname); 1659 1660/* The Magnum Opus of dotted-name import :-) */ 1661 1662static PyObject * 1663import_module_ex(char *name, PyObject *globals, PyObject *locals, 1664 PyObject *fromlist) 1665{ 1666 char buf[MAXPATHLEN+1]; 1667 int buflen = 0; 1668 PyObject *parent, *head, *next, *tail; 1669 1670 parent = get_parent(globals, buf, &buflen); 1671 if (parent == NULL) 1672 return NULL; 1673 1674 head = load_next(parent, Py_None, &name, buf, &buflen); 1675 if (head == NULL) 1676 return NULL; 1677 1678 tail = head; 1679 Py_INCREF(tail); 1680 while (name) { 1681 next = load_next(tail, tail, &name, buf, &buflen); 1682 Py_DECREF(tail); 1683 if (next == NULL) { 1684 Py_DECREF(head); 1685 return NULL; 1686 } 1687 tail = next; 1688 } 1689 1690 if (fromlist != NULL) { 1691 if (fromlist == Py_None || !PyObject_IsTrue(fromlist)) 1692 fromlist = NULL; 1693 } 1694 1695 if (fromlist == NULL) { 1696 Py_DECREF(tail); 1697 return head; 1698 } 1699 1700 Py_DECREF(head); 1701 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) { 1702 Py_DECREF(tail); 1703 return NULL; 1704 } 1705 1706 return tail; 1707} 1708 1709PyObject * 1710PyImport_ImportModuleEx(char *name, PyObject *globals, PyObject *locals, 1711 PyObject *fromlist) 1712{ 1713 PyObject *result; 1714 lock_import(); 1715 result = import_module_ex(name, globals, locals, fromlist); 1716 unlock_import(); 1717 return result; 1718} 1719 1720static PyObject * 1721get_parent(PyObject *globals, char *buf, int *p_buflen) 1722{ 1723 static PyObject *namestr = NULL; 1724 static PyObject *pathstr = NULL; 1725 PyObject *modname, *modpath, *modules, *parent; 1726 1727 if (globals == NULL || !PyDict_Check(globals)) 1728 return Py_None; 1729 1730 if (namestr == NULL) { 1731 namestr = PyString_InternFromString("__name__"); 1732 if (namestr == NULL) 1733 return NULL; 1734 } 1735 if (pathstr == NULL) { 1736 pathstr = PyString_InternFromString("__path__"); 1737 if (pathstr == NULL) 1738 return NULL; 1739 } 1740 1741 *buf = '\0'; 1742 *p_buflen = 0; 1743 modname = PyDict_GetItem(globals, namestr); 1744 if (modname == NULL || !PyString_Check(modname)) 1745 return Py_None; 1746 1747 modpath = PyDict_GetItem(globals, pathstr); 1748 if (modpath != NULL) { 1749 int len = PyString_GET_SIZE(modname); 1750 if (len > MAXPATHLEN) { 1751 PyErr_SetString(PyExc_ValueError, 1752 "Module name too long"); 1753 return NULL; 1754 } 1755 strcpy(buf, PyString_AS_STRING(modname)); 1756 *p_buflen = len; 1757 } 1758 else { 1759 char *start = PyString_AS_STRING(modname); 1760 char *lastdot = strrchr(start, '.'); 1761 size_t len; 1762 if (lastdot == NULL) 1763 return Py_None; 1764 len = lastdot - start; 1765 if (len >= MAXPATHLEN) { 1766 PyErr_SetString(PyExc_ValueError, 1767 "Module name too long"); 1768 return NULL; 1769 } 1770 strncpy(buf, start, len); 1771 buf[len] = '\0'; 1772 *p_buflen = len; 1773 } 1774 1775 modules = PyImport_GetModuleDict(); 1776 parent = PyDict_GetItemString(modules, buf); 1777 if (parent == NULL) 1778 parent = Py_None; 1779 return parent; 1780 /* We expect, but can't guarantee, if parent != None, that: 1781 - parent.__name__ == buf 1782 - parent.__dict__ is globals 1783 If this is violated... Who cares? */ 1784} 1785 1786/* altmod is either None or same as mod */ 1787static PyObject * 1788load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf, 1789 int *p_buflen) 1790{ 1791 char *name = *p_name; 1792 char *dot = strchr(name, '.'); 1793 size_t len; 1794 char *p; 1795 PyObject *result; 1796 1797 if (dot == NULL) { 1798 *p_name = NULL; 1799 len = strlen(name); 1800 } 1801 else { 1802 *p_name = dot+1; 1803 len = dot-name; 1804 } 1805 if (len == 0) { 1806 PyErr_SetString(PyExc_ValueError, 1807 "Empty module name"); 1808 return NULL; 1809 } 1810 1811 p = buf + *p_buflen; 1812 if (p != buf) 1813 *p++ = '.'; 1814 if (p+len-buf >= MAXPATHLEN) { 1815 PyErr_SetString(PyExc_ValueError, 1816 "Module name too long"); 1817 return NULL; 1818 } 1819 strncpy(p, name, len); 1820 p[len] = '\0'; 1821 *p_buflen = p+len-buf; 1822 1823 result = import_submodule(mod, p, buf); 1824 if (result == Py_None && altmod != mod) { 1825 Py_DECREF(result); 1826 /* Here, altmod must be None and mod must not be None */ 1827 result = import_submodule(altmod, p, p); 1828 if (result != NULL && result != Py_None) { 1829 if (mark_miss(buf) != 0) { 1830 Py_DECREF(result); 1831 return NULL; 1832 } 1833 strncpy(buf, name, len); 1834 buf[len] = '\0'; 1835 *p_buflen = len; 1836 } 1837 } 1838 if (result == NULL) 1839 return NULL; 1840 1841 if (result == Py_None) { 1842 Py_DECREF(result); 1843 PyErr_Format(PyExc_ImportError, 1844 "No module named %.200s", name); 1845 return NULL; 1846 } 1847 1848 return result; 1849} 1850 1851static int 1852mark_miss(char *name) 1853{ 1854 PyObject *modules = PyImport_GetModuleDict(); 1855 return PyDict_SetItemString(modules, name, Py_None); 1856} 1857 1858static int 1859ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, int buflen, 1860 int recursive) 1861{ 1862 int i; 1863 1864 if (!PyObject_HasAttrString(mod, "__path__")) 1865 return 1; 1866 1867 for (i = 0; ; i++) { 1868 PyObject *item = PySequence_GetItem(fromlist, i); 1869 int hasit; 1870 if (item == NULL) { 1871 if (PyErr_ExceptionMatches(PyExc_IndexError)) { 1872 PyErr_Clear(); 1873 return 1; 1874 } 1875 return 0; 1876 } 1877 if (!PyString_Check(item)) { 1878 PyErr_SetString(PyExc_TypeError, 1879 "Item in ``from list'' not a string"); 1880 Py_DECREF(item); 1881 return 0; 1882 } 1883 if (PyString_AS_STRING(item)[0] == '*') { 1884 PyObject *all; 1885 Py_DECREF(item); 1886 /* See if the package defines __all__ */ 1887 if (recursive) 1888 continue; /* Avoid endless recursion */ 1889 all = PyObject_GetAttrString(mod, "__all__"); 1890 if (all == NULL) 1891 PyErr_Clear(); 1892 else { 1893 if (!ensure_fromlist(mod, all, buf, buflen, 1)) 1894 return 0; 1895 Py_DECREF(all); 1896 } 1897 continue; 1898 } 1899 hasit = PyObject_HasAttr(mod, item); 1900 if (!hasit) { 1901 char *subname = PyString_AS_STRING(item); 1902 PyObject *submod; 1903 char *p; 1904 if (buflen + strlen(subname) >= MAXPATHLEN) { 1905 PyErr_SetString(PyExc_ValueError, 1906 "Module name too long"); 1907 Py_DECREF(item); 1908 return 0; 1909 } 1910 p = buf + buflen; 1911 *p++ = '.'; 1912 strcpy(p, subname); 1913 submod = import_submodule(mod, subname, buf); 1914 Py_XDECREF(submod); 1915 if (submod == NULL) { 1916 Py_DECREF(item); 1917 return 0; 1918 } 1919 } 1920 Py_DECREF(item); 1921 } 1922 1923 /* NOTREACHED */ 1924} 1925 1926static PyObject * 1927import_submodule(PyObject *mod, char *subname, char *fullname) 1928{ 1929 PyObject *modules = PyImport_GetModuleDict(); 1930 PyObject *m, *res = NULL; 1931 1932 /* Require: 1933 if mod == None: subname == fullname 1934 else: mod.__name__ + "." + subname == fullname 1935 */ 1936 1937 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) { 1938 Py_INCREF(m); 1939 } 1940 else { 1941 PyObject *path; 1942 char buf[MAXPATHLEN+1]; 1943 struct filedescr *fdp; 1944 FILE *fp = NULL; 1945 1946 if (mod == Py_None) 1947 path = NULL; 1948 else { 1949 path = PyObject_GetAttrString(mod, "__path__"); 1950 if (path == NULL) { 1951 PyErr_Clear(); 1952 Py_INCREF(Py_None); 1953 return Py_None; 1954 } 1955 } 1956 1957 buf[0] = '\0'; 1958 fdp = find_module(subname, path, buf, MAXPATHLEN+1, &fp); 1959 Py_XDECREF(path); 1960 if (fdp == NULL) { 1961 if (!PyErr_ExceptionMatches(PyExc_ImportError)) 1962 return NULL; 1963 PyErr_Clear(); 1964 Py_INCREF(Py_None); 1965 return Py_None; 1966 } 1967 m = load_module(fullname, fp, buf, fdp->type); 1968 if (fp) 1969 fclose(fp); 1970 if (mod != Py_None) { 1971 /* Irrespective of the success of this load, make a 1972 reference to it in the parent package module. 1973 A copy gets saved in the modules dictionary 1974 under the full name, so get a reference from 1975 there, if need be. (The exception is when 1976 the load failed with a SyntaxError -- then 1977 there's no trace in sys.modules. In that case, 1978 of course, do nothing extra.) */ 1979 res = m; 1980 if (res == NULL) 1981 res = PyDict_GetItemString(modules, fullname); 1982 if (res != NULL && 1983 PyObject_SetAttrString(mod, subname, res) < 0) { 1984 Py_XDECREF(m); 1985 m = NULL; 1986 } 1987 } 1988 } 1989 1990 return m; 1991} 1992 1993 1994/* Re-import a module of any kind and return its module object, WITH 1995 INCREMENTED REFERENCE COUNT */ 1996 1997PyObject * 1998PyImport_ReloadModule(PyObject *m) 1999{ 2000 PyObject *modules = PyImport_GetModuleDict(); 2001 PyObject *path = NULL; 2002 char *name, *subname; 2003 char buf[MAXPATHLEN+1]; 2004 struct filedescr *fdp; 2005 FILE *fp = NULL; 2006 2007 if (m == NULL || !PyModule_Check(m)) { 2008 PyErr_SetString(PyExc_TypeError, 2009 "reload() argument must be module"); 2010 return NULL; 2011 } 2012 name = PyModule_GetName(m); 2013 if (name == NULL) 2014 return NULL; 2015 if (m != PyDict_GetItemString(modules, name)) { 2016 PyErr_Format(PyExc_ImportError, 2017 "reload(): module %.200s not in sys.modules", 2018 name); 2019 return NULL; 2020 } 2021 subname = strrchr(name, '.'); 2022 if (subname == NULL) 2023 subname = name; 2024 else { 2025 PyObject *parentname, *parent; 2026 parentname = PyString_FromStringAndSize(name, (subname-name)); 2027 if (parentname == NULL) 2028 return NULL; 2029 parent = PyDict_GetItem(modules, parentname); 2030 Py_DECREF(parentname); 2031 if (parent == NULL) { 2032 PyErr_Format(PyExc_ImportError, 2033 "reload(): parent %.200s not in sys.modules", 2034 name); 2035 return NULL; 2036 } 2037 subname++; 2038 path = PyObject_GetAttrString(parent, "__path__"); 2039 if (path == NULL) 2040 PyErr_Clear(); 2041 } 2042 buf[0] = '\0'; 2043 fdp = find_module(subname, path, buf, MAXPATHLEN+1, &fp); 2044 Py_XDECREF(path); 2045 if (fdp == NULL) 2046 return NULL; 2047 m = load_module(name, fp, buf, fdp->type); 2048 if (fp) 2049 fclose(fp); 2050 return m; 2051} 2052 2053 2054/* Higher-level import emulator which emulates the "import" statement 2055 more accurately -- it invokes the __import__() function from the 2056 builtins of the current globals. This means that the import is 2057 done using whatever import hooks are installed in the current 2058 environment, e.g. by "rexec". 2059 A dummy list ["__doc__"] is passed as the 4th argument so that 2060 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache")) 2061 will return <module "gencache"> instead of <module "win32com">. */ 2062 2063PyObject * 2064PyImport_Import(PyObject *module_name) 2065{ 2066 static PyObject *silly_list = NULL; 2067 static PyObject *builtins_str = NULL; 2068 static PyObject *import_str = NULL; 2069 PyObject *globals = NULL; 2070 PyObject *import = NULL; 2071 PyObject *builtins = NULL; 2072 PyObject *r = NULL; 2073 2074 /* Initialize constant string objects */ 2075 if (silly_list == NULL) { 2076 import_str = PyString_InternFromString("__import__"); 2077 if (import_str == NULL) 2078 return NULL; 2079 builtins_str = PyString_InternFromString("__builtins__"); 2080 if (builtins_str == NULL) 2081 return NULL; 2082 silly_list = Py_BuildValue("[s]", "__doc__"); 2083 if (silly_list == NULL) 2084 return NULL; 2085 } 2086 2087 /* Get the builtins from current globals */ 2088 globals = PyEval_GetGlobals(); 2089 if (globals != NULL) { 2090 Py_INCREF(globals); 2091 builtins = PyObject_GetItem(globals, builtins_str); 2092 if (builtins == NULL) 2093 goto err; 2094 } 2095 else { 2096 /* No globals -- use standard builtins, and fake globals */ 2097 PyErr_Clear(); 2098 2099 builtins = PyImport_ImportModuleEx("__builtin__", 2100 NULL, NULL, NULL); 2101 if (builtins == NULL) 2102 return NULL; 2103 globals = Py_BuildValue("{OO}", builtins_str, builtins); 2104 if (globals == NULL) 2105 goto err; 2106 } 2107 2108 /* Get the __import__ function from the builtins */ 2109 if (PyDict_Check(builtins)) { 2110 import = PyObject_GetItem(builtins, import_str); 2111 if (import == NULL) 2112 PyErr_SetObject(PyExc_KeyError, import_str); 2113 } 2114 else 2115 import = PyObject_GetAttr(builtins, import_str); 2116 if (import == NULL) 2117 goto err; 2118 2119 /* Call the _import__ function with the proper argument list */ 2120 r = PyObject_CallFunction(import, "OOOO", 2121 module_name, globals, globals, silly_list); 2122 2123 err: 2124 Py_XDECREF(globals); 2125 Py_XDECREF(builtins); 2126 Py_XDECREF(import); 2127 2128 return r; 2129} 2130 2131 2132/* Module 'imp' provides Python access to the primitives used for 2133 importing modules. 2134*/ 2135 2136static PyObject * 2137imp_get_magic(PyObject *self, PyObject *args) 2138{ 2139 char buf[4]; 2140 2141 if (!PyArg_ParseTuple(args, ":get_magic")) 2142 return NULL; 2143 buf[0] = (char) ((pyc_magic >> 0) & 0xff); 2144 buf[1] = (char) ((pyc_magic >> 8) & 0xff); 2145 buf[2] = (char) ((pyc_magic >> 16) & 0xff); 2146 buf[3] = (char) ((pyc_magic >> 24) & 0xff); 2147 2148 return PyString_FromStringAndSize(buf, 4); 2149} 2150 2151static PyObject * 2152imp_get_suffixes(PyObject *self, PyObject *args) 2153{ 2154 PyObject *list; 2155 struct filedescr *fdp; 2156 2157 if (!PyArg_ParseTuple(args, ":get_suffixes")) 2158 return NULL; 2159 list = PyList_New(0); 2160 if (list == NULL) 2161 return NULL; 2162 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) { 2163 PyObject *item = Py_BuildValue("ssi", 2164 fdp->suffix, fdp->mode, fdp->type); 2165 if (item == NULL) { 2166 Py_DECREF(list); 2167 return NULL; 2168 } 2169 if (PyList_Append(list, item) < 0) { 2170 Py_DECREF(list); 2171 Py_DECREF(item); 2172 return NULL; 2173 } 2174 Py_DECREF(item); 2175 } 2176 return list; 2177} 2178 2179static PyObject * 2180call_find_module(char *name, PyObject *path) 2181{ 2182 extern int fclose(FILE *); 2183 PyObject *fob, *ret; 2184 struct filedescr *fdp; 2185 char pathname[MAXPATHLEN+1]; 2186 FILE *fp = NULL; 2187 2188 pathname[0] = '\0'; 2189 if (path == Py_None) 2190 path = NULL; 2191 fdp = find_module(name, path, pathname, MAXPATHLEN+1, &fp); 2192 if (fdp == NULL) 2193 return NULL; 2194 if (fp != NULL) { 2195 fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose); 2196 if (fob == NULL) { 2197 fclose(fp); 2198 return NULL; 2199 } 2200 } 2201 else { 2202 fob = Py_None; 2203 Py_INCREF(fob); 2204 } 2205 ret = Py_BuildValue("Os(ssi)", 2206 fob, pathname, fdp->suffix, fdp->mode, fdp->type); 2207 Py_DECREF(fob); 2208 return ret; 2209} 2210 2211static PyObject * 2212imp_find_module(PyObject *self, PyObject *args) 2213{ 2214 char *name; 2215 PyObject *path = NULL; 2216 if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path)) 2217 return NULL; 2218 return call_find_module(name, path); 2219} 2220 2221static PyObject * 2222imp_init_builtin(PyObject *self, PyObject *args) 2223{ 2224 char *name; 2225 int ret; 2226 PyObject *m; 2227 if (!PyArg_ParseTuple(args, "s:init_builtin", &name)) 2228 return NULL; 2229 ret = init_builtin(name); 2230 if (ret < 0) 2231 return NULL; 2232 if (ret == 0) { 2233 Py_INCREF(Py_None); 2234 return Py_None; 2235 } 2236 m = PyImport_AddModule(name); 2237 Py_XINCREF(m); 2238 return m; 2239} 2240 2241static PyObject * 2242imp_init_frozen(PyObject *self, PyObject *args) 2243{ 2244 char *name; 2245 int ret; 2246 PyObject *m; 2247 if (!PyArg_ParseTuple(args, "s:init_frozen", &name)) 2248 return NULL; 2249 ret = PyImport_ImportFrozenModule(name); 2250 if (ret < 0) 2251 return NULL; 2252 if (ret == 0) { 2253 Py_INCREF(Py_None); 2254 return Py_None; 2255 } 2256 m = PyImport_AddModule(name); 2257 Py_XINCREF(m); 2258 return m; 2259} 2260 2261static PyObject * 2262imp_get_frozen_object(PyObject *self, PyObject *args) 2263{ 2264 char *name; 2265 2266 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name)) 2267 return NULL; 2268 return get_frozen_object(name); 2269} 2270 2271static PyObject * 2272imp_is_builtin(PyObject *self, PyObject *args) 2273{ 2274 char *name; 2275 if (!PyArg_ParseTuple(args, "s:is_builtin", &name)) 2276 return NULL; 2277 return PyInt_FromLong(is_builtin(name)); 2278} 2279 2280static PyObject * 2281imp_is_frozen(PyObject *self, PyObject *args) 2282{ 2283 char *name; 2284 struct _frozen *p; 2285 if (!PyArg_ParseTuple(args, "s:is_frozen", &name)) 2286 return NULL; 2287 p = find_frozen(name); 2288 return PyBool_FromLong((long) (p == NULL ? 0 : p->size)); 2289} 2290 2291static FILE * 2292get_file(char *pathname, PyObject *fob, char *mode) 2293{ 2294 FILE *fp; 2295 if (fob == NULL) { 2296 fp = fopen(pathname, mode); 2297 if (fp == NULL) 2298 PyErr_SetFromErrno(PyExc_IOError); 2299 } 2300 else { 2301 fp = PyFile_AsFile(fob); 2302 if (fp == NULL) 2303 PyErr_SetString(PyExc_ValueError, 2304 "bad/closed file object"); 2305 } 2306 return fp; 2307} 2308 2309static PyObject * 2310imp_load_compiled(PyObject *self, PyObject *args) 2311{ 2312 char *name; 2313 char *pathname; 2314 PyObject *fob = NULL; 2315 PyObject *m; 2316 FILE *fp; 2317 if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname, 2318 &PyFile_Type, &fob)) 2319 return NULL; 2320 fp = get_file(pathname, fob, "rb"); 2321 if (fp == NULL) 2322 return NULL; 2323 m = load_compiled_module(name, pathname, fp); 2324 if (fob == NULL) 2325 fclose(fp); 2326 return m; 2327} 2328 2329#ifdef HAVE_DYNAMIC_LOADING 2330 2331static PyObject * 2332imp_load_dynamic(PyObject *self, PyObject *args) 2333{ 2334 char *name; 2335 char *pathname; 2336 PyObject *fob = NULL; 2337 PyObject *m; 2338 FILE *fp = NULL; 2339 if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname, 2340 &PyFile_Type, &fob)) 2341 return NULL; 2342 if (fob) { 2343 fp = get_file(pathname, fob, "r"); 2344 if (fp == NULL) 2345 return NULL; 2346 } 2347 m = _PyImport_LoadDynamicModule(name, pathname, fp); 2348 return m; 2349} 2350 2351#endif /* HAVE_DYNAMIC_LOADING */ 2352 2353static PyObject * 2354imp_load_source(PyObject *self, PyObject *args) 2355{ 2356 char *name; 2357 char *pathname; 2358 PyObject *fob = NULL; 2359 PyObject *m; 2360 FILE *fp; 2361 if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname, 2362 &PyFile_Type, &fob)) 2363 return NULL; 2364 fp = get_file(pathname, fob, "r"); 2365 if (fp == NULL) 2366 return NULL; 2367 m = load_source_module(name, pathname, fp); 2368 if (fob == NULL) 2369 fclose(fp); 2370 return m; 2371} 2372 2373#ifdef macintosh 2374static PyObject * 2375imp_load_resource(PyObject *self, PyObject *args) 2376{ 2377 char *name; 2378 char *pathname; 2379 PyObject *m; 2380 2381 if (!PyArg_ParseTuple(args, "ss:load_resource", &name, &pathname)) 2382 return NULL; 2383 m = PyMac_LoadResourceModule(name, pathname); 2384 return m; 2385} 2386#endif /* macintosh */ 2387 2388static PyObject * 2389imp_load_module(PyObject *self, PyObject *args) 2390{ 2391 char *name; 2392 PyObject *fob; 2393 char *pathname; 2394 char *suffix; /* Unused */ 2395 char *mode; 2396 int type; 2397 FILE *fp; 2398 2399 if (!PyArg_ParseTuple(args, "sOs(ssi):load_module", 2400 &name, &fob, &pathname, 2401 &suffix, &mode, &type)) 2402 return NULL; 2403 if (*mode && (*mode != 'r' || strchr(mode, '+') != NULL)) { 2404 PyErr_Format(PyExc_ValueError, 2405 "invalid file open mode %.200s", mode); 2406 return NULL; 2407 } 2408 if (fob == Py_None) 2409 fp = NULL; 2410 else { 2411 if (!PyFile_Check(fob)) { 2412 PyErr_SetString(PyExc_ValueError, 2413 "load_module arg#2 should be a file or None"); 2414 return NULL; 2415 } 2416 fp = get_file(pathname, fob, mode); 2417 if (fp == NULL) 2418 return NULL; 2419 } 2420 return load_module(name, fp, pathname, type); 2421} 2422 2423static PyObject * 2424imp_load_package(PyObject *self, PyObject *args) 2425{ 2426 char *name; 2427 char *pathname; 2428 if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname)) 2429 return NULL; 2430 return load_package(name, pathname); 2431} 2432 2433static PyObject * 2434imp_new_module(PyObject *self, PyObject *args) 2435{ 2436 char *name; 2437 if (!PyArg_ParseTuple(args, "s:new_module", &name)) 2438 return NULL; 2439 return PyModule_New(name); 2440} 2441 2442/* Doc strings */ 2443 2444static char doc_imp[] = "\ 2445This module provides the components needed to build your own\n\ 2446__import__ function. Undocumented functions are obsolete.\n\ 2447"; 2448 2449static char doc_find_module[] = "\ 2450find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\ 2451Search for a module. If path is omitted or None, search for a\n\ 2452built-in, frozen or special module and continue search in sys.path.\n\ 2453The module name cannot contain '.'; to search for a submodule of a\n\ 2454package, pass the submodule name and the package's __path__.\ 2455"; 2456 2457static char doc_load_module[] = "\ 2458load_module(name, file, filename, (suffix, mode, type)) -> module\n\ 2459Load a module, given information returned by find_module().\n\ 2460The module name must include the full package name, if any.\ 2461"; 2462 2463static char doc_get_magic[] = "\ 2464get_magic() -> string\n\ 2465Return the magic number for .pyc or .pyo files.\ 2466"; 2467 2468static char doc_get_suffixes[] = "\ 2469get_suffixes() -> [(suffix, mode, type), ...]\n\ 2470Return a list of (suffix, mode, type) tuples describing the files\n\ 2471that find_module() looks for.\ 2472"; 2473 2474static char doc_new_module[] = "\ 2475new_module(name) -> module\n\ 2476Create a new module. Do not enter it in sys.modules.\n\ 2477The module name must include the full package name, if any.\ 2478"; 2479 2480static char doc_lock_held[] = "\ 2481lock_held() -> 0 or 1\n\ 2482Return 1 if the import lock is currently held.\n\ 2483On platforms without threads, return 0.\ 2484"; 2485 2486static PyMethodDef imp_methods[] = { 2487 {"find_module", imp_find_module, METH_VARARGS, doc_find_module}, 2488 {"get_magic", imp_get_magic, METH_VARARGS, doc_get_magic}, 2489 {"get_suffixes", imp_get_suffixes, METH_VARARGS, doc_get_suffixes}, 2490 {"load_module", imp_load_module, METH_VARARGS, doc_load_module}, 2491 {"new_module", imp_new_module, METH_VARARGS, doc_new_module}, 2492 {"lock_held", imp_lock_held, METH_VARARGS, doc_lock_held}, 2493 /* The rest are obsolete */ 2494 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS}, 2495 {"init_builtin", imp_init_builtin, METH_VARARGS}, 2496 {"init_frozen", imp_init_frozen, METH_VARARGS}, 2497 {"is_builtin", imp_is_builtin, METH_VARARGS}, 2498 {"is_frozen", imp_is_frozen, METH_VARARGS}, 2499 {"load_compiled", imp_load_compiled, METH_VARARGS}, 2500#ifdef HAVE_DYNAMIC_LOADING 2501 {"load_dynamic", imp_load_dynamic, METH_VARARGS}, 2502#endif 2503 {"load_package", imp_load_package, METH_VARARGS}, 2504#ifdef macintosh 2505 {"load_resource", imp_load_resource, METH_VARARGS}, 2506#endif 2507 {"load_source", imp_load_source, METH_VARARGS}, 2508 {NULL, NULL} /* sentinel */ 2509}; 2510 2511static int 2512setint(PyObject *d, char *name, int value) 2513{ 2514 PyObject *v; 2515 int err; 2516 2517 v = PyInt_FromLong((long)value); 2518 err = PyDict_SetItemString(d, name, v); 2519 Py_XDECREF(v); 2520 return err; 2521} 2522 2523void 2524initimp(void) 2525{ 2526 PyObject *m, *d; 2527 2528 m = Py_InitModule4("imp", imp_methods, doc_imp, 2529 NULL, PYTHON_API_VERSION); 2530 d = PyModule_GetDict(m); 2531 2532 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure; 2533 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure; 2534 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure; 2535 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure; 2536 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure; 2537 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure; 2538 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure; 2539 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure; 2540 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure; 2541 2542 failure: 2543 ; 2544} 2545 2546 2547/* API for embedding applications that want to add their own entries 2548 to the table of built-in modules. This should normally be called 2549 *before* Py_Initialize(). When the table resize fails, -1 is 2550 returned and the existing table is unchanged. 2551 2552 After a similar function by Just van Rossum. */ 2553 2554int 2555PyImport_ExtendInittab(struct _inittab *newtab) 2556{ 2557 static struct _inittab *our_copy = NULL; 2558 struct _inittab *p; 2559 int i, n; 2560 2561 /* Count the number of entries in both tables */ 2562 for (n = 0; newtab[n].name != NULL; n++) 2563 ; 2564 if (n == 0) 2565 return 0; /* Nothing to do */ 2566 for (i = 0; PyImport_Inittab[i].name != NULL; i++) 2567 ; 2568 2569 /* Allocate new memory for the combined table */ 2570 p = our_copy; 2571 PyMem_RESIZE(p, struct _inittab, i+n+1); 2572 if (p == NULL) 2573 return -1; 2574 2575 /* Copy the tables into the new memory */ 2576 if (our_copy != PyImport_Inittab) 2577 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab)); 2578 PyImport_Inittab = our_copy = p; 2579 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab)); 2580 2581 return 0; 2582} 2583 2584/* Shorthand to add a single entry given a name and a function */ 2585 2586int 2587PyImport_AppendInittab(char *name, void (*initfunc)(void)) 2588{ 2589 struct _inittab newtab[2]; 2590 2591 memset(newtab, '\0', sizeof newtab); 2592 2593 newtab[0].name = name; 2594 newtab[0].initfunc = initfunc; 2595 2596 return PyImport_ExtendInittab(newtab); 2597} 2598