Python/import.c

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