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