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