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