Bug Summary

File:Python/import.c
Location:line 896, column 9
Description:Value stored to 'i' is never read

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