### 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
18 | extern "C" {
19 | #endif
20 |
21 | #ifdef MS_WINDOWS
22 | /* for stat.st_mode */
23 | typedef 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. */
117 | static long pyc_magic = MAGIC(3180 | ((long)'\r'<<16) | ((long)'\n'<<24));
118 | static const char *pyc_tag = TAG"cpython-32";
119 |
120 | /* See _PyImport_FixupExtensionUnicode() below */
121 | static PyObject *extensions = NULL((void *)0);
122 |
123 | /* This table is defined in config.c: */
124 | extern struct _inittab _PyImport_Inittab[];
125 |
126 | /* Method from Parser/tokenizer.c */
127 | extern char * PyTokenizer_FindEncoding(int);
128 |
129 | struct _inittab *PyImport_Inittab = _PyImport_Inittab;
130 |
131 | /* these tables define the module suffixes that Python recognizes */
132 | struct filedescr * _PyImport_Filetab = NULL((void *)0);
133 |
134 | static 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 |
146 | void
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 |
185 | void
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 |
255 | void
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 |
273 | static PyThread_type_lock import_lock = 0;
274 | static long import_lock_thread = -1;
275 | static int import_lock_level = 0;
276 |
277 | void
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 |
302 | int
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 |
323 | void
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 |
343 | static PyObject *
344 | imp_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 |
353 | static PyObject *
354 | imp_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 |
363 | static PyObject *
364 | imp_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 |
377 | static void
378 | imp_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 |
387 | PyObject *
388 | PyImport_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 */
398 | static 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 |
407 | static 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 |
417 | void
418 | PyImport_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 |
551 | long
552 | PyImport_GetMagicNumber(void)
553 | {
554 | return pyc_magic;
555 | }
556 |
557 |
558 | const char *
559 | PyImport_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 |
580 | int
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 |
625 | int
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 |
638 | PyObject *
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 |
682 | PyObject *
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 |
700 | PyObject *
701 | PyImport_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. */
722 | static void
723 | remove_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 |
733 | static PyObject * get_sourcefile(char *file);
734 | static char *make_source_pathname(char *pathname, char *buf);
735 | static 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 | */
748 | PyObject *
749 | PyImport_ExecCodeModule(char *name, PyObject *co)
750 | {
751 | return PyImport_ExecCodeModuleWithPathnames(
752 | name, co, (char *)NULL((void *)0), (char *)NULL((void *)0));
753 | }
754 |
755 | PyObject *
756 | PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
757 | {
758 | return PyImport_ExecCodeModuleWithPathnames(
759 | name, co, pathname, (char *)NULL((void *)0));
760 | }
761 |
762 | PyObject *
763 | PyImport_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 | */
834 | static char *
835 | rightmost_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 |
857 | static char *
858 | make_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 |
967 | static char *
968 | make_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 |
1021 | static FILE *
1022 | check_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 |
1053 | static PyCodeObject *
1054 | read_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 |
1074 | static PyObject *
1075 | load_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 |
1103 | static PyCodeObject *
1104 | parse_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 |
1127 | static FILE *
1128 | open_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 |
1164 | static void
1165 | write_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 |
1234 | static void
1235 | update_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 |
1258 | static int
1259 | update_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 |
1284 | static PyObject *
1285 | load_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 | */
1349 | static PyObject *
1350 | get_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 */
1387 | static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
1388 | static struct filedescr *find_module(char *, char *, PyObject *,
1389 | char *, size_t, FILE **, PyObject **);
1390 | static struct _frozen * find_frozen(char *);
1391 |
1392 | /* Load a package and return its module object WITH INCREMENTED
1393 | REFERENCE COUNT */
1394 |
1395 | static PyObject *
1396 | load_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 |
1451 | static int
1452 | is_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 |
1475 | static PyObject *
1476 | get_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 |
1531 | PyAPI_FUNC(PyObject *)PyObject *
1532 | PyImport_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
1550 | extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
1551 | char *, Py_ssize_t);
1552 | #endif
1553 |
1554 | static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
1555 | static int find_init_module(char *); /* Forward */
1556 | static struct filedescr importhookdescr = {"", "", IMP_HOOK};
1557 |
1558 | static struct filedescr *
1559 | find_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 |
1877 | static int
1878 | case_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 */
1990 | static int
1991 | find_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 |
2038 | static int init_builtin(char *); /* Forward */
2039 |
2040 | static PyObject*
2041 | load_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 |
2082 | static PyObject *
2083 | load_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 |
2150 | static int
2151 | init_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 |
2186 | static struct _frozen *
2187 | find_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 |
2203 | static PyObject *
2204 | get_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 |
2227 | static PyObject *
2228 | is_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 |
2254 | int
2255 | PyImport_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;
2315 | err_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 |
2324 | PyObject *
2325 | PyImport_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 | */
2347 | PyObject *
2348 | PyImport_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 */
2389 | static PyObject *get_parent(PyObject *globals, char *buf,
2390 | Py_ssize_t *p_buflen, int level);
2391 | static PyObject *load_next(PyObject *mod, PyObject *altmod,
2392 | char **p_name, char *buf, Py_ssize_t *p_buflen);
2393 | static int mark_miss(char *name);
2394 | static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
2395 | char *buf, Py_ssize_t buflen, int recursive);
2396 | static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
2397 |
2398 | /* The Magnum Opus of dotted-name import :-) */
2399 |
2400 | static PyObject *
2401 | import_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 |
2468 | PyObject *
2469 | PyImport_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 | */
2495 | static PyObject *
2496 | get_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 */
2662 | static PyObject *
2663 | load_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 |
2734 | static int
2735 | mark_miss(char *name)
2736 | {
2737 | PyObject *modules = PyImport_GetModuleDict();
2738 | return PyDict_SetItemString(modules, name, Py_None(&_Py_NoneStruct));
2739 | }
2740 |
2741 | static int
2742 | ensure_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 |
2818 | static int
2819 | add_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 |
2852 | static PyObject *
2853 | import_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 |
2911 | PyObject *
2912 | PyImport_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 |
3016 | PyObject *
3017 | PyImport_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 |
3098 | static PyObject *
3099 | imp_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 |
3111 | static PyObject *
3112 | imp_get_magic(PyObject *self, PyObject *noargs)
3113 | {
3114 | return imp_make_magic(pyc_magic);
3115 | }
3116 |
3117 | static PyObject *
3118 | imp_get_tag(PyObject *self, PyObject *noargs)
3119 | {
3120 | return PyUnicode_FromStringPyUnicodeUCS2_FromString(pyc_tag);
3121 | }
3122 |
3123 | static PyObject *
3124 | imp_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 |
3149 | static PyObject *
3150 | call_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 |
3206 | static PyObject *
3207 | imp_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 |
3220 | static PyObject *
3221 | imp_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 |
3240 | static PyObject *
3241 | imp_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 |
3260 | static PyObject *
3261 | imp_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 |
3270 | static PyObject *
3271 | imp_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 |
3280 | static PyObject *
3281 | imp_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 |
3289 | static PyObject *
3290 | imp_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 |
3300 | static FILE *
3301 | get_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;
3325 | error:
3326 | PyErr_SetFromErrno(PyExc_IOError);
3327 | return NULL((void *)0);
3328 | }
3329 |
3330 | static PyObject *
3331 | imp_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 |
3356 | static PyObject *
3357 | imp_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 |
3385 | static PyObject *
3386 | imp_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 |
3409 | static PyObject *
3410 | imp_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 |
3454 | static PyObject *
3455 | imp_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 |
3468 | static PyObject *
3469 | imp_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 |
3477 | static PyObject *
3478 | imp_reload(PyObject *self, PyObject *v)
3479 | {
3480 | return PyImport_ReloadModule(v);
3481 | }
3482 |
3483 | PyDoc_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."
3486 | Reload 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 |
3488 | static PyObject *
3489 | imp_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 |
3522 | PyDoc_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."
3525 | The .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."
3527 | will 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."
3529 | If 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."
3530 | the 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 |
3532 | static PyObject *
3533 | imp_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 |
3557 | PyDoc_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."
3560 | The .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."
3561 | the .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."
3562 | does 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 |
3566 | PyDoc_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 |
3570 | PyDoc_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__."
3572 | Search 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__."
3573 | built-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__."
3574 | The 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__."
3575 | package, 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 |
3577 | PyDoc_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."
3579 | Load 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."
3580 | The 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 |
3582 | PyDoc_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."
3584 | Return 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 |
3586 | PyDoc_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."
3588 | Return 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 |
3590 | PyDoc_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."
3592 | Return 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."
3593 | that 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 |
3595 | PyDoc_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."
3597 | Create 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."
3598 | The 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 |
3600 | PyDoc_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."
3602 | Return 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."
3603 | On 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 |
3605 | PyDoc_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."
3607 | Acquires 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."
3608 | This 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."
3609 | when 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."
3610 | On 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 |
3612 | PyDoc_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."
3614 | Release 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."
3615 | On 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 |
3617 | static 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 |
3648 | static int
3649 | setint(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 |
3660 | typedef struct {
3661 | PyObject_HEADPyObject ob_base;
3662 | } NullImporter;
3663 |
3664 | static int
3665 | NullImporter_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 |
3733 | static PyObject *
3734 | NullImporter_find_module(NullImporter *self, PyObject *args)
3735 | {
3736 | Py_RETURN_NONEreturn ( _Py_RefTotal++ , ((PyObject*)((&_Py_NoneStruct)) )->ob_refcnt++), (&_Py_NoneStruct);
3737 | }
3738 |
3739 | static 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 |
3747 | PyTypeObject 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 |
3788 | static 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 |
3800 | PyMODINIT_FUNCPyObject*
3801 | PyInit_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 |
3842 | int
3843 | PyImport_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 |
3874 | int
3875 | PyImport_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