Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

import.c

Last change on this file was 779, checked in by Yuri Dario, 9 years ago
python: remove 8.3 file name truncation, use opendir() to avoid resolving symlinks. ticket#185.
Property svn:eol-style set to `native`
File size: 97.8 KB

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

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

Context Navigation

source: python/trunk/Python/import.c

Download in other formats: