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