Context Navigation

source: python/trunk/Python/import.c@ 383

Last change on this file since 383 was 10, checked in by Yuri Dario, 15 years ago
python: merged offline changes.
Property svn:eol-style set to `native`
File size: 84.2 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: