blob: 81027d88879430b45434f55f3e6fa83c9539eea6 [file] [log] [blame]
Guido van Rossumf70e43a1991-02-19 12:39:46 +00001
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00002/* Module definition and import implementation */
3
Guido van Rossum79f25d91997-04-29 20:08:16 +00004#include "Python.h"
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00005
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00006#include "Python-ast.h"
Neal Norwitzadb69fc2005-12-17 20:54:49 +00007#include "pyarena.h"
Jeremy Hylton3e0055f2005-10-20 19:59:25 +00008#include "pythonrun.h"
Guido van Rossum85a5fbb1990-10-14 12:07:46 +00009#include "errcode.h"
Guido van Rossumc405b7b1991-06-04 19:39:42 +000010#include "marshal.h"
Jeremy Hylton3e0055f2005-10-20 19:59:25 +000011#include "code.h"
Guido van Rossumc405b7b1991-06-04 19:39:42 +000012#include "compile.h"
Guido van Rossumff4949e1992-08-05 19:58:53 +000013#include "eval.h"
Guido van Rossumd8bac6d1992-02-26 15:19:13 +000014#include "osdefs.h"
Guido van Rossum1ae940a1995-01-02 19:04:15 +000015#include "importdl.h"
Guido van Rossumc405b7b1991-06-04 19:39:42 +000016
Guido van Rossum55a83382000-09-20 20:31:38 +000017#ifdef HAVE_FCNTL_H
18#include <fcntl.h>
19#endif
Anthony Baxterac6bd462006-04-13 02:06:09 +000020#ifdef __cplusplus
21extern "C" {
22#endif
Guido van Rossum55a83382000-09-20 20:31:38 +000023
Thomas Woutersf70ef4f2000-07-22 18:47:25 +000024extern time_t PyOS_GetLastModificationTime(char *, FILE *);
25 /* In getmtime.c */
Guido van Rossum21d335e1993-10-15 13:01:11 +000026
Jeremy Hyltond4ceb312004-04-01 02:45:22 +000027/* Magic word to reject .pyc files generated by other Python versions.
28 It should change for each incompatible change to the bytecode.
29
30 The value of CR and LF is incorporated so if you ever read or write
Guido van Rossum7faeab31995-07-07 22:50:36 +000031 a .pyc file in text mode the magic number will be wrong; also, the
Tim Peters36515e22001-11-18 04:06:29 +000032 Apple MPW compiler swaps their values, botching string constants.
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000033
Martin v. Löwisef82d2f2004-06-27 16:51:46 +000034 The magic numbers must be spaced apart atleast 2 values, as the
35 -U interpeter flag will cause MAGIC+1 being used. They have been
36 odd numbers for some time now.
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000037
Jeremy Hyltond4ceb312004-04-01 02:45:22 +000038 There were a variety of old schemes for setting the magic number.
39 The current working scheme is to increment the previous value by
40 10.
Guido van Rossumf6894922002-08-31 15:16:14 +000041
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000042 Known values:
43 Python 1.5: 20121
44 Python 1.5.1: 20121
45 Python 1.5.2: 20121
Skip Montanaro4ec3c262006-03-25 14:12:03 +000046 Python 1.6: 50428
Marc-André Lemburgbd3be8f2002-02-07 11:33:49 +000047 Python 2.0: 50823
48 Python 2.0.1: 50823
49 Python 2.1: 60202
50 Python 2.1.1: 60202
51 Python 2.1.2: 60202
52 Python 2.2: 60717
Neal Norwitz7fdcb412002-06-14 01:07:39 +000053 Python 2.3a0: 62011
Michael W. Hudsondd32a912002-08-15 14:59:02 +000054 Python 2.3a0: 62021
Guido van Rossumf6894922002-08-31 15:16:14 +000055 Python 2.3a0: 62011 (!)
Martin v. Löwisef82d2f2004-06-27 16:51:46 +000056 Python 2.4a0: 62041
Raymond Hettingerfd2d1f72004-08-23 23:37:48 +000057 Python 2.4a3: 62051
Raymond Hettinger2c31a052004-09-22 18:44:21 +000058 Python 2.4b1: 62061
Michael W. Hudsondf888462005-06-03 14:41:55 +000059 Python 2.5a0: 62071
Michael W. Hudsonaee2e282005-10-21 11:32:20 +000060 Python 2.5a0: 62081 (ast-branch)
Guido van Rossumc2e20742006-02-27 22:32:47 +000061 Python 2.5a0: 62091 (with)
Guido van Rossumf6694362006-03-10 02:28:35 +000062 Python 2.5a0: 62092 (changed WITH_CLEANUP opcode)
Michael W. Hudsonaee2e282005-10-21 11:32:20 +000063.
Tim Peters36515e22001-11-18 04:06:29 +000064*/
Thomas Woutersf7f438b2006-02-28 16:09:29 +000065#define MAGIC (62092 | ((long)'\r'<<16) | ((long)'\n'<<24))
Guido van Rossum3ddee711991-12-16 13:06:34 +000066
Guido van Rossum96774c12000-05-01 20:19:08 +000067/* Magic word as global; note that _PyImport_Init() can change the
Jeremy Hylton9262b8a2000-06-30 04:59:17 +000068 value of this global to accommodate for alterations of how the
Guido van Rossum96774c12000-05-01 20:19:08 +000069 compiler works which are enabled by command line switches. */
70static long pyc_magic = MAGIC;
71
Guido van Rossum25ce5661997-08-02 03:10:38 +000072/* See _PyImport_FixupExtension() below */
73static PyObject *extensions = NULL;
Guido van Rossum3f5da241990-12-20 15:06:42 +000074
Guido van Rossum771c6c81997-10-31 18:37:24 +000075/* This table is defined in config.c: */
76extern struct _inittab _PyImport_Inittab[];
77
78struct _inittab *PyImport_Inittab = _PyImport_Inittab;
Guido van Rossum66f1fa81991-04-03 19:03:52 +000079
Guido van Rossumed1170e1999-12-20 21:23:41 +000080/* these tables define the module suffixes that Python recognizes */
81struct filedescr * _PyImport_Filetab = NULL;
Guido van Rossum48a680c2001-03-02 06:34:14 +000082
83#ifdef RISCOS
84static const struct filedescr _PyImport_StandardFiletab[] = {
Jack Jansenc88da1f2002-05-28 10:58:19 +000085 {"/py", "U", PY_SOURCE},
Guido van Rossum48a680c2001-03-02 06:34:14 +000086 {"/pyc", "rb", PY_COMPILED},
87 {0, 0}
88};
89#else
Guido van Rossumed1170e1999-12-20 21:23:41 +000090static const struct filedescr _PyImport_StandardFiletab[] = {
Jack Jansenc88da1f2002-05-28 10:58:19 +000091 {".py", "U", PY_SOURCE},
Martin v. Löwis6238d2b2002-06-30 15:26:10 +000092#ifdef MS_WINDOWS
Jack Jansenc88da1f2002-05-28 10:58:19 +000093 {".pyw", "U", PY_SOURCE},
Tim Peters36515e22001-11-18 04:06:29 +000094#endif
Guido van Rossumed1170e1999-12-20 21:23:41 +000095 {".pyc", "rb", PY_COMPILED},
96 {0, 0}
97};
Guido van Rossum48a680c2001-03-02 06:34:14 +000098#endif
Guido van Rossumed1170e1999-12-20 21:23:41 +000099
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000100/* Initialize things */
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000101
102void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000103_PyImport_Init(void)
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000104{
Guido van Rossumed1170e1999-12-20 21:23:41 +0000105 const struct filedescr *scan;
106 struct filedescr *filetab;
107 int countD = 0;
108 int countS = 0;
109
110 /* prepare _PyImport_Filetab: copy entries from
111 _PyImport_DynLoadFiletab and _PyImport_StandardFiletab.
112 */
113 for (scan = _PyImport_DynLoadFiletab; scan->suffix != NULL; ++scan)
114 ++countD;
115 for (scan = _PyImport_StandardFiletab; scan->suffix != NULL; ++scan)
116 ++countS;
Guido van Rossumb18618d2000-05-03 23:44:39 +0000117 filetab = PyMem_NEW(struct filedescr, countD + countS + 1);
Guido van Rossumed1170e1999-12-20 21:23:41 +0000118 memcpy(filetab, _PyImport_DynLoadFiletab,
119 countD * sizeof(struct filedescr));
120 memcpy(filetab + countD, _PyImport_StandardFiletab,
121 countS * sizeof(struct filedescr));
122 filetab[countD + countS].suffix = NULL;
123
124 _PyImport_Filetab = filetab;
125
Guido van Rossum0824f631997-03-11 18:37:35 +0000126 if (Py_OptimizeFlag) {
Guido van Rossumed1170e1999-12-20 21:23:41 +0000127 /* Replace ".pyc" with ".pyo" in _PyImport_Filetab */
128 for (; filetab->suffix != NULL; filetab++) {
Guido van Rossum48a680c2001-03-02 06:34:14 +0000129#ifndef RISCOS
Guido van Rossumed1170e1999-12-20 21:23:41 +0000130 if (strcmp(filetab->suffix, ".pyc") == 0)
131 filetab->suffix = ".pyo";
Guido van Rossum48a680c2001-03-02 06:34:14 +0000132#else
133 if (strcmp(filetab->suffix, "/pyc") == 0)
134 filetab->suffix = "/pyo";
135#endif
Guido van Rossum0824f631997-03-11 18:37:35 +0000136 }
137 }
Guido van Rossum96774c12000-05-01 20:19:08 +0000138
139 if (Py_UnicodeFlag) {
140 /* Fix the pyc_magic so that byte compiled code created
141 using the all-Unicode method doesn't interfere with
142 code created in normal operation mode. */
143 pyc_magic = MAGIC + 1;
144 }
Guido van Rossum85a5fbb1990-10-14 12:07:46 +0000145}
146
Guido van Rossum25ce5661997-08-02 03:10:38 +0000147void
Just van Rossum52e14d62002-12-30 22:08:05 +0000148_PyImportHooks_Init(void)
149{
150 PyObject *v, *path_hooks = NULL, *zimpimport;
151 int err = 0;
152
153 /* adding sys.path_hooks and sys.path_importer_cache, setting up
154 zipimport */
155
156 if (Py_VerboseFlag)
157 PySys_WriteStderr("# installing zipimport hook\n");
158
159 v = PyList_New(0);
160 if (v == NULL)
161 goto error;
162 err = PySys_SetObject("meta_path", v);
163 Py_DECREF(v);
164 if (err)
165 goto error;
166 v = PyDict_New();
167 if (v == NULL)
168 goto error;
169 err = PySys_SetObject("path_importer_cache", v);
170 Py_DECREF(v);
171 if (err)
172 goto error;
173 path_hooks = PyList_New(0);
174 if (path_hooks == NULL)
175 goto error;
176 err = PySys_SetObject("path_hooks", path_hooks);
177 if (err) {
178 error:
179 PyErr_Print();
180 Py_FatalError("initializing sys.meta_path, sys.path_hooks or "
181 "path_importer_cache failed");
182 }
183 zimpimport = PyImport_ImportModule("zipimport");
184 if (zimpimport == NULL) {
185 PyErr_Clear(); /* No zip import module -- okay */
186 if (Py_VerboseFlag)
187 PySys_WriteStderr("# can't import zipimport\n");
188 }
189 else {
190 PyObject *zipimporter = PyObject_GetAttrString(zimpimport,
191 "zipimporter");
192 Py_DECREF(zimpimport);
193 if (zipimporter == NULL) {
194 PyErr_Clear(); /* No zipimporter object -- okay */
195 if (Py_VerboseFlag)
196 PySys_WriteStderr(
Fred Drake1e5fc552003-07-11 15:01:02 +0000197 "# can't import zipimport.zipimporter\n");
Just van Rossum52e14d62002-12-30 22:08:05 +0000198 }
199 else {
200 /* sys.path_hooks.append(zipimporter) */
201 err = PyList_Append(path_hooks, zipimporter);
202 Py_DECREF(zipimporter);
203 if (err)
204 goto error;
205 if (Py_VerboseFlag)
206 PySys_WriteStderr(
207 "# installed zipimport hook\n");
208 }
209 }
210 Py_DECREF(path_hooks);
211}
212
213void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000214_PyImport_Fini(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000215{
216 Py_XDECREF(extensions);
217 extensions = NULL;
Barry Warsaw84294482000-10-03 16:02:05 +0000218 PyMem_DEL(_PyImport_Filetab);
219 _PyImport_Filetab = NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000220}
221
222
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000223/* Locking primitives to prevent parallel imports of the same module
224 in different threads to return with a partially loaded module.
225 These calls are serialized by the global interpreter lock. */
226
227#ifdef WITH_THREAD
228
Guido van Rossum49b56061998-10-01 20:42:43 +0000229#include "pythread.h"
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000230
Guido van Rossum65d5b571998-12-21 19:32:43 +0000231static PyThread_type_lock import_lock = 0;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000232static long import_lock_thread = -1;
233static int import_lock_level = 0;
234
235static void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000236lock_import(void)
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000237{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000238 long me = PyThread_get_thread_ident();
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000239 if (me == -1)
240 return; /* Too bad */
241 if (import_lock == NULL)
Guido van Rossum65d5b571998-12-21 19:32:43 +0000242 import_lock = PyThread_allocate_lock();
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000243 if (import_lock_thread == me) {
244 import_lock_level++;
245 return;
246 }
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000247 if (import_lock_thread != -1 || !PyThread_acquire_lock(import_lock, 0))
248 {
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000249 PyThreadState *tstate = PyEval_SaveThread();
Guido van Rossum65d5b571998-12-21 19:32:43 +0000250 PyThread_acquire_lock(import_lock, 1);
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000251 PyEval_RestoreThread(tstate);
252 }
253 import_lock_thread = me;
254 import_lock_level = 1;
255}
256
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000257static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000258unlock_import(void)
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000259{
Guido van Rossum65d5b571998-12-21 19:32:43 +0000260 long me = PyThread_get_thread_ident();
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000261 if (me == -1)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000262 return 0; /* Too bad */
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000263 if (import_lock_thread != me)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000264 return -1;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000265 import_lock_level--;
266 if (import_lock_level == 0) {
267 import_lock_thread = -1;
Guido van Rossum65d5b571998-12-21 19:32:43 +0000268 PyThread_release_lock(import_lock);
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000269 }
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000270 return 1;
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000271}
272
Guido van Rossum8ee3e5a2005-09-14 18:09:42 +0000273/* This function is called from PyOS_AfterFork to ensure that newly
274 created child processes do not share locks with the parent. */
275
276void
277_PyImport_ReInitLock(void)
278{
279#ifdef _AIX
280 if (import_lock != NULL)
281 import_lock = PyThread_allocate_lock();
282#endif
283}
284
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000285#else
286
287#define lock_import()
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000288#define unlock_import() 0
Guido van Rossum75acc9c1998-03-03 22:26:50 +0000289
290#endif
291
Tim Peters69232342001-08-30 05:16:13 +0000292static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000293imp_lock_held(PyObject *self, PyObject *noargs)
Tim Peters69232342001-08-30 05:16:13 +0000294{
Tim Peters69232342001-08-30 05:16:13 +0000295#ifdef WITH_THREAD
Guido van Rossumb8bff3f2002-04-07 06:34:38 +0000296 return PyBool_FromLong(import_lock_thread != -1);
Tim Peters69232342001-08-30 05:16:13 +0000297#else
Guido van Rossumb8bff3f2002-04-07 06:34:38 +0000298 return PyBool_FromLong(0);
Tim Peters69232342001-08-30 05:16:13 +0000299#endif
300}
301
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000302static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000303imp_acquire_lock(PyObject *self, PyObject *noargs)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000304{
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000305#ifdef WITH_THREAD
306 lock_import();
307#endif
Neal Norwitz2294c0d2003-02-12 23:02:21 +0000308 Py_INCREF(Py_None);
309 return Py_None;
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000310}
311
312static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +0000313imp_release_lock(PyObject *self, PyObject *noargs)
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000314{
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000315#ifdef WITH_THREAD
316 if (unlock_import() < 0) {
317 PyErr_SetString(PyExc_RuntimeError,
318 "not holding the import lock");
319 return NULL;
320 }
321#endif
Neal Norwitz2294c0d2003-02-12 23:02:21 +0000322 Py_INCREF(Py_None);
323 return Py_None;
Guido van Rossumc4f4ca92003-02-12 21:46:11 +0000324}
325
Guido van Rossum25ce5661997-08-02 03:10:38 +0000326/* Helper for sys */
327
328PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000329PyImport_GetModuleDict(void)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000330{
Nicholas Bastine5662ae2004-03-24 22:22:12 +0000331 PyInterpreterState *interp = PyThreadState_GET()->interp;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000332 if (interp->modules == NULL)
333 Py_FatalError("PyImport_GetModuleDict: no module dictionary!");
334 return interp->modules;
335}
336
Guido van Rossum3f5da241990-12-20 15:06:42 +0000337
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000338/* List of names to clear in sys */
339static char* sys_deletes[] = {
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000340 "path", "argv", "ps1", "ps2", "exitfunc",
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000341 "exc_type", "exc_value", "exc_traceback",
342 "last_type", "last_value", "last_traceback",
Just van Rossum52e14d62002-12-30 22:08:05 +0000343 "path_hooks", "path_importer_cache", "meta_path",
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000344 NULL
345};
346
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000347static char* sys_files[] = {
348 "stdin", "__stdin__",
349 "stdout", "__stdout__",
350 "stderr", "__stderr__",
351 NULL
352};
353
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000354
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000355/* Un-initialize things, as good as we can */
Guido van Rossum3f5da241990-12-20 15:06:42 +0000356
Guido van Rossum3f5da241990-12-20 15:06:42 +0000357void
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000358PyImport_Cleanup(void)
Guido van Rossum3f5da241990-12-20 15:06:42 +0000359{
Martin v. Löwis18e16552006-02-15 17:27:45 +0000360 Py_ssize_t pos, ndone;
Guido van Rossum758eec01998-01-19 21:58:26 +0000361 char *name;
362 PyObject *key, *value, *dict;
Nicholas Bastine5662ae2004-03-24 22:22:12 +0000363 PyInterpreterState *interp = PyThreadState_GET()->interp;
Guido van Rossum758eec01998-01-19 21:58:26 +0000364 PyObject *modules = interp->modules;
365
366 if (modules == NULL)
367 return; /* Already done */
368
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000369 /* Delete some special variables first. These are common
370 places where user values hide and people complain when their
371 destructors fail. Since the modules containing them are
372 deleted *last* of all, they would come too late in the normal
373 destruction order. Sigh. */
374
375 value = PyDict_GetItemString(modules, "__builtin__");
376 if (value != NULL && PyModule_Check(value)) {
377 dict = PyModule_GetDict(value);
378 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000379 PySys_WriteStderr("# clear __builtin__._\n");
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000380 PyDict_SetItemString(dict, "_", Py_None);
381 }
382 value = PyDict_GetItemString(modules, "sys");
383 if (value != NULL && PyModule_Check(value)) {
384 char **p;
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000385 PyObject *v;
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000386 dict = PyModule_GetDict(value);
387 for (p = sys_deletes; *p != NULL; p++) {
388 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000389 PySys_WriteStderr("# clear sys.%s\n", *p);
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000390 PyDict_SetItemString(dict, *p, Py_None);
391 }
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000392 for (p = sys_files; *p != NULL; p+=2) {
393 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000394 PySys_WriteStderr("# restore sys.%s\n", *p);
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000395 v = PyDict_GetItemString(dict, *(p+1));
396 if (v == NULL)
397 v = Py_None;
398 PyDict_SetItemString(dict, *p, v);
399 }
400 }
401
402 /* First, delete __main__ */
403 value = PyDict_GetItemString(modules, "__main__");
404 if (value != NULL && PyModule_Check(value)) {
405 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000406 PySys_WriteStderr("# cleanup __main__\n");
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000407 _PyModule_Clear(value);
408 PyDict_SetItemString(modules, "__main__", Py_None);
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000409 }
410
Guido van Rossum758eec01998-01-19 21:58:26 +0000411 /* The special treatment of __builtin__ here is because even
412 when it's not referenced as a module, its dictionary is
413 referenced by almost every module's __builtins__. Since
414 deleting a module clears its dictionary (even if there are
415 references left to it), we need to delete the __builtin__
416 module last. Likewise, we don't delete sys until the very
417 end because it is implicitly referenced (e.g. by print).
418
419 Also note that we 'delete' modules by replacing their entry
420 in the modules dict with None, rather than really deleting
421 them; this avoids a rehash of the modules dictionary and
422 also marks them as "non existent" so they won't be
423 re-imported. */
424
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000425 /* Next, repeatedly delete modules with a reference count of
Guido van Rossum758eec01998-01-19 21:58:26 +0000426 one (skipping __builtin__ and sys) and delete them */
427 do {
428 ndone = 0;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000429 pos = 0;
Guido van Rossum758eec01998-01-19 21:58:26 +0000430 while (PyDict_Next(modules, &pos, &key, &value)) {
431 if (value->ob_refcnt != 1)
432 continue;
Guido van Rossum566373e1998-10-01 15:24:50 +0000433 if (PyString_Check(key) && PyModule_Check(value)) {
434 name = PyString_AS_STRING(key);
Guido van Rossum758eec01998-01-19 21:58:26 +0000435 if (strcmp(name, "__builtin__") == 0)
436 continue;
437 if (strcmp(name, "sys") == 0)
438 continue;
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000439 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000440 PySys_WriteStderr(
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000441 "# cleanup[1] %s\n", name);
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000442 _PyModule_Clear(value);
Guido van Rossum758eec01998-01-19 21:58:26 +0000443 PyDict_SetItem(modules, key, Py_None);
444 ndone++;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000445 }
446 }
Guido van Rossum758eec01998-01-19 21:58:26 +0000447 } while (ndone > 0);
448
Guido van Rossum758eec01998-01-19 21:58:26 +0000449 /* Next, delete all modules (still skipping __builtin__ and sys) */
450 pos = 0;
451 while (PyDict_Next(modules, &pos, &key, &value)) {
Guido van Rossum566373e1998-10-01 15:24:50 +0000452 if (PyString_Check(key) && PyModule_Check(value)) {
453 name = PyString_AS_STRING(key);
Guido van Rossum758eec01998-01-19 21:58:26 +0000454 if (strcmp(name, "__builtin__") == 0)
455 continue;
456 if (strcmp(name, "sys") == 0)
457 continue;
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000458 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000459 PySys_WriteStderr("# cleanup[2] %s\n", name);
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000460 _PyModule_Clear(value);
Guido van Rossum758eec01998-01-19 21:58:26 +0000461 PyDict_SetItem(modules, key, Py_None);
462 }
463 }
464
465 /* Next, delete sys and __builtin__ (in that order) */
466 value = PyDict_GetItemString(modules, "sys");
467 if (value != NULL && PyModule_Check(value)) {
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000468 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000469 PySys_WriteStderr("# cleanup sys\n");
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000470 _PyModule_Clear(value);
Guido van Rossum758eec01998-01-19 21:58:26 +0000471 PyDict_SetItemString(modules, "sys", Py_None);
472 }
473 value = PyDict_GetItemString(modules, "__builtin__");
474 if (value != NULL && PyModule_Check(value)) {
Guido van Rossuma0fec2b1998-02-06 17:16:02 +0000475 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000476 PySys_WriteStderr("# cleanup __builtin__\n");
Guido van Rossum05f9dce1998-02-19 20:58:44 +0000477 _PyModule_Clear(value);
Guido van Rossum758eec01998-01-19 21:58:26 +0000478 PyDict_SetItemString(modules, "__builtin__", Py_None);
479 }
480
481 /* Finally, clear and delete the modules directory */
482 PyDict_Clear(modules);
483 interp->modules = NULL;
484 Py_DECREF(modules);
Guido van Rossum8d15b5d1990-10-26 14:58:58 +0000485}
Guido van Rossum7f133ed1991-02-19 12:23:57 +0000486
487
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000488/* Helper for pythonrun.c -- return magic number */
489
490long
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000491PyImport_GetMagicNumber(void)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000492{
Guido van Rossum96774c12000-05-01 20:19:08 +0000493 return pyc_magic;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000494}
495
496
Guido van Rossum25ce5661997-08-02 03:10:38 +0000497/* Magic for extension modules (built-in as well as dynamically
498 loaded). To prevent initializing an extension module more than
499 once, we keep a static dictionary 'extensions' keyed by module name
500 (for built-in modules) or by filename (for dynamically loaded
Barry Warsaw92883382001-08-13 23:05:44 +0000501 modules), containing these modules. A copy of the module's
Guido van Rossum25ce5661997-08-02 03:10:38 +0000502 dictionary is stored by calling _PyImport_FixupExtension()
503 immediately after the module initialization function succeeds. A
504 copy can be retrieved from there by calling
505 _PyImport_FindExtension(). */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000506
Guido van Rossum79f25d91997-04-29 20:08:16 +0000507PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000508_PyImport_FixupExtension(char *name, char *filename)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000509{
Guido van Rossum25ce5661997-08-02 03:10:38 +0000510 PyObject *modules, *mod, *dict, *copy;
511 if (extensions == NULL) {
512 extensions = PyDict_New();
513 if (extensions == NULL)
514 return NULL;
515 }
516 modules = PyImport_GetModuleDict();
517 mod = PyDict_GetItemString(modules, name);
518 if (mod == NULL || !PyModule_Check(mod)) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000519 PyErr_Format(PyExc_SystemError,
520 "_PyImport_FixupExtension: module %.200s not loaded", name);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000521 return NULL;
522 }
523 dict = PyModule_GetDict(mod);
524 if (dict == NULL)
525 return NULL;
Fred Drake9cd0efc2001-10-25 21:38:59 +0000526 copy = PyDict_Copy(dict);
Guido van Rossum25ce5661997-08-02 03:10:38 +0000527 if (copy == NULL)
528 return NULL;
529 PyDict_SetItemString(extensions, filename, copy);
530 Py_DECREF(copy);
531 return copy;
532}
533
534PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000535_PyImport_FindExtension(char *name, char *filename)
Guido van Rossum25ce5661997-08-02 03:10:38 +0000536{
Fred Drake9cd0efc2001-10-25 21:38:59 +0000537 PyObject *dict, *mod, *mdict;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000538 if (extensions == NULL)
539 return NULL;
540 dict = PyDict_GetItemString(extensions, filename);
541 if (dict == NULL)
542 return NULL;
543 mod = PyImport_AddModule(name);
544 if (mod == NULL)
545 return NULL;
546 mdict = PyModule_GetDict(mod);
547 if (mdict == NULL)
548 return NULL;
Fred Drake9cd0efc2001-10-25 21:38:59 +0000549 if (PyDict_Update(mdict, dict))
Guido van Rossum25ce5661997-08-02 03:10:38 +0000550 return NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000551 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000552 PySys_WriteStderr("import %s # previously loaded (%s)\n",
Guido van Rossum25ce5661997-08-02 03:10:38 +0000553 name, filename);
554 return mod;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000555}
556
557
558/* Get the module object corresponding to a module name.
559 First check the modules dictionary if there's one there,
Walter Dörwaldf0dfc7a2003-10-20 14:01:56 +0000560 if not, create a new one and insert it in the modules dictionary.
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000561 Because the former action is most common, THIS DOES NOT RETURN A
562 'NEW' REFERENCE! */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000563
Guido van Rossum79f25d91997-04-29 20:08:16 +0000564PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000565PyImport_AddModule(const char *name)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000566{
Guido van Rossum25ce5661997-08-02 03:10:38 +0000567 PyObject *modules = PyImport_GetModuleDict();
Guido van Rossum79f25d91997-04-29 20:08:16 +0000568 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000569
Guido van Rossum25ce5661997-08-02 03:10:38 +0000570 if ((m = PyDict_GetItemString(modules, name)) != NULL &&
Guido van Rossum79f25d91997-04-29 20:08:16 +0000571 PyModule_Check(m))
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000572 return m;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000573 m = PyModule_New(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000574 if (m == NULL)
575 return NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +0000576 if (PyDict_SetItemString(modules, name, m) != 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000577 Py_DECREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000578 return NULL;
579 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000580 Py_DECREF(m); /* Yes, it still exists, in modules! */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000581
582 return m;
583}
584
Tim Peters1cd70172004-08-02 03:52:12 +0000585/* Remove name from sys.modules, if it's there. */
586static void
587_RemoveModule(const char *name)
588{
589 PyObject *modules = PyImport_GetModuleDict();
590 if (PyDict_GetItemString(modules, name) == NULL)
591 return;
592 if (PyDict_DelItemString(modules, name) < 0)
593 Py_FatalError("import: deleting existing key in"
594 "sys.modules failed");
595}
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000596
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000597/* Execute a code object in a module and return the module object
Tim Peters1cd70172004-08-02 03:52:12 +0000598 * WITH INCREMENTED REFERENCE COUNT. If an error occurs, name is
599 * removed from sys.modules, to avoid leaving damaged module objects
600 * in sys.modules. The caller may wish to restore the original
601 * module object (if any) in this case; PyImport_ReloadModule is an
602 * example.
603 */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000604PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000605PyImport_ExecCodeModule(char *name, PyObject *co)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000606{
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000607 return PyImport_ExecCodeModuleEx(name, co, (char *)NULL);
608}
609
610PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000611PyImport_ExecCodeModuleEx(char *name, PyObject *co, char *pathname)
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000612{
Guido van Rossum25ce5661997-08-02 03:10:38 +0000613 PyObject *modules = PyImport_GetModuleDict();
Guido van Rossum79f25d91997-04-29 20:08:16 +0000614 PyObject *m, *d, *v;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000615
Guido van Rossum79f25d91997-04-29 20:08:16 +0000616 m = PyImport_AddModule(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000617 if (m == NULL)
618 return NULL;
Jeremy Hyltonecd91292004-01-02 23:25:32 +0000619 /* If the module is being reloaded, we get the old module back
620 and re-use its dict to exec the new code. */
Guido van Rossum79f25d91997-04-29 20:08:16 +0000621 d = PyModule_GetDict(m);
622 if (PyDict_GetItemString(d, "__builtins__") == NULL) {
623 if (PyDict_SetItemString(d, "__builtins__",
624 PyEval_GetBuiltins()) != 0)
Tim Peters1cd70172004-08-02 03:52:12 +0000625 goto error;
Guido van Rossum6135a871995-01-09 17:53:26 +0000626 }
Guido van Rossum9c9a07c1996-05-16 20:43:40 +0000627 /* Remember the filename as the __file__ attribute */
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000628 v = NULL;
629 if (pathname != NULL) {
630 v = PyString_FromString(pathname);
631 if (v == NULL)
632 PyErr_Clear();
633 }
634 if (v == NULL) {
635 v = ((PyCodeObject *)co)->co_filename;
636 Py_INCREF(v);
637 }
638 if (PyDict_SetItemString(d, "__file__", v) != 0)
Guido van Rossum79f25d91997-04-29 20:08:16 +0000639 PyErr_Clear(); /* Not important enough to report */
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000640 Py_DECREF(v);
641
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000642 v = PyEval_EvalCode((PyCodeObject *)co, d, d);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000643 if (v == NULL)
Tim Peters1cd70172004-08-02 03:52:12 +0000644 goto error;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000645 Py_DECREF(v);
Guido van Rossumb65e85c1997-07-10 18:00:45 +0000646
Guido van Rossum25ce5661997-08-02 03:10:38 +0000647 if ((m = PyDict_GetItemString(modules, name)) == NULL) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000648 PyErr_Format(PyExc_ImportError,
649 "Loaded module %.200s not found in sys.modules",
650 name);
Guido van Rossumb65e85c1997-07-10 18:00:45 +0000651 return NULL;
652 }
653
Guido van Rossum79f25d91997-04-29 20:08:16 +0000654 Py_INCREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000655
656 return m;
Tim Peters1cd70172004-08-02 03:52:12 +0000657
658 error:
659 _RemoveModule(name);
660 return NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000661}
662
663
664/* Given a pathname for a Python source file, fill a buffer with the
665 pathname for the corresponding compiled file. Return the pathname
666 for the compiled file, or NULL if there's no space in the buffer.
667 Doesn't set an exception. */
668
669static char *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000670make_compiled_pathname(char *pathname, char *buf, size_t buflen)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000671{
Tim Petersc1731372001-08-04 08:12:36 +0000672 size_t len = strlen(pathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000673 if (len+2 > buflen)
674 return NULL;
Tim Petersc1731372001-08-04 08:12:36 +0000675
Martin v. Löwis6238d2b2002-06-30 15:26:10 +0000676#ifdef MS_WINDOWS
Tim Petersc1731372001-08-04 08:12:36 +0000677 /* Treat .pyw as if it were .py. The case of ".pyw" must match
678 that used in _PyImport_StandardFiletab. */
679 if (len >= 4 && strcmp(&pathname[len-4], ".pyw") == 0)
680 --len; /* pretend 'w' isn't there */
681#endif
682 memcpy(buf, pathname, len);
683 buf[len] = Py_OptimizeFlag ? 'o' : 'c';
684 buf[len+1] = '\0';
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000685
686 return buf;
687}
688
689
690/* Given a pathname for a Python source file, its time of last
691 modification, and a pathname for a compiled file, check whether the
692 compiled file represents the same version of the source. If so,
693 return a FILE pointer for the compiled file, positioned just after
694 the header; if not, return NULL.
695 Doesn't set an exception. */
696
697static FILE *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000698check_compiled_module(char *pathname, time_t mtime, char *cpathname)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000699{
700 FILE *fp;
701 long magic;
702 long pyc_mtime;
703
704 fp = fopen(cpathname, "rb");
705 if (fp == NULL)
706 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000707 magic = PyMarshal_ReadLongFromFile(fp);
Guido van Rossum96774c12000-05-01 20:19:08 +0000708 if (magic != pyc_magic) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000709 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000710 PySys_WriteStderr("# %s has bad magic\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000711 fclose(fp);
712 return NULL;
713 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000714 pyc_mtime = PyMarshal_ReadLongFromFile(fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000715 if (pyc_mtime != mtime) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000716 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000717 PySys_WriteStderr("# %s has bad mtime\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000718 fclose(fp);
719 return NULL;
720 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000721 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000722 PySys_WriteStderr("# %s matches %s\n", cpathname, pathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000723 return fp;
724}
725
726
727/* Read a code object from a file and check it for validity */
728
Guido van Rossum79f25d91997-04-29 20:08:16 +0000729static PyCodeObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000730read_compiled_module(char *cpathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000731{
Guido van Rossum79f25d91997-04-29 20:08:16 +0000732 PyObject *co;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000733
Tim Petersd9b9ac82001-01-28 00:27:39 +0000734 co = PyMarshal_ReadLastObjectFromFile(fp);
Armin Rigo01ab2792004-03-26 15:09:27 +0000735 if (co == NULL)
736 return NULL;
737 if (!PyCode_Check(co)) {
738 PyErr_Format(PyExc_ImportError,
739 "Non-code object in %.200s", cpathname);
740 Py_DECREF(co);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000741 return NULL;
742 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000743 return (PyCodeObject *)co;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000744}
745
746
747/* Load a module from a compiled file, execute it, and return its
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000748 module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000749
Guido van Rossum79f25d91997-04-29 20:08:16 +0000750static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000751load_compiled_module(char *name, char *cpathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000752{
753 long magic;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000754 PyCodeObject *co;
755 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000756
Guido van Rossum79f25d91997-04-29 20:08:16 +0000757 magic = PyMarshal_ReadLongFromFile(fp);
Guido van Rossum96774c12000-05-01 20:19:08 +0000758 if (magic != pyc_magic) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000759 PyErr_Format(PyExc_ImportError,
760 "Bad magic number in %.200s", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000761 return NULL;
762 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000763 (void) PyMarshal_ReadLongFromFile(fp);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000764 co = read_compiled_module(cpathname, fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000765 if (co == NULL)
766 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000767 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000768 PySys_WriteStderr("import %s # precompiled from %s\n",
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000769 name, cpathname);
Guido van Rossume32bf6e1998-02-11 05:53:02 +0000770 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, cpathname);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000771 Py_DECREF(co);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000772
773 return m;
774}
775
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000776/* Parse a source file and return the corresponding code object */
777
Guido van Rossum79f25d91997-04-29 20:08:16 +0000778static PyCodeObject *
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000779parse_source_module(const char *pathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000780{
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000781 PyCodeObject *co = NULL;
782 mod_ty mod;
Neal Norwitzadb69fc2005-12-17 20:54:49 +0000783 PyArena *arena = PyArena_New();
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000784
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000785 mod = PyParser_ASTFromFile(fp, pathname, Py_file_input, 0, 0, 0,
Neal Norwitzadb69fc2005-12-17 20:54:49 +0000786 NULL, arena);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000787 if (mod) {
Neal Norwitzadb69fc2005-12-17 20:54:49 +0000788 co = PyAST_Compile(mod, pathname, NULL, arena);
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000789 }
Neal Norwitzadb69fc2005-12-17 20:54:49 +0000790 PyArena_Free(arena);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000791 return co;
792}
793
794
Guido van Rossum55a83382000-09-20 20:31:38 +0000795/* Helper to open a bytecode file for writing in exclusive mode */
796
797static FILE *
798open_exclusive(char *filename)
799{
800#if defined(O_EXCL)&&defined(O_CREAT)&&defined(O_WRONLY)&&defined(O_TRUNC)
801 /* Use O_EXCL to avoid a race condition when another process tries to
802 write the same file. When that happens, our open() call fails,
803 which is just fine (since it's only a cache).
804 XXX If the file exists and is writable but the directory is not
805 writable, the file will never be written. Oh well.
806 */
807 int fd;
808 (void) unlink(filename);
Tim Peters42c83af2000-09-29 04:03:10 +0000809 fd = open(filename, O_EXCL|O_CREAT|O_WRONLY|O_TRUNC
810#ifdef O_BINARY
811 |O_BINARY /* necessary for Windows */
812#endif
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000813#ifdef __VMS
Martin v. Löwis18e16552006-02-15 17:27:45 +0000814 , 0666, "ctxt=bin", "shr=nil"
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000815#else
Martin v. Löwis18e16552006-02-15 17:27:45 +0000816 , 0666
Martin v. Löwis79acb9e2002-12-06 12:48:53 +0000817#endif
Martin v. Löwis18e16552006-02-15 17:27:45 +0000818 );
Guido van Rossum55a83382000-09-20 20:31:38 +0000819 if (fd < 0)
820 return NULL;
821 return fdopen(fd, "wb");
822#else
823 /* Best we can do -- on Windows this can't happen anyway */
824 return fopen(filename, "wb");
825#endif
826}
827
828
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000829/* Write a compiled module to a file, placing the time of last
830 modification of its source into the header.
831 Errors are ignored, if a write error occurs an attempt is made to
832 remove the file. */
833
834static void
Martin v. Löwis18e16552006-02-15 17:27:45 +0000835write_compiled_module(PyCodeObject *co, char *cpathname, time_t mtime)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000836{
837 FILE *fp;
838
Guido van Rossum55a83382000-09-20 20:31:38 +0000839 fp = open_exclusive(cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000840 if (fp == NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000841 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000842 PySys_WriteStderr(
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000843 "# can't create %s\n", cpathname);
844 return;
845 }
Martin v. Löwisef82d2f2004-06-27 16:51:46 +0000846 PyMarshal_WriteLongToFile(pyc_magic, fp, Py_MARSHAL_VERSION);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000847 /* First write a 0 for mtime */
Martin v. Löwisef82d2f2004-06-27 16:51:46 +0000848 PyMarshal_WriteLongToFile(0L, fp, Py_MARSHAL_VERSION);
849 PyMarshal_WriteObjectToFile((PyObject *)co, fp, Py_MARSHAL_VERSION);
Armin Rigo01ab2792004-03-26 15:09:27 +0000850 if (fflush(fp) != 0 || ferror(fp)) {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000851 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000852 PySys_WriteStderr("# can't write %s\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000853 /* Don't keep partial file */
854 fclose(fp);
855 (void) unlink(cpathname);
856 return;
857 }
858 /* Now write the true mtime */
859 fseek(fp, 4L, 0);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000860 assert(mtime < LONG_MAX);
Martin v. Löwis725507b2006-03-07 12:08:51 +0000861 PyMarshal_WriteLongToFile((long)mtime, fp, Py_MARSHAL_VERSION);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000862 fflush(fp);
863 fclose(fp);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000864 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000865 PySys_WriteStderr("# wrote %s\n", cpathname);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000866}
867
868
869/* Load a source module from a given file and return its module
Guido van Rossum7f9fa971995-01-20 16:53:12 +0000870 object WITH INCREMENTED REFERENCE COUNT. If there's a matching
871 byte-compiled file, use that instead. */
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000872
Guido van Rossum79f25d91997-04-29 20:08:16 +0000873static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000874load_source_module(char *name, char *pathname, FILE *fp)
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000875{
Fred Drake4c82b232000-06-30 16:18:57 +0000876 time_t mtime;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000877 FILE *fpc;
878 char buf[MAXPATHLEN+1];
879 char *cpathname;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000880 PyCodeObject *co;
881 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000882
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000883 mtime = PyOS_GetLastModificationTime(pathname, fp);
Neal Norwitz708e51a2005-10-03 04:48:15 +0000884 if (mtime == (time_t)(-1)) {
885 PyErr_Format(PyExc_RuntimeError,
886 "unable to get modification time from '%s'",
887 pathname);
Fred Drake4c82b232000-06-30 16:18:57 +0000888 return NULL;
Neal Norwitz708e51a2005-10-03 04:48:15 +0000889 }
Fred Drake4c82b232000-06-30 16:18:57 +0000890#if SIZEOF_TIME_T > 4
891 /* Python's .pyc timestamp handling presumes that the timestamp fits
892 in 4 bytes. This will be fine until sometime in the year 2038,
893 when a 4-byte signed time_t will overflow.
894 */
895 if (mtime >> 32) {
896 PyErr_SetString(PyExc_OverflowError,
Fred Drakec63d3e92001-03-01 06:33:32 +0000897 "modification time overflows a 4 byte field");
Fred Drake4c82b232000-06-30 16:18:57 +0000898 return NULL;
899 }
900#endif
Tim Peters36515e22001-11-18 04:06:29 +0000901 cpathname = make_compiled_pathname(pathname, buf,
Jeremy Hylton37832f02001-04-13 17:50:20 +0000902 (size_t)MAXPATHLEN + 1);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000903 if (cpathname != NULL &&
904 (fpc = check_compiled_module(pathname, mtime, cpathname))) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000905 co = read_compiled_module(cpathname, fpc);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000906 fclose(fpc);
907 if (co == NULL)
908 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000909 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000910 PySys_WriteStderr("import %s # precompiled from %s\n",
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000911 name, cpathname);
Guido van Rossumafd3dae1998-08-25 18:44:34 +0000912 pathname = cpathname;
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000913 }
914 else {
915 co = parse_source_module(pathname, fp);
916 if (co == NULL)
917 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +0000918 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000919 PySys_WriteStderr("import %s # from %s\n",
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000920 name, pathname);
921 write_compiled_module(co, cpathname, mtime);
922 }
Guido van Rossumafd3dae1998-08-25 18:44:34 +0000923 m = PyImport_ExecCodeModuleEx(name, (PyObject *)co, pathname);
Guido van Rossum79f25d91997-04-29 20:08:16 +0000924 Py_DECREF(co);
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000925
926 return m;
927}
928
929
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000930/* Forward */
Just van Rossum52e14d62002-12-30 22:08:05 +0000931static PyObject *load_module(char *, FILE *, char *, int, PyObject *);
932static struct filedescr *find_module(char *, char *, PyObject *,
933 char *, size_t, FILE **, PyObject **);
Tim Petersdbd9ba62000-07-09 03:09:57 +0000934static struct _frozen *find_frozen(char *name);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000935
936/* Load a package and return its module object WITH INCREMENTED
937 REFERENCE COUNT */
938
939static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000940load_package(char *name, char *pathname)
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000941{
Tim Peters1cd70172004-08-02 03:52:12 +0000942 PyObject *m, *d;
943 PyObject *file = NULL;
944 PyObject *path = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000945 int err;
946 char buf[MAXPATHLEN+1];
947 FILE *fp = NULL;
948 struct filedescr *fdp;
949
950 m = PyImport_AddModule(name);
951 if (m == NULL)
952 return NULL;
Guido van Rossum17fc85f1997-09-06 18:52:03 +0000953 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +0000954 PySys_WriteStderr("import %s # directory %s\n",
Guido van Rossum17fc85f1997-09-06 18:52:03 +0000955 name, pathname);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000956 d = PyModule_GetDict(m);
957 file = PyString_FromString(pathname);
958 if (file == NULL)
Tim Peters1cd70172004-08-02 03:52:12 +0000959 goto error;
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000960 path = Py_BuildValue("[O]", file);
Tim Peters1cd70172004-08-02 03:52:12 +0000961 if (path == NULL)
962 goto error;
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000963 err = PyDict_SetItemString(d, "__file__", file);
964 if (err == 0)
965 err = PyDict_SetItemString(d, "__path__", path);
Tim Peters1cd70172004-08-02 03:52:12 +0000966 if (err != 0)
967 goto error;
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000968 buf[0] = '\0';
Just van Rossum52e14d62002-12-30 22:08:05 +0000969 fdp = find_module(name, "__init__", path, buf, sizeof(buf), &fp, NULL);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000970 if (fdp == NULL) {
971 if (PyErr_ExceptionMatches(PyExc_ImportError)) {
972 PyErr_Clear();
Thomas Heller25653242004-06-07 15:04:10 +0000973 Py_INCREF(m);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000974 }
975 else
976 m = NULL;
977 goto cleanup;
978 }
Just van Rossum52e14d62002-12-30 22:08:05 +0000979 m = load_module(name, fp, buf, fdp->type, NULL);
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000980 if (fp != NULL)
981 fclose(fp);
Tim Peters1cd70172004-08-02 03:52:12 +0000982 goto cleanup;
983
984 error:
985 m = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000986 cleanup:
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000987 Py_XDECREF(path);
988 Py_XDECREF(file);
989 return m;
990}
991
992
993/* Helper to test for built-in module */
994
995static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +0000996is_builtin(char *name)
Guido van Rossumaee0bad1997-09-05 07:33:22 +0000997{
998 int i;
Guido van Rossum771c6c81997-10-31 18:37:24 +0000999 for (i = 0; PyImport_Inittab[i].name != NULL; i++) {
1000 if (strcmp(name, PyImport_Inittab[i].name) == 0) {
1001 if (PyImport_Inittab[i].initfunc == NULL)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001002 return -1;
1003 else
1004 return 1;
1005 }
1006 }
1007 return 0;
1008}
1009
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001010
Just van Rossum52e14d62002-12-30 22:08:05 +00001011/* Return an importer object for a sys.path/pkg.__path__ item 'p',
1012 possibly by fetching it from the path_importer_cache dict. If it
1013 wasn't yet cached, traverse path_hooks until it a hook is found
1014 that can handle the path item. Return None if no hook could;
1015 this tells our caller it should fall back to the builtin
1016 import mechanism. Cache the result in path_importer_cache.
1017 Returns a borrowed reference. */
1018
1019static PyObject *
1020get_path_importer(PyObject *path_importer_cache, PyObject *path_hooks,
1021 PyObject *p)
1022{
1023 PyObject *importer;
Martin v. Löwis725507b2006-03-07 12:08:51 +00001024 Py_ssize_t j, nhooks;
Just van Rossum52e14d62002-12-30 22:08:05 +00001025
1026 /* These conditions are the caller's responsibility: */
1027 assert(PyList_Check(path_hooks));
1028 assert(PyDict_Check(path_importer_cache));
1029
1030 nhooks = PyList_Size(path_hooks);
1031 if (nhooks < 0)
1032 return NULL; /* Shouldn't happen */
1033
1034 importer = PyDict_GetItem(path_importer_cache, p);
1035 if (importer != NULL)
1036 return importer;
1037
1038 /* set path_importer_cache[p] to None to avoid recursion */
1039 if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
1040 return NULL;
1041
1042 for (j = 0; j < nhooks; j++) {
1043 PyObject *hook = PyList_GetItem(path_hooks, j);
1044 if (hook == NULL)
1045 return NULL;
1046 importer = PyObject_CallFunction(hook, "O", p);
1047 if (importer != NULL)
1048 break;
1049
1050 if (!PyErr_ExceptionMatches(PyExc_ImportError)) {
1051 return NULL;
1052 }
1053 PyErr_Clear();
1054 }
1055 if (importer == NULL)
1056 importer = Py_None;
1057 else if (importer != Py_None) {
1058 int err = PyDict_SetItem(path_importer_cache, p, importer);
1059 Py_DECREF(importer);
1060 if (err != 0)
1061 return NULL;
1062 }
1063 return importer;
1064}
1065
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001066/* Search the path (default sys.path) for a module. Return the
1067 corresponding filedescr struct, and (via return arguments) the
1068 pathname and an open file. Return NULL if the module is not found. */
1069
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001070#ifdef MS_COREDLL
Thomas Woutersb4bd21c2000-07-22 23:38:01 +00001071extern FILE *PyWin_FindRegisteredModule(const char *, struct filedescr **,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001072 char *, Py_ssize_t);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001073#endif
1074
Martin v. Löwis18e16552006-02-15 17:27:45 +00001075static int case_ok(char *, Py_ssize_t, Py_ssize_t, char *);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001076static int find_init_module(char *); /* Forward */
Just van Rossum52e14d62002-12-30 22:08:05 +00001077static struct filedescr importhookdescr = {"", "", IMP_HOOK};
Guido van Rossum197346f1997-10-31 18:38:52 +00001078
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001079static struct filedescr *
Just van Rossum52e14d62002-12-30 22:08:05 +00001080find_module(char *fullname, char *subname, PyObject *path, char *buf,
1081 size_t buflen, FILE **p_fp, PyObject **p_loader)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001082{
Martin v. Löwis725507b2006-03-07 12:08:51 +00001083 Py_ssize_t i, npath;
Fred Drake4c82b232000-06-30 16:18:57 +00001084 size_t len, namelen;
Guido van Rossum80bb9651996-12-05 23:27:02 +00001085 struct filedescr *fdp = NULL;
Jack Jansenc88da1f2002-05-28 10:58:19 +00001086 char *filemode;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001087 FILE *fp = NULL;
Just van Rossum52e14d62002-12-30 22:08:05 +00001088 PyObject *path_hooks, *path_importer_cache;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001089#ifndef RISCOS
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001090 struct stat statbuf;
Guido van Rossum48a680c2001-03-02 06:34:14 +00001091#endif
Guido van Rossuma5568d31998-03-05 03:45:08 +00001092 static struct filedescr fd_frozen = {"", "", PY_FROZEN};
1093 static struct filedescr fd_builtin = {"", "", C_BUILTIN};
1094 static struct filedescr fd_package = {"", "", PKG_DIRECTORY};
Guido van Rossum0506a431998-08-11 15:07:39 +00001095 char name[MAXPATHLEN+1];
Andrew MacIntyred9400542002-02-26 11:41:34 +00001096#if defined(PYOS_OS2)
1097 size_t saved_len;
1098 size_t saved_namelen;
1099 char *saved_buf = NULL;
1100#endif
Just van Rossum52e14d62002-12-30 22:08:05 +00001101 if (p_loader != NULL)
1102 *p_loader = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001103
Just van Rossum52e14d62002-12-30 22:08:05 +00001104 if (strlen(subname) > MAXPATHLEN) {
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001105 PyErr_SetString(PyExc_OverflowError,
1106 "module name is too long");
Fred Drake4c82b232000-06-30 16:18:57 +00001107 return NULL;
1108 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001109 strcpy(name, subname);
1110
1111 /* sys.meta_path import hook */
1112 if (p_loader != NULL) {
1113 PyObject *meta_path;
1114
1115 meta_path = PySys_GetObject("meta_path");
1116 if (meta_path == NULL || !PyList_Check(meta_path)) {
1117 PyErr_SetString(PyExc_ImportError,
1118 "sys.meta_path must be a list of "
1119 "import hooks");
1120 return NULL;
1121 }
1122 Py_INCREF(meta_path); /* zap guard */
1123 npath = PyList_Size(meta_path);
1124 for (i = 0; i < npath; i++) {
1125 PyObject *loader;
1126 PyObject *hook = PyList_GetItem(meta_path, i);
1127 loader = PyObject_CallMethod(hook, "find_module",
1128 "sO", fullname,
1129 path != NULL ?
1130 path : Py_None);
1131 if (loader == NULL) {
1132 Py_DECREF(meta_path);
1133 return NULL; /* true error */
1134 }
1135 if (loader != Py_None) {
1136 /* a loader was found */
1137 *p_loader = loader;
1138 Py_DECREF(meta_path);
1139 return &importhookdescr;
1140 }
1141 Py_DECREF(loader);
1142 }
1143 Py_DECREF(meta_path);
1144 }
Guido van Rossum0506a431998-08-11 15:07:39 +00001145
1146 if (path != NULL && PyString_Check(path)) {
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001147 /* The only type of submodule allowed inside a "frozen"
1148 package are other frozen modules or packages. */
Guido van Rossum0506a431998-08-11 15:07:39 +00001149 if (PyString_Size(path) + 1 + strlen(name) >= (size_t)buflen) {
1150 PyErr_SetString(PyExc_ImportError,
1151 "full frozen module name too long");
1152 return NULL;
1153 }
1154 strcpy(buf, PyString_AsString(path));
1155 strcat(buf, ".");
1156 strcat(buf, name);
1157 strcpy(name, buf);
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001158 if (find_frozen(name) != NULL) {
1159 strcpy(buf, name);
1160 return &fd_frozen;
1161 }
1162 PyErr_Format(PyExc_ImportError,
1163 "No frozen submodule named %.200s", name);
1164 return NULL;
Guido van Rossum0506a431998-08-11 15:07:39 +00001165 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001166 if (path == NULL) {
1167 if (is_builtin(name)) {
Guido van Rossuma5568d31998-03-05 03:45:08 +00001168 strcpy(buf, name);
1169 return &fd_builtin;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001170 }
Greg Ward201baee2001-10-04 14:52:06 +00001171 if ((find_frozen(name)) != NULL) {
Guido van Rossuma5568d31998-03-05 03:45:08 +00001172 strcpy(buf, name);
1173 return &fd_frozen;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001174 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001175
Guido van Rossumac279101996-08-22 23:10:58 +00001176#ifdef MS_COREDLL
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001177 fp = PyWin_FindRegisteredModule(name, &fdp, buf, buflen);
1178 if (fp != NULL) {
1179 *p_fp = fp;
1180 return fdp;
1181 }
Guido van Rossuma5a3db71996-04-09 02:39:59 +00001182#endif
Guido van Rossuma5568d31998-03-05 03:45:08 +00001183 path = PySys_GetObject("path");
1184 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00001185 if (path == NULL || !PyList_Check(path)) {
1186 PyErr_SetString(PyExc_ImportError,
Guido van Rossuma5568d31998-03-05 03:45:08 +00001187 "sys.path must be a list of directory names");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001188 return NULL;
1189 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001190
1191 path_hooks = PySys_GetObject("path_hooks");
1192 if (path_hooks == NULL || !PyList_Check(path_hooks)) {
1193 PyErr_SetString(PyExc_ImportError,
1194 "sys.path_hooks must be a list of "
1195 "import hooks");
1196 return NULL;
1197 }
1198 path_importer_cache = PySys_GetObject("path_importer_cache");
1199 if (path_importer_cache == NULL ||
1200 !PyDict_Check(path_importer_cache)) {
1201 PyErr_SetString(PyExc_ImportError,
1202 "sys.path_importer_cache must be a dict");
1203 return NULL;
1204 }
1205
Guido van Rossum79f25d91997-04-29 20:08:16 +00001206 npath = PyList_Size(path);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001207 namelen = strlen(name);
1208 for (i = 0; i < npath; i++) {
Walter Dörwald3430d702002-06-17 10:43:59 +00001209 PyObject *copy = NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001210 PyObject *v = PyList_GetItem(path, i);
Walter Dörwald3430d702002-06-17 10:43:59 +00001211#ifdef Py_USING_UNICODE
1212 if (PyUnicode_Check(v)) {
1213 copy = PyUnicode_Encode(PyUnicode_AS_UNICODE(v),
1214 PyUnicode_GET_SIZE(v), Py_FileSystemDefaultEncoding, NULL);
1215 if (copy == NULL)
1216 return NULL;
1217 v = copy;
1218 }
1219 else
1220#endif
Guido van Rossum79f25d91997-04-29 20:08:16 +00001221 if (!PyString_Check(v))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001222 continue;
Neal Norwitz2aa9a5d2006-03-20 01:53:23 +00001223 len = PyString_GET_SIZE(v);
Walter Dörwald3430d702002-06-17 10:43:59 +00001224 if (len + 2 + namelen + MAXSUFFIXSIZE >= buflen) {
1225 Py_XDECREF(copy);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001226 continue; /* Too long */
Walter Dörwald3430d702002-06-17 10:43:59 +00001227 }
Neal Norwitz2aa9a5d2006-03-20 01:53:23 +00001228 strcpy(buf, PyString_AS_STRING(v));
Walter Dörwald3430d702002-06-17 10:43:59 +00001229 if (strlen(buf) != len) {
1230 Py_XDECREF(copy);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001231 continue; /* v contains '\0' */
Walter Dörwald3430d702002-06-17 10:43:59 +00001232 }
Just van Rossum52e14d62002-12-30 22:08:05 +00001233
1234 /* sys.path_hooks import hook */
1235 if (p_loader != NULL) {
1236 PyObject *importer;
1237
1238 importer = get_path_importer(path_importer_cache,
1239 path_hooks, v);
1240 if (importer == NULL)
1241 return NULL;
1242 /* Note: importer is a borrowed reference */
1243 if (importer != Py_None) {
1244 PyObject *loader;
1245 loader = PyObject_CallMethod(importer,
1246 "find_module",
1247 "s", fullname);
1248 if (loader == NULL)
1249 return NULL; /* error */
1250 if (loader != Py_None) {
1251 /* a loader was found */
1252 *p_loader = loader;
1253 return &importhookdescr;
1254 }
1255 Py_DECREF(loader);
1256 }
1257 /* no hook was successful, use builtin import */
1258 }
1259
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001260 if (len > 0 && buf[len-1] != SEP
1261#ifdef ALTSEP
1262 && buf[len-1] != ALTSEP
1263#endif
1264 )
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001265 buf[len++] = SEP;
Guido van Rossum215c3402000-11-13 17:26:32 +00001266 strcpy(buf+len, name);
1267 len += namelen;
Tim Peters50d8d372001-02-28 05:34:27 +00001268
1269 /* Check for package import (buf holds a directory name,
1270 and there's an __init__ module in that directory */
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001271#ifdef HAVE_STAT
Walter Dörwald3430d702002-06-17 10:43:59 +00001272 if (stat(buf, &statbuf) == 0 && /* it exists */
1273 S_ISDIR(statbuf.st_mode) && /* it's a directory */
1274 find_init_module(buf) && /* it has __init__.py */
1275 case_ok(buf, len, namelen, name)) { /* and case matches */
1276 Py_XDECREF(copy);
Tim Peterscab3f682001-04-29 22:21:25 +00001277 return &fd_package;
Walter Dörwald3430d702002-06-17 10:43:59 +00001278 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001279#else
1280 /* XXX How are you going to test for directories? */
Guido van Rossum48a680c2001-03-02 06:34:14 +00001281#ifdef RISCOS
Guido van Rossume2ae77b2001-10-24 20:42:55 +00001282 if (isdir(buf) &&
1283 find_init_module(buf) &&
Walter Dörwald3430d702002-06-17 10:43:59 +00001284 case_ok(buf, len, namelen, name)) {
1285 Py_XDECREF(copy);
Guido van Rossume2ae77b2001-10-24 20:42:55 +00001286 return &fd_package;
Walter Dörwald3430d702002-06-17 10:43:59 +00001287 }
Guido van Rossum48a680c2001-03-02 06:34:14 +00001288#endif
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001289#endif
Andrew MacIntyred9400542002-02-26 11:41:34 +00001290#if defined(PYOS_OS2)
1291 /* take a snapshot of the module spec for restoration
1292 * after the 8 character DLL hackery
1293 */
1294 saved_buf = strdup(buf);
1295 saved_len = len;
1296 saved_namelen = namelen;
1297#endif /* PYOS_OS2 */
Guido van Rossum79f25d91997-04-29 20:08:16 +00001298 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
Andrew MacIntyred9400542002-02-26 11:41:34 +00001299#if defined(PYOS_OS2)
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00001300 /* OS/2 limits DLLs to 8 character names (w/o
1301 extension)
Andrew MacIntyred9400542002-02-26 11:41:34 +00001302 * so if the name is longer than that and its a
1303 * dynamically loaded module we're going to try,
1304 * truncate the name before trying
1305 */
Just van Rossum52e14d62002-12-30 22:08:05 +00001306 if (strlen(subname) > 8) {
Andrew MacIntyred9400542002-02-26 11:41:34 +00001307 /* is this an attempt to load a C extension? */
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00001308 const struct filedescr *scan;
1309 scan = _PyImport_DynLoadFiletab;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001310 while (scan->suffix != NULL) {
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00001311 if (!strcmp(scan->suffix, fdp->suffix))
Andrew MacIntyred9400542002-02-26 11:41:34 +00001312 break;
1313 else
1314 scan++;
1315 }
1316 if (scan->suffix != NULL) {
1317 /* yes, so truncate the name */
1318 namelen = 8;
Just van Rossum52e14d62002-12-30 22:08:05 +00001319 len -= strlen(subname) - namelen;
Andrew MacIntyred9400542002-02-26 11:41:34 +00001320 buf[len] = '\0';
1321 }
1322 }
1323#endif /* PYOS_OS2 */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001324 strcpy(buf+len, fdp->suffix);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001325 if (Py_VerboseFlag > 1)
Guido van Rossum2f3667a1998-10-12 18:23:55 +00001326 PySys_WriteStderr("# trying %s\n", buf);
Jack Jansenc88da1f2002-05-28 10:58:19 +00001327 filemode = fdp->mode;
Tim Peters86c7d2f2004-08-01 23:24:21 +00001328 if (filemode[0] == 'U')
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00001329 filemode = "r" PY_STDIOTEXTMODE;
Jack Jansenc88da1f2002-05-28 10:58:19 +00001330 fp = fopen(buf, filemode);
Tim Peters50d8d372001-02-28 05:34:27 +00001331 if (fp != NULL) {
1332 if (case_ok(buf, len, namelen, name))
1333 break;
1334 else { /* continue search */
1335 fclose(fp);
1336 fp = NULL;
Barry Warsaw914a0b12001-02-02 19:12:16 +00001337 }
Barry Warsaw914a0b12001-02-02 19:12:16 +00001338 }
Andrew MacIntyred9400542002-02-26 11:41:34 +00001339#if defined(PYOS_OS2)
1340 /* restore the saved snapshot */
1341 strcpy(buf, saved_buf);
1342 len = saved_len;
1343 namelen = saved_namelen;
1344#endif
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001345 }
Andrew MacIntyred9400542002-02-26 11:41:34 +00001346#if defined(PYOS_OS2)
1347 /* don't need/want the module name snapshot anymore */
1348 if (saved_buf)
1349 {
1350 free(saved_buf);
1351 saved_buf = NULL;
1352 }
1353#endif
Walter Dörwald3430d702002-06-17 10:43:59 +00001354 Py_XDECREF(copy);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001355 if (fp != NULL)
1356 break;
1357 }
1358 if (fp == NULL) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001359 PyErr_Format(PyExc_ImportError,
1360 "No module named %.200s", name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001361 return NULL;
1362 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001363 *p_fp = fp;
1364 return fdp;
1365}
1366
Raymond Hettingerdb29e0f2004-10-07 06:46:25 +00001367/* Helpers for main.c
1368 * Find the source file corresponding to a named module
1369 */
1370struct filedescr *
1371_PyImport_FindModule(const char *name, PyObject *path, char *buf,
1372 size_t buflen, FILE **p_fp, PyObject **p_loader)
1373{
1374 return find_module((char *) name, (char *) name, path,
1375 buf, buflen, p_fp, p_loader);
1376}
1377
1378PyAPI_FUNC(int) _PyImport_IsScript(struct filedescr * fd)
1379{
1380 return fd->type == PY_SOURCE || fd->type == PY_COMPILED;
1381}
1382
Martin v. Löwis18e16552006-02-15 17:27:45 +00001383/* case_ok(char* buf, Py_ssize_t len, Py_ssize_t namelen, char* name)
Tim Petersd1e87a82001-03-01 18:12:00 +00001384 * The arguments here are tricky, best shown by example:
1385 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1386 * ^ ^ ^ ^
1387 * |--------------------- buf ---------------------|
1388 * |------------------- len ------------------|
1389 * |------ name -------|
1390 * |----- namelen -----|
1391 * buf is the full path, but len only counts up to (& exclusive of) the
1392 * extension. name is the module name, also exclusive of extension.
1393 *
1394 * We've already done a successful stat() or fopen() on buf, so know that
1395 * there's some match, possibly case-insensitive.
1396 *
Tim Peters50d8d372001-02-28 05:34:27 +00001397 * case_ok() is to return 1 if there's a case-sensitive match for
1398 * name, else 0. case_ok() is also to return 1 if envar PYTHONCASEOK
1399 * exists.
Tim Petersd1e87a82001-03-01 18:12:00 +00001400 *
Tim Peters50d8d372001-02-28 05:34:27 +00001401 * case_ok() is used to implement case-sensitive import semantics even
1402 * on platforms with case-insensitive filesystems. It's trivial to implement
1403 * for case-sensitive filesystems. It's pretty much a cross-platform
1404 * nightmare for systems with case-insensitive filesystems.
1405 */
Guido van Rossum0980bd91998-02-13 17:18:36 +00001406
Tim Peters50d8d372001-02-28 05:34:27 +00001407/* First we may need a pile of platform-specific header files; the sequence
1408 * of #if's here should match the sequence in the body of case_ok().
1409 */
Jason Tishler7961aa62005-05-20 00:56:54 +00001410#if defined(MS_WINDOWS)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001411#include <windows.h>
Guido van Rossum4c3f57c2001-01-10 20:40:46 +00001412
Tim Peters50d8d372001-02-28 05:34:27 +00001413#elif defined(DJGPP)
1414#include <dir.h>
1415
Jason Tishler7961aa62005-05-20 00:56:54 +00001416#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
Tim Peters430f5d42001-03-01 01:30:56 +00001417#include <sys/types.h>
1418#include <dirent.h>
1419
Andrew MacIntyred9400542002-02-26 11:41:34 +00001420#elif defined(PYOS_OS2)
1421#define INCL_DOS
1422#define INCL_DOSERRORS
1423#define INCL_NOPMAPI
1424#include <os2.h>
1425
Guido van Rossume2ae77b2001-10-24 20:42:55 +00001426#elif defined(RISCOS)
1427#include "oslib/osfscontrol.h"
Tim Peters50d8d372001-02-28 05:34:27 +00001428#endif
1429
Guido van Rossum0980bd91998-02-13 17:18:36 +00001430static int
Martin v. Löwis18e16552006-02-15 17:27:45 +00001431case_ok(char *buf, Py_ssize_t len, Py_ssize_t namelen, char *name)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001432{
Tim Peters50d8d372001-02-28 05:34:27 +00001433/* Pick a platform-specific implementation; the sequence of #if's here should
1434 * match the sequence just above.
1435 */
1436
Jason Tishler7961aa62005-05-20 00:56:54 +00001437/* MS_WINDOWS */
1438#if defined(MS_WINDOWS)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001439 WIN32_FIND_DATA data;
1440 HANDLE h;
Tim Peters50d8d372001-02-28 05:34:27 +00001441
Neil Schemenauer7d4bb9f2001-07-23 16:30:27 +00001442 if (Py_GETENV("PYTHONCASEOK") != NULL)
Guido van Rossum0980bd91998-02-13 17:18:36 +00001443 return 1;
Tim Peters50d8d372001-02-28 05:34:27 +00001444
Guido van Rossum0980bd91998-02-13 17:18:36 +00001445 h = FindFirstFile(buf, &data);
1446 if (h == INVALID_HANDLE_VALUE) {
1447 PyErr_Format(PyExc_NameError,
1448 "Can't find file for module %.100s\n(filename %.300s)",
1449 name, buf);
1450 return 0;
1451 }
1452 FindClose(h);
Tim Peters50d8d372001-02-28 05:34:27 +00001453 return strncmp(data.cFileName, name, namelen) == 0;
1454
1455/* DJGPP */
1456#elif defined(DJGPP)
1457 struct ffblk ffblk;
1458 int done;
1459
Neil Schemenauer7d4bb9f2001-07-23 16:30:27 +00001460 if (Py_GETENV("PYTHONCASEOK") != NULL)
Guido van Rossum323bf5e1998-06-24 03:54:06 +00001461 return 1;
Tim Peters50d8d372001-02-28 05:34:27 +00001462
1463 done = findfirst(buf, &ffblk, FA_ARCH|FA_RDONLY|FA_HIDDEN|FA_DIREC);
1464 if (done) {
Guido van Rossum0980bd91998-02-13 17:18:36 +00001465 PyErr_Format(PyExc_NameError,
Tim Peters50d8d372001-02-28 05:34:27 +00001466 "Can't find file for module %.100s\n(filename %.300s)",
Guido van Rossum0980bd91998-02-13 17:18:36 +00001467 name, buf);
1468 return 0;
1469 }
Tim Peters50d8d372001-02-28 05:34:27 +00001470 return strncmp(ffblk.ff_name, name, namelen) == 0;
Guido van Rossum0980bd91998-02-13 17:18:36 +00001471
Jason Tishler7961aa62005-05-20 00:56:54 +00001472/* new-fangled macintosh (macosx) or Cygwin */
1473#elif (defined(__MACH__) && defined(__APPLE__) || defined(__CYGWIN__)) && defined(HAVE_DIRENT_H)
Tim Peters430f5d42001-03-01 01:30:56 +00001474 DIR *dirp;
1475 struct dirent *dp;
Tim Petersd1e87a82001-03-01 18:12:00 +00001476 char dirname[MAXPATHLEN + 1];
1477 const int dirlen = len - namelen - 1; /* don't want trailing SEP */
Tim Peters430f5d42001-03-01 01:30:56 +00001478
Neil Schemenauer7d4bb9f2001-07-23 16:30:27 +00001479 if (Py_GETENV("PYTHONCASEOK") != NULL)
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001480 return 1;
1481
Tim Petersd1e87a82001-03-01 18:12:00 +00001482 /* Copy the dir component into dirname; substitute "." if empty */
1483 if (dirlen <= 0) {
1484 dirname[0] = '.';
1485 dirname[1] = '\0';
Tim Peters430f5d42001-03-01 01:30:56 +00001486 }
1487 else {
Tim Petersd1e87a82001-03-01 18:12:00 +00001488 assert(dirlen <= MAXPATHLEN);
1489 memcpy(dirname, buf, dirlen);
1490 dirname[dirlen] = '\0';
Tim Peters430f5d42001-03-01 01:30:56 +00001491 }
1492 /* Open the directory and search the entries for an exact match. */
Tim Petersd1e87a82001-03-01 18:12:00 +00001493 dirp = opendir(dirname);
Tim Peters430f5d42001-03-01 01:30:56 +00001494 if (dirp) {
Tim Peters677898a2001-03-02 03:28:03 +00001495 char *nameWithExt = buf + len - namelen;
Tim Peters430f5d42001-03-01 01:30:56 +00001496 while ((dp = readdir(dirp)) != NULL) {
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001497 const int thislen =
Tim Peters430f5d42001-03-01 01:30:56 +00001498#ifdef _DIRENT_HAVE_D_NAMELEN
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001499 dp->d_namlen;
Tim Peters430f5d42001-03-01 01:30:56 +00001500#else
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001501 strlen(dp->d_name);
Tim Peters430f5d42001-03-01 01:30:56 +00001502#endif
Tim Petersd1e87a82001-03-01 18:12:00 +00001503 if (thislen >= namelen &&
Tim Peters677898a2001-03-02 03:28:03 +00001504 strcmp(dp->d_name, nameWithExt) == 0) {
Tim Peters430f5d42001-03-01 01:30:56 +00001505 (void)closedir(dirp);
1506 return 1; /* Found */
1507 }
1508 }
Tim Petersdbe6ebb2001-03-01 08:47:29 +00001509 (void)closedir(dirp);
Tim Peters430f5d42001-03-01 01:30:56 +00001510 }
Tim Peters430f5d42001-03-01 01:30:56 +00001511 return 0 ; /* Not found */
Tim Peters430f5d42001-03-01 01:30:56 +00001512
Guido van Rossume2ae77b2001-10-24 20:42:55 +00001513/* RISC OS */
1514#elif defined(RISCOS)
1515 char canon[MAXPATHLEN+1]; /* buffer for the canonical form of the path */
1516 char buf2[MAXPATHLEN+2];
1517 char *nameWithExt = buf+len-namelen;
1518 int canonlen;
1519 os_error *e;
1520
1521 if (Py_GETENV("PYTHONCASEOK") != NULL)
1522 return 1;
1523
1524 /* workaround:
1525 append wildcard, otherwise case of filename wouldn't be touched */
1526 strcpy(buf2, buf);
1527 strcat(buf2, "*");
1528
1529 e = xosfscontrol_canonicalise_path(buf2,canon,0,0,MAXPATHLEN+1,&canonlen);
1530 canonlen = MAXPATHLEN+1-canonlen;
1531 if (e || canonlen<=0 || canonlen>(MAXPATHLEN+1) )
1532 return 0;
1533 if (strcmp(nameWithExt, canon+canonlen-strlen(nameWithExt))==0)
1534 return 1; /* match */
1535
1536 return 0;
1537
Andrew MacIntyred9400542002-02-26 11:41:34 +00001538/* OS/2 */
1539#elif defined(PYOS_OS2)
1540 HDIR hdir = 1;
1541 ULONG srchcnt = 1;
1542 FILEFINDBUF3 ffbuf;
1543 APIRET rc;
1544
1545 if (getenv("PYTHONCASEOK") != NULL)
1546 return 1;
1547
1548 rc = DosFindFirst(buf,
1549 &hdir,
1550 FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,
1551 &ffbuf, sizeof(ffbuf),
1552 &srchcnt,
1553 FIL_STANDARD);
1554 if (rc != NO_ERROR)
1555 return 0;
1556 return strncmp(ffbuf.achName, name, namelen) == 0;
1557
Tim Peters50d8d372001-02-28 05:34:27 +00001558/* assuming it's a case-sensitive filesystem, so there's nothing to do! */
1559#else
Guido van Rossum0980bd91998-02-13 17:18:36 +00001560 return 1;
Guido van Rossum0980bd91998-02-13 17:18:36 +00001561
Guido van Rossum4d1b3b91998-02-13 23:27:59 +00001562#endif
Tim Peters50d8d372001-02-28 05:34:27 +00001563}
Guido van Rossum4d1b3b91998-02-13 23:27:59 +00001564
Guido van Rossum0980bd91998-02-13 17:18:36 +00001565
Guido van Rossum197346f1997-10-31 18:38:52 +00001566#ifdef HAVE_STAT
1567/* Helper to look for __init__.py or __init__.py[co] in potential package */
1568static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001569find_init_module(char *buf)
Guido van Rossum197346f1997-10-31 18:38:52 +00001570{
Tim Peters0f9431f2001-07-05 03:47:53 +00001571 const size_t save_len = strlen(buf);
Fred Drake4c82b232000-06-30 16:18:57 +00001572 size_t i = save_len;
Tim Peters0f9431f2001-07-05 03:47:53 +00001573 char *pname; /* pointer to start of __init__ */
Guido van Rossum197346f1997-10-31 18:38:52 +00001574 struct stat statbuf;
1575
Tim Peters0f9431f2001-07-05 03:47:53 +00001576/* For calling case_ok(buf, len, namelen, name):
1577 * /a/b/c/d/e/f/g/h/i/j/k/some_long_module_name.py\0
1578 * ^ ^ ^ ^
1579 * |--------------------- buf ---------------------|
1580 * |------------------- len ------------------|
1581 * |------ name -------|
1582 * |----- namelen -----|
1583 */
Guido van Rossum197346f1997-10-31 18:38:52 +00001584 if (save_len + 13 >= MAXPATHLEN)
1585 return 0;
1586 buf[i++] = SEP;
Tim Peters0f9431f2001-07-05 03:47:53 +00001587 pname = buf + i;
1588 strcpy(pname, "__init__.py");
Guido van Rossum197346f1997-10-31 18:38:52 +00001589 if (stat(buf, &statbuf) == 0) {
Tim Peters0f9431f2001-07-05 03:47:53 +00001590 if (case_ok(buf,
1591 save_len + 9, /* len("/__init__") */
1592 8, /* len("__init__") */
1593 pname)) {
1594 buf[save_len] = '\0';
1595 return 1;
1596 }
Guido van Rossum197346f1997-10-31 18:38:52 +00001597 }
Tim Peters0f9431f2001-07-05 03:47:53 +00001598 i += strlen(pname);
1599 strcpy(buf+i, Py_OptimizeFlag ? "o" : "c");
Guido van Rossum197346f1997-10-31 18:38:52 +00001600 if (stat(buf, &statbuf) == 0) {
Tim Peters0f9431f2001-07-05 03:47:53 +00001601 if (case_ok(buf,
1602 save_len + 9, /* len("/__init__") */
1603 8, /* len("__init__") */
1604 pname)) {
1605 buf[save_len] = '\0';
1606 return 1;
1607 }
Guido van Rossum197346f1997-10-31 18:38:52 +00001608 }
1609 buf[save_len] = '\0';
1610 return 0;
1611}
Guido van Rossum48a680c2001-03-02 06:34:14 +00001612
1613#else
1614
1615#ifdef RISCOS
1616static int
1617find_init_module(buf)
1618 char *buf;
1619{
1620 int save_len = strlen(buf);
1621 int i = save_len;
1622
1623 if (save_len + 13 >= MAXPATHLEN)
1624 return 0;
1625 buf[i++] = SEP;
1626 strcpy(buf+i, "__init__/py");
1627 if (isfile(buf)) {
1628 buf[save_len] = '\0';
1629 return 1;
1630 }
1631
1632 if (Py_OptimizeFlag)
1633 strcpy(buf+i, "o");
1634 else
1635 strcpy(buf+i, "c");
1636 if (isfile(buf)) {
1637 buf[save_len] = '\0';
1638 return 1;
1639 }
1640 buf[save_len] = '\0';
1641 return 0;
1642}
1643#endif /*RISCOS*/
1644
Guido van Rossum197346f1997-10-31 18:38:52 +00001645#endif /* HAVE_STAT */
1646
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001647
Tim Petersdbd9ba62000-07-09 03:09:57 +00001648static int init_builtin(char *); /* Forward */
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001649
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001650/* Load an external module using the default search path and return
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001651 its module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001652
Guido van Rossum79f25d91997-04-29 20:08:16 +00001653static PyObject *
Just van Rossum52e14d62002-12-30 22:08:05 +00001654load_module(char *name, FILE *fp, char *buf, int type, PyObject *loader)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001655{
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001656 PyObject *modules;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001657 PyObject *m;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001658 int err;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001659
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001660 /* First check that there's an open file (if we need one) */
1661 switch (type) {
1662 case PY_SOURCE:
1663 case PY_COMPILED:
1664 if (fp == NULL) {
1665 PyErr_Format(PyExc_ValueError,
1666 "file object required for import (type code %d)",
1667 type);
1668 return NULL;
1669 }
1670 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001671
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001672 switch (type) {
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001673
1674 case PY_SOURCE:
1675 m = load_source_module(name, buf, fp);
1676 break;
1677
1678 case PY_COMPILED:
1679 m = load_compiled_module(name, buf, fp);
1680 break;
1681
Guido van Rossum96a8fb71999-12-22 14:09:35 +00001682#ifdef HAVE_DYNAMIC_LOADING
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001683 case C_EXTENSION:
Guido van Rossum79f25d91997-04-29 20:08:16 +00001684 m = _PyImport_LoadDynamicModule(name, buf, fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001685 break;
Guido van Rossum96a8fb71999-12-22 14:09:35 +00001686#endif
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001687
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001688 case PKG_DIRECTORY:
1689 m = load_package(name, buf);
1690 break;
1691
1692 case C_BUILTIN:
1693 case PY_FROZEN:
Guido van Rossuma5568d31998-03-05 03:45:08 +00001694 if (buf != NULL && buf[0] != '\0')
1695 name = buf;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001696 if (type == C_BUILTIN)
1697 err = init_builtin(name);
1698 else
1699 err = PyImport_ImportFrozenModule(name);
1700 if (err < 0)
Guido van Rossuma86f77d1997-09-09 18:53:47 +00001701 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001702 if (err == 0) {
1703 PyErr_Format(PyExc_ImportError,
1704 "Purported %s module %.200s not found",
1705 type == C_BUILTIN ?
1706 "builtin" : "frozen",
1707 name);
Guido van Rossuma86f77d1997-09-09 18:53:47 +00001708 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001709 }
1710 modules = PyImport_GetModuleDict();
1711 m = PyDict_GetItemString(modules, name);
1712 if (m == NULL) {
1713 PyErr_Format(
1714 PyExc_ImportError,
1715 "%s module %.200s not properly initialized",
1716 type == C_BUILTIN ?
1717 "builtin" : "frozen",
1718 name);
Guido van Rossuma86f77d1997-09-09 18:53:47 +00001719 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001720 }
1721 Py_INCREF(m);
1722 break;
1723
Just van Rossum52e14d62002-12-30 22:08:05 +00001724 case IMP_HOOK: {
1725 if (loader == NULL) {
1726 PyErr_SetString(PyExc_ImportError,
1727 "import hook without loader");
1728 return NULL;
1729 }
1730 m = PyObject_CallMethod(loader, "load_module", "s", name);
1731 break;
1732 }
1733
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001734 default:
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001735 PyErr_Format(PyExc_ImportError,
1736 "Don't know how to import %.200s (type code %d)",
1737 name, type);
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001738 m = NULL;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001739
1740 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001741
1742 return m;
1743}
1744
1745
1746/* Initialize a built-in module.
1747 Return 1 for succes, 0 if the module is not found, and -1 with
1748 an exception set if the initialization failed. */
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001749
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001750static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001751init_builtin(char *name)
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001752{
Guido van Rossum25ce5661997-08-02 03:10:38 +00001753 struct _inittab *p;
Guido van Rossum25ce5661997-08-02 03:10:38 +00001754
Greg Ward201baee2001-10-04 14:52:06 +00001755 if (_PyImport_FindExtension(name, name) != NULL)
Guido van Rossum25ce5661997-08-02 03:10:38 +00001756 return 1;
1757
Guido van Rossum771c6c81997-10-31 18:37:24 +00001758 for (p = PyImport_Inittab; p->name != NULL; p++) {
Guido van Rossum25ce5661997-08-02 03:10:38 +00001759 if (strcmp(name, p->name) == 0) {
1760 if (p->initfunc == NULL) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001761 PyErr_Format(PyExc_ImportError,
1762 "Cannot re-init internal module %.200s",
1763 name);
Guido van Rossum74e6a111994-08-29 12:54:38 +00001764 return -1;
1765 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00001766 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +00001767 PySys_WriteStderr("import %s # builtin\n", name);
Guido van Rossum25ce5661997-08-02 03:10:38 +00001768 (*p->initfunc)();
Guido van Rossum79f25d91997-04-29 20:08:16 +00001769 if (PyErr_Occurred())
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001770 return -1;
Guido van Rossum25ce5661997-08-02 03:10:38 +00001771 if (_PyImport_FixupExtension(name, name) == NULL)
1772 return -1;
Guido van Rossum7f133ed1991-02-19 12:23:57 +00001773 return 1;
1774 }
1775 }
1776 return 0;
1777}
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001778
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001779
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001780/* Frozen modules */
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001781
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001782static struct _frozen *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001783find_frozen(char *name)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001784{
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001785 struct _frozen *p;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001786
Guido van Rossum79f25d91997-04-29 20:08:16 +00001787 for (p = PyImport_FrozenModules; ; p++) {
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001788 if (p->name == NULL)
1789 return NULL;
1790 if (strcmp(p->name, name) == 0)
1791 break;
1792 }
1793 return p;
1794}
1795
Guido van Rossum79f25d91997-04-29 20:08:16 +00001796static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001797get_frozen_object(char *name)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001798{
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001799 struct _frozen *p = find_frozen(name);
Guido van Rossuma5568d31998-03-05 03:45:08 +00001800 int size;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001801
1802 if (p == NULL) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001803 PyErr_Format(PyExc_ImportError,
1804 "No such frozen object named %.200s",
1805 name);
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001806 return NULL;
1807 }
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001808 if (p->code == NULL) {
1809 PyErr_Format(PyExc_ImportError,
1810 "Excluded frozen object named %.200s",
1811 name);
1812 return NULL;
1813 }
Guido van Rossuma5568d31998-03-05 03:45:08 +00001814 size = p->size;
1815 if (size < 0)
1816 size = -size;
1817 return PyMarshal_ReadObjectFromString((char *)p->code, size);
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001818}
1819
1820/* Initialize a frozen module.
1821 Return 1 for succes, 0 if the module is not found, and -1 with
1822 an exception set if the initialization failed.
1823 This function is also used from frozenmain.c */
Guido van Rossum0b344901995-02-07 15:35:27 +00001824
1825int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001826PyImport_ImportFrozenModule(char *name)
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001827{
Guido van Rossumcfd0a221996-06-17 17:06:34 +00001828 struct _frozen *p = find_frozen(name);
Guido van Rossum79f25d91997-04-29 20:08:16 +00001829 PyObject *co;
1830 PyObject *m;
Guido van Rossuma5568d31998-03-05 03:45:08 +00001831 int ispackage;
1832 int size;
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00001833
1834 if (p == NULL)
1835 return 0;
Guido van Rossum8f4d3312001-10-18 18:54:11 +00001836 if (p->code == NULL) {
1837 PyErr_Format(PyExc_ImportError,
1838 "Excluded frozen object named %.200s",
1839 name);
1840 return -1;
1841 }
Guido van Rossuma5568d31998-03-05 03:45:08 +00001842 size = p->size;
1843 ispackage = (size < 0);
1844 if (ispackage)
1845 size = -size;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001846 if (Py_VerboseFlag)
Guido van Rossum2f3667a1998-10-12 18:23:55 +00001847 PySys_WriteStderr("import %s # frozen%s\n",
Guido van Rossuma5568d31998-03-05 03:45:08 +00001848 name, ispackage ? " package" : "");
1849 co = PyMarshal_ReadObjectFromString((char *)p->code, size);
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001850 if (co == NULL)
1851 return -1;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001852 if (!PyCode_Check(co)) {
1853 Py_DECREF(co);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001854 PyErr_Format(PyExc_TypeError,
1855 "frozen object %.200s is not a code object",
1856 name);
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001857 return -1;
1858 }
Guido van Rossuma5568d31998-03-05 03:45:08 +00001859 if (ispackage) {
1860 /* Set __path__ to the package name */
1861 PyObject *d, *s;
1862 int err;
1863 m = PyImport_AddModule(name);
1864 if (m == NULL)
1865 return -1;
1866 d = PyModule_GetDict(m);
1867 s = PyString_InternFromString(name);
1868 if (s == NULL)
1869 return -1;
1870 err = PyDict_SetItemString(d, "__path__", s);
1871 Py_DECREF(s);
1872 if (err != 0)
1873 return err;
1874 }
Guido van Rossume32bf6e1998-02-11 05:53:02 +00001875 m = PyImport_ExecCodeModuleEx(name, co, "<frozen>");
Guido van Rossum79f25d91997-04-29 20:08:16 +00001876 Py_DECREF(co);
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001877 if (m == NULL)
1878 return -1;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001879 Py_DECREF(m);
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001880 return 1;
Guido van Rossumf56e3db1993-04-01 20:59:32 +00001881}
Guido van Rossum74e6a111994-08-29 12:54:38 +00001882
1883
Guido van Rossum1ae940a1995-01-02 19:04:15 +00001884/* Import a module, either built-in, frozen, or external, and return
Guido van Rossum7f9fa971995-01-20 16:53:12 +00001885 its module object WITH INCREMENTED REFERENCE COUNT */
Guido van Rossum74e6a111994-08-29 12:54:38 +00001886
Guido van Rossum79f25d91997-04-29 20:08:16 +00001887PyObject *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001888PyImport_ImportModule(const char *name)
Guido van Rossum74e6a111994-08-29 12:54:38 +00001889{
Marc-André Lemburg3c61c352001-02-09 19:40:15 +00001890 PyObject *pname;
1891 PyObject *result;
1892
1893 pname = PyString_FromString(name);
Neal Norwitza11e4c12003-03-23 14:31:01 +00001894 if (pname == NULL)
1895 return NULL;
Marc-André Lemburg3c61c352001-02-09 19:40:15 +00001896 result = PyImport_Import(pname);
1897 Py_DECREF(pname);
1898 return result;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001899}
1900
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001901/* Forward declarations for helper routines */
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001902static PyObject *get_parent(PyObject *globals, char *buf,
1903 Py_ssize_t *p_buflen, int level);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001904static PyObject *load_next(PyObject *mod, PyObject *altmod,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001905 char **p_name, char *buf, Py_ssize_t *p_buflen);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001906static int mark_miss(char *name);
1907static int ensure_fromlist(PyObject *mod, PyObject *fromlist,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001908 char *buf, Py_ssize_t buflen, int recursive);
Tim Petersdbd9ba62000-07-09 03:09:57 +00001909static PyObject * import_submodule(PyObject *mod, char *name, char *fullname);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001910
1911/* The Magnum Opus of dotted-name import :-) */
1912
Guido van Rossum75acc9c1998-03-03 22:26:50 +00001913static PyObject *
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001914import_module_level(char *name, PyObject *globals, PyObject *locals,
1915 PyObject *fromlist, int level)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00001916{
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001917 char buf[MAXPATHLEN+1];
Martin v. Löwis18e16552006-02-15 17:27:45 +00001918 Py_ssize_t buflen = 0;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001919 PyObject *parent, *head, *next, *tail;
1920
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001921 parent = get_parent(globals, buf, &buflen, level);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001922 if (parent == NULL)
1923 return NULL;
1924
1925 head = load_next(parent, Py_None, &name, buf, &buflen);
1926 if (head == NULL)
1927 return NULL;
1928
1929 tail = head;
1930 Py_INCREF(tail);
1931 while (name) {
1932 next = load_next(tail, tail, &name, buf, &buflen);
1933 Py_DECREF(tail);
1934 if (next == NULL) {
1935 Py_DECREF(head);
1936 return NULL;
1937 }
1938 tail = next;
1939 }
Thomas Wouters8ddab272006-04-04 16:17:02 +00001940 if (tail == Py_None) {
1941 /* If tail is Py_None, both get_parent and load_next found
1942 an empty module name: someone called __import__("") or
1943 doctored faulty bytecode */
Thomas Wouters4bdaa272006-04-05 13:39:37 +00001944 Py_DECREF(tail);
1945 Py_DECREF(head);
Thomas Wouters8ddab272006-04-04 16:17:02 +00001946 PyErr_SetString(PyExc_ValueError,
1947 "Empty module name");
1948 return NULL;
1949 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001950
1951 if (fromlist != NULL) {
1952 if (fromlist == Py_None || !PyObject_IsTrue(fromlist))
1953 fromlist = NULL;
1954 }
1955
1956 if (fromlist == NULL) {
1957 Py_DECREF(tail);
1958 return head;
1959 }
1960
1961 Py_DECREF(head);
Guido van Rossum9905ef91997-09-08 16:07:11 +00001962 if (!ensure_fromlist(tail, fromlist, buf, buflen, 0)) {
Guido van Rossum17fc85f1997-09-06 18:52:03 +00001963 Py_DECREF(tail);
1964 return NULL;
1965 }
1966
1967 return tail;
1968}
1969
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001970/* For DLL compatibility */
1971#undef PyImport_ImportModuleEx
Guido van Rossum75acc9c1998-03-03 22:26:50 +00001972PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00001973PyImport_ImportModuleEx(char *name, PyObject *globals, PyObject *locals,
1974 PyObject *fromlist)
Guido van Rossum75acc9c1998-03-03 22:26:50 +00001975{
1976 PyObject *result;
1977 lock_import();
Thomas Woutersf7f438b2006-02-28 16:09:29 +00001978 result = import_module_level(name, globals, locals, fromlist, -1);
1979 if (unlock_import() < 0) {
1980 Py_XDECREF(result);
1981 PyErr_SetString(PyExc_RuntimeError,
1982 "not holding the import lock");
1983 return NULL;
1984 }
1985 return result;
1986}
1987#define PyImport_ImportModuleEx(n, g, l, f) \
1988 PyImport_ImportModuleLevel(n, g, l, f, -1);
1989
1990PyObject *
1991PyImport_ImportModuleLevel(char *name, PyObject *globals, PyObject *locals,
1992 PyObject *fromlist, int level)
1993{
1994 PyObject *result;
1995 lock_import();
1996 result = import_module_level(name, globals, locals, fromlist, level);
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00001997 if (unlock_import() < 0) {
1998 Py_XDECREF(result);
1999 PyErr_SetString(PyExc_RuntimeError,
2000 "not holding the import lock");
2001 return NULL;
2002 }
Guido van Rossum75acc9c1998-03-03 22:26:50 +00002003 return result;
2004}
2005
Fred Drake87590902004-05-28 20:21:36 +00002006/* Return the package that an import is being performed in. If globals comes
2007 from the module foo.bar.bat (not itself a package), this returns the
2008 sys.modules entry for foo.bar. If globals is from a package's __init__.py,
2009 the package's entry in sys.modules is returned.
2010
2011 The *name* of the returned package is returned in buf, with the length of
2012 the name in *p_buflen.
2013
2014 If globals doesn't come from a package or a module in a package, or a
2015 corresponding entry is not found in sys.modules, Py_None is returned.
2016*/
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002017static PyObject *
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002018get_parent(PyObject *globals, char *buf, Py_ssize_t *p_buflen, int level)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002019{
2020 static PyObject *namestr = NULL;
2021 static PyObject *pathstr = NULL;
2022 PyObject *modname, *modpath, *modules, *parent;
2023
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002024 if (globals == NULL || !PyDict_Check(globals) || !level)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002025 return Py_None;
2026
2027 if (namestr == NULL) {
2028 namestr = PyString_InternFromString("__name__");
2029 if (namestr == NULL)
2030 return NULL;
2031 }
2032 if (pathstr == NULL) {
2033 pathstr = PyString_InternFromString("__path__");
2034 if (pathstr == NULL)
2035 return NULL;
2036 }
2037
2038 *buf = '\0';
2039 *p_buflen = 0;
2040 modname = PyDict_GetItem(globals, namestr);
2041 if (modname == NULL || !PyString_Check(modname))
2042 return Py_None;
2043
2044 modpath = PyDict_GetItem(globals, pathstr);
2045 if (modpath != NULL) {
Martin v. Löwis725507b2006-03-07 12:08:51 +00002046 Py_ssize_t len = PyString_GET_SIZE(modname);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002047 if (len > MAXPATHLEN) {
2048 PyErr_SetString(PyExc_ValueError,
2049 "Module name too long");
2050 return NULL;
2051 }
2052 strcpy(buf, PyString_AS_STRING(modname));
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002053 }
2054 else {
2055 char *start = PyString_AS_STRING(modname);
2056 char *lastdot = strrchr(start, '.');
Fred Drake4c82b232000-06-30 16:18:57 +00002057 size_t len;
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002058 if (lastdot == NULL && level > 0) {
2059 PyErr_SetString(PyExc_ValueError,
2060 "Relative importpath too deep");
2061 return NULL;
2062 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002063 if (lastdot == NULL)
2064 return Py_None;
2065 len = lastdot - start;
2066 if (len >= MAXPATHLEN) {
2067 PyErr_SetString(PyExc_ValueError,
2068 "Module name too long");
2069 return NULL;
2070 }
2071 strncpy(buf, start, len);
2072 buf[len] = '\0';
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002073 }
2074
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002075 while (--level > 0) {
2076 char *dot = strrchr(buf, '.');
2077 if (dot == NULL) {
2078 PyErr_SetString(PyExc_ValueError,
2079 "Relative importpath too deep");
2080 return NULL;
2081 }
2082 *dot = '\0';
2083 }
2084 *p_buflen = strlen(buf);
2085
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002086 modules = PyImport_GetModuleDict();
2087 parent = PyDict_GetItemString(modules, buf);
2088 if (parent == NULL)
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002089 PyErr_Format(PyExc_SystemError,
2090 "Parent module '%.200s' not loaded", buf);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002091 return parent;
2092 /* We expect, but can't guarantee, if parent != None, that:
2093 - parent.__name__ == buf
2094 - parent.__dict__ is globals
2095 If this is violated... Who cares? */
2096}
2097
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002098/* altmod is either None or same as mod */
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002099static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002100load_next(PyObject *mod, PyObject *altmod, char **p_name, char *buf,
Martin v. Löwis18e16552006-02-15 17:27:45 +00002101 Py_ssize_t *p_buflen)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002102{
2103 char *name = *p_name;
2104 char *dot = strchr(name, '.');
Fred Drake4c82b232000-06-30 16:18:57 +00002105 size_t len;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002106 char *p;
2107 PyObject *result;
2108
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002109 if (strlen(name) == 0) {
Thomas Wouters8ddab272006-04-04 16:17:02 +00002110 /* completely empty module name should only happen in
2111 'from . import' (or '__import__("")')*/
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002112 Py_INCREF(mod);
2113 *p_name = NULL;
2114 return mod;
2115 }
2116
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002117 if (dot == NULL) {
2118 *p_name = NULL;
2119 len = strlen(name);
2120 }
2121 else {
2122 *p_name = dot+1;
2123 len = dot-name;
2124 }
Guido van Rossum111c20b1998-04-11 17:38:22 +00002125 if (len == 0) {
2126 PyErr_SetString(PyExc_ValueError,
2127 "Empty module name");
2128 return NULL;
2129 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002130
2131 p = buf + *p_buflen;
2132 if (p != buf)
2133 *p++ = '.';
2134 if (p+len-buf >= MAXPATHLEN) {
2135 PyErr_SetString(PyExc_ValueError,
2136 "Module name too long");
2137 return NULL;
2138 }
2139 strncpy(p, name, len);
2140 p[len] = '\0';
2141 *p_buflen = p+len-buf;
2142
2143 result = import_submodule(mod, p, buf);
2144 if (result == Py_None && altmod != mod) {
2145 Py_DECREF(result);
Guido van Rossumf5f5fdb1997-09-06 20:29:52 +00002146 /* Here, altmod must be None and mod must not be None */
Guido van Rossum0c819451997-09-07 06:16:57 +00002147 result = import_submodule(altmod, p, p);
Guido van Rossumf5f5fdb1997-09-06 20:29:52 +00002148 if (result != NULL && result != Py_None) {
2149 if (mark_miss(buf) != 0) {
2150 Py_DECREF(result);
2151 return NULL;
2152 }
2153 strncpy(buf, name, len);
2154 buf[len] = '\0';
2155 *p_buflen = len;
2156 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002157 }
2158 if (result == NULL)
2159 return NULL;
2160
2161 if (result == Py_None) {
2162 Py_DECREF(result);
2163 PyErr_Format(PyExc_ImportError,
2164 "No module named %.200s", name);
2165 return NULL;
2166 }
2167
2168 return result;
2169}
2170
2171static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002172mark_miss(char *name)
Guido van Rossumf5f5fdb1997-09-06 20:29:52 +00002173{
2174 PyObject *modules = PyImport_GetModuleDict();
2175 return PyDict_SetItemString(modules, name, Py_None);
2176}
2177
2178static int
Martin v. Löwis18e16552006-02-15 17:27:45 +00002179ensure_fromlist(PyObject *mod, PyObject *fromlist, char *buf, Py_ssize_t buflen,
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002180 int recursive)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002181{
2182 int i;
2183
2184 if (!PyObject_HasAttrString(mod, "__path__"))
2185 return 1;
2186
2187 for (i = 0; ; i++) {
2188 PyObject *item = PySequence_GetItem(fromlist, i);
2189 int hasit;
2190 if (item == NULL) {
2191 if (PyErr_ExceptionMatches(PyExc_IndexError)) {
2192 PyErr_Clear();
2193 return 1;
2194 }
2195 return 0;
2196 }
2197 if (!PyString_Check(item)) {
2198 PyErr_SetString(PyExc_TypeError,
2199 "Item in ``from list'' not a string");
2200 Py_DECREF(item);
2201 return 0;
2202 }
2203 if (PyString_AS_STRING(item)[0] == '*') {
Guido van Rossum9905ef91997-09-08 16:07:11 +00002204 PyObject *all;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002205 Py_DECREF(item);
Guido van Rossum9905ef91997-09-08 16:07:11 +00002206 /* See if the package defines __all__ */
2207 if (recursive)
2208 continue; /* Avoid endless recursion */
2209 all = PyObject_GetAttrString(mod, "__all__");
2210 if (all == NULL)
2211 PyErr_Clear();
2212 else {
Martin v. Löwis83969ee2004-03-23 16:28:13 +00002213 int ret = ensure_fromlist(mod, all, buf, buflen, 1);
Guido van Rossum9905ef91997-09-08 16:07:11 +00002214 Py_DECREF(all);
Martin v. Löwis83969ee2004-03-23 16:28:13 +00002215 if (!ret)
2216 return 0;
Guido van Rossum9905ef91997-09-08 16:07:11 +00002217 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002218 continue;
2219 }
2220 hasit = PyObject_HasAttr(mod, item);
2221 if (!hasit) {
2222 char *subname = PyString_AS_STRING(item);
2223 PyObject *submod;
2224 char *p;
2225 if (buflen + strlen(subname) >= MAXPATHLEN) {
2226 PyErr_SetString(PyExc_ValueError,
2227 "Module name too long");
2228 Py_DECREF(item);
2229 return 0;
2230 }
2231 p = buf + buflen;
2232 *p++ = '.';
2233 strcpy(p, subname);
2234 submod = import_submodule(mod, subname, buf);
2235 Py_XDECREF(submod);
2236 if (submod == NULL) {
2237 Py_DECREF(item);
2238 return 0;
2239 }
2240 }
2241 Py_DECREF(item);
2242 }
2243
Guido van Rossuma7f2e811997-10-03 15:33:32 +00002244 /* NOTREACHED */
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002245}
2246
Neil Schemenauer00b09662003-06-16 21:03:07 +00002247static int
2248add_submodule(PyObject *mod, PyObject *submod, char *fullname, char *subname,
2249 PyObject *modules)
2250{
2251 if (mod == Py_None)
2252 return 1;
2253 /* Irrespective of the success of this load, make a
2254 reference to it in the parent package module. A copy gets
2255 saved in the modules dictionary under the full name, so get a
2256 reference from there, if need be. (The exception is when the
2257 load failed with a SyntaxError -- then there's no trace in
2258 sys.modules. In that case, of course, do nothing extra.) */
2259 if (submod == NULL) {
2260 submod = PyDict_GetItemString(modules, fullname);
2261 if (submod == NULL)
2262 return 1;
2263 }
2264 if (PyModule_Check(mod)) {
2265 /* We can't use setattr here since it can give a
2266 * spurious warning if the submodule name shadows a
2267 * builtin name */
2268 PyObject *dict = PyModule_GetDict(mod);
2269 if (!dict)
2270 return 0;
2271 if (PyDict_SetItemString(dict, subname, submod) < 0)
2272 return 0;
2273 }
2274 else {
2275 if (PyObject_SetAttrString(mod, subname, submod) < 0)
2276 return 0;
2277 }
2278 return 1;
2279}
2280
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002281static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002282import_submodule(PyObject *mod, char *subname, char *fullname)
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002283{
Guido van Rossum25ce5661997-08-02 03:10:38 +00002284 PyObject *modules = PyImport_GetModuleDict();
Neil Schemenauer00b09662003-06-16 21:03:07 +00002285 PyObject *m = NULL;
Guido van Rossum74e6a111994-08-29 12:54:38 +00002286
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002287 /* Require:
2288 if mod == None: subname == fullname
2289 else: mod.__name__ + "." + subname == fullname
2290 */
2291
Tim Peters50d8d372001-02-28 05:34:27 +00002292 if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002293 Py_INCREF(m);
Guido van Rossum7f9fa971995-01-20 16:53:12 +00002294 }
2295 else {
Just van Rossum52e14d62002-12-30 22:08:05 +00002296 PyObject *path, *loader = NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002297 char buf[MAXPATHLEN+1];
2298 struct filedescr *fdp;
2299 FILE *fp = NULL;
2300
Guido van Rossum9c0afe51998-05-19 15:09:05 +00002301 if (mod == Py_None)
2302 path = NULL;
2303 else {
2304 path = PyObject_GetAttrString(mod, "__path__");
2305 if (path == NULL) {
2306 PyErr_Clear();
2307 Py_INCREF(Py_None);
2308 return Py_None;
2309 }
2310 }
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002311
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002312 buf[0] = '\0';
Just van Rossum52e14d62002-12-30 22:08:05 +00002313 fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
2314 &fp, &loader);
Guido van Rossumb68cd421998-07-01 17:36:26 +00002315 Py_XDECREF(path);
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002316 if (fdp == NULL) {
2317 if (!PyErr_ExceptionMatches(PyExc_ImportError))
2318 return NULL;
2319 PyErr_Clear();
2320 Py_INCREF(Py_None);
2321 return Py_None;
2322 }
Just van Rossum52e14d62002-12-30 22:08:05 +00002323 m = load_module(fullname, fp, buf, fdp->type, loader);
2324 Py_XDECREF(loader);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002325 if (fp)
2326 fclose(fp);
Neil Schemenauer00b09662003-06-16 21:03:07 +00002327 if (!add_submodule(mod, m, fullname, subname, modules)) {
2328 Py_XDECREF(m);
2329 m = NULL;
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002330 }
Guido van Rossum74e6a111994-08-29 12:54:38 +00002331 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002332
2333 return m;
Guido van Rossum74e6a111994-08-29 12:54:38 +00002334}
2335
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002336
2337/* Re-import a module of any kind and return its module object, WITH
2338 INCREMENTED REFERENCE COUNT */
2339
Guido van Rossum79f25d91997-04-29 20:08:16 +00002340PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002341PyImport_ReloadModule(PyObject *m)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002342{
Guido van Rossum25ce5661997-08-02 03:10:38 +00002343 PyObject *modules = PyImport_GetModuleDict();
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002344 PyObject *path = NULL, *loader = NULL;
Guido van Rossum222ef561997-09-06 19:41:09 +00002345 char *name, *subname;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002346 char buf[MAXPATHLEN+1];
2347 struct filedescr *fdp;
2348 FILE *fp = NULL;
Tim Peters1cd70172004-08-02 03:52:12 +00002349 PyObject *newm;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002350
Guido van Rossum79f25d91997-04-29 20:08:16 +00002351 if (m == NULL || !PyModule_Check(m)) {
2352 PyErr_SetString(PyExc_TypeError,
2353 "reload() argument must be module");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002354 return NULL;
2355 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002356 name = PyModule_GetName(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002357 if (name == NULL)
2358 return NULL;
Guido van Rossum25ce5661997-08-02 03:10:38 +00002359 if (m != PyDict_GetItemString(modules, name)) {
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002360 PyErr_Format(PyExc_ImportError,
2361 "reload(): module %.200s not in sys.modules",
2362 name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002363 return NULL;
2364 }
Guido van Rossum222ef561997-09-06 19:41:09 +00002365 subname = strrchr(name, '.');
2366 if (subname == NULL)
2367 subname = name;
2368 else {
2369 PyObject *parentname, *parent;
2370 parentname = PyString_FromStringAndSize(name, (subname-name));
2371 if (parentname == NULL)
2372 return NULL;
2373 parent = PyDict_GetItem(modules, parentname);
2374 if (parent == NULL) {
2375 PyErr_Format(PyExc_ImportError,
2376 "reload(): parent %.200s not in sys.modules",
Georg Brandl0c55f292005-09-14 06:56:20 +00002377 PyString_AS_STRING(parentname));
2378 Py_DECREF(parentname);
Guido van Rossum222ef561997-09-06 19:41:09 +00002379 return NULL;
2380 }
Georg Brandl0c55f292005-09-14 06:56:20 +00002381 Py_DECREF(parentname);
Guido van Rossum222ef561997-09-06 19:41:09 +00002382 subname++;
2383 path = PyObject_GetAttrString(parent, "__path__");
2384 if (path == NULL)
2385 PyErr_Clear();
2386 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002387 buf[0] = '\0';
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002388 fdp = find_module(name, subname, path, buf, MAXPATHLEN+1, &fp, &loader);
Guido van Rossum222ef561997-09-06 19:41:09 +00002389 Py_XDECREF(path);
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002390
2391 if (fdp == NULL) {
2392 Py_XDECREF(loader);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002393 return NULL;
Phillip J. Eby7ec642a2004-09-23 04:37:36 +00002394 }
2395
2396 newm = load_module(name, fp, buf, fdp->type, loader);
2397 Py_XDECREF(loader);
2398
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002399 if (fp)
2400 fclose(fp);
Tim Peters1cd70172004-08-02 03:52:12 +00002401 if (newm == NULL) {
2402 /* load_module probably removed name from modules because of
2403 * the error. Put back the original module object. We're
2404 * going to return NULL in this case regardless of whether
2405 * replacing name succeeds, so the return value is ignored.
2406 */
2407 PyDict_SetItemString(modules, name, m);
2408 }
2409 return newm;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002410}
2411
2412
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002413/* Higher-level import emulator which emulates the "import" statement
2414 more accurately -- it invokes the __import__() function from the
2415 builtins of the current globals. This means that the import is
2416 done using whatever import hooks are installed in the current
Guido van Rossum6058eb41998-12-21 19:51:00 +00002417 environment, e.g. by "rexec".
2418 A dummy list ["__doc__"] is passed as the 4th argument so that
2419 e.g. PyImport_Import(PyString_FromString("win32com.client.gencache"))
2420 will return <module "gencache"> instead of <module "win32com">. */
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002421
2422PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002423PyImport_Import(PyObject *module_name)
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002424{
2425 static PyObject *silly_list = NULL;
2426 static PyObject *builtins_str = NULL;
2427 static PyObject *import_str = NULL;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002428 PyObject *globals = NULL;
2429 PyObject *import = NULL;
2430 PyObject *builtins = NULL;
2431 PyObject *r = NULL;
2432
2433 /* Initialize constant string objects */
2434 if (silly_list == NULL) {
2435 import_str = PyString_InternFromString("__import__");
2436 if (import_str == NULL)
2437 return NULL;
2438 builtins_str = PyString_InternFromString("__builtins__");
2439 if (builtins_str == NULL)
2440 return NULL;
2441 silly_list = Py_BuildValue("[s]", "__doc__");
2442 if (silly_list == NULL)
2443 return NULL;
2444 }
2445
2446 /* Get the builtins from current globals */
2447 globals = PyEval_GetGlobals();
Guido van Rossum85cd1d62001-02-20 21:43:24 +00002448 if (globals != NULL) {
Guido van Rossum66468561998-10-22 15:46:50 +00002449 Py_INCREF(globals);
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002450 builtins = PyObject_GetItem(globals, builtins_str);
2451 if (builtins == NULL)
2452 goto err;
2453 }
2454 else {
2455 /* No globals -- use standard builtins, and fake globals */
2456 PyErr_Clear();
2457
Thomas Woutersf7f438b2006-02-28 16:09:29 +00002458 builtins = PyImport_ImportModuleLevel("__builtin__",
2459 NULL, NULL, NULL, 0);
Guido van Rossum85cd1d62001-02-20 21:43:24 +00002460 if (builtins == NULL)
2461 return NULL;
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002462 globals = Py_BuildValue("{OO}", builtins_str, builtins);
2463 if (globals == NULL)
2464 goto err;
2465 }
2466
2467 /* Get the __import__ function from the builtins */
Tim Peters6d6c1a32001-08-02 04:15:00 +00002468 if (PyDict_Check(builtins)) {
Fred Drakea76ba6e2001-03-06 06:31:15 +00002469 import = PyObject_GetItem(builtins, import_str);
Tim Peters6d6c1a32001-08-02 04:15:00 +00002470 if (import == NULL)
2471 PyErr_SetObject(PyExc_KeyError, import_str);
2472 }
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002473 else
Fred Drakea76ba6e2001-03-06 06:31:15 +00002474 import = PyObject_GetAttr(builtins, import_str);
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002475 if (import == NULL)
2476 goto err;
2477
2478 /* Call the _import__ function with the proper argument list */
2479 r = PyObject_CallFunction(import, "OOOO",
2480 module_name, globals, globals, silly_list);
2481
2482 err:
2483 Py_XDECREF(globals);
2484 Py_XDECREF(builtins);
2485 Py_XDECREF(import);
Tim Peters50d8d372001-02-28 05:34:27 +00002486
Guido van Rossumd47a0a81997-08-14 20:11:26 +00002487 return r;
2488}
2489
2490
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002491/* Module 'imp' provides Python access to the primitives used for
2492 importing modules.
2493*/
2494
Guido van Rossum79f25d91997-04-29 20:08:16 +00002495static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +00002496imp_get_magic(PyObject *self, PyObject *noargs)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002497{
2498 char buf[4];
2499
Guido van Rossum96774c12000-05-01 20:19:08 +00002500 buf[0] = (char) ((pyc_magic >> 0) & 0xff);
2501 buf[1] = (char) ((pyc_magic >> 8) & 0xff);
2502 buf[2] = (char) ((pyc_magic >> 16) & 0xff);
2503 buf[3] = (char) ((pyc_magic >> 24) & 0xff);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002504
Guido van Rossum79f25d91997-04-29 20:08:16 +00002505 return PyString_FromStringAndSize(buf, 4);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002506}
2507
Guido van Rossum79f25d91997-04-29 20:08:16 +00002508static PyObject *
Neal Norwitz08ea61a2003-02-17 18:18:00 +00002509imp_get_suffixes(PyObject *self, PyObject *noargs)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002510{
Guido van Rossum79f25d91997-04-29 20:08:16 +00002511 PyObject *list;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002512 struct filedescr *fdp;
2513
Guido van Rossum79f25d91997-04-29 20:08:16 +00002514 list = PyList_New(0);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002515 if (list == NULL)
2516 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002517 for (fdp = _PyImport_Filetab; fdp->suffix != NULL; fdp++) {
2518 PyObject *item = Py_BuildValue("ssi",
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002519 fdp->suffix, fdp->mode, fdp->type);
2520 if (item == NULL) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002521 Py_DECREF(list);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002522 return NULL;
2523 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002524 if (PyList_Append(list, item) < 0) {
2525 Py_DECREF(list);
2526 Py_DECREF(item);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002527 return NULL;
2528 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002529 Py_DECREF(item);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002530 }
2531 return list;
2532}
2533
Guido van Rossum79f25d91997-04-29 20:08:16 +00002534static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002535call_find_module(char *name, PyObject *path)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002536{
Tim Petersdbd9ba62000-07-09 03:09:57 +00002537 extern int fclose(FILE *);
Guido van Rossum79f25d91997-04-29 20:08:16 +00002538 PyObject *fob, *ret;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002539 struct filedescr *fdp;
2540 char pathname[MAXPATHLEN+1];
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002541 FILE *fp = NULL;
2542
2543 pathname[0] = '\0';
Guido van Rossum17fc85f1997-09-06 18:52:03 +00002544 if (path == Py_None)
2545 path = NULL;
Just van Rossum52e14d62002-12-30 22:08:05 +00002546 fdp = find_module(NULL, name, path, pathname, MAXPATHLEN+1, &fp, NULL);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002547 if (fdp == NULL)
2548 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002549 if (fp != NULL) {
2550 fob = PyFile_FromFile(fp, pathname, fdp->mode, fclose);
2551 if (fob == NULL) {
2552 fclose(fp);
2553 return NULL;
2554 }
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002555 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002556 else {
2557 fob = Py_None;
2558 Py_INCREF(fob);
Tim Peters50d8d372001-02-28 05:34:27 +00002559 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002560 ret = Py_BuildValue("Os(ssi)",
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002561 fob, pathname, fdp->suffix, fdp->mode, fdp->type);
Guido van Rossum79f25d91997-04-29 20:08:16 +00002562 Py_DECREF(fob);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002563 return ret;
2564}
2565
Guido van Rossum79f25d91997-04-29 20:08:16 +00002566static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002567imp_find_module(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002568{
2569 char *name;
2570 PyObject *path = NULL;
Guido van Rossum43713e52000-02-29 13:59:29 +00002571 if (!PyArg_ParseTuple(args, "s|O:find_module", &name, &path))
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002572 return NULL;
2573 return call_find_module(name, path);
2574}
2575
2576static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002577imp_init_builtin(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002578{
2579 char *name;
2580 int ret;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002581 PyObject *m;
Guido van Rossum43713e52000-02-29 13:59:29 +00002582 if (!PyArg_ParseTuple(args, "s:init_builtin", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002583 return NULL;
2584 ret = init_builtin(name);
2585 if (ret < 0)
2586 return NULL;
2587 if (ret == 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002588 Py_INCREF(Py_None);
2589 return Py_None;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002590 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002591 m = PyImport_AddModule(name);
2592 Py_XINCREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002593 return m;
2594}
2595
Guido van Rossum79f25d91997-04-29 20:08:16 +00002596static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002597imp_init_frozen(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002598{
2599 char *name;
2600 int ret;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002601 PyObject *m;
Guido van Rossum43713e52000-02-29 13:59:29 +00002602 if (!PyArg_ParseTuple(args, "s:init_frozen", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002603 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002604 ret = PyImport_ImportFrozenModule(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002605 if (ret < 0)
2606 return NULL;
2607 if (ret == 0) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002608 Py_INCREF(Py_None);
2609 return Py_None;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002610 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002611 m = PyImport_AddModule(name);
2612 Py_XINCREF(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002613 return m;
2614}
2615
Guido van Rossum79f25d91997-04-29 20:08:16 +00002616static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002617imp_get_frozen_object(PyObject *self, PyObject *args)
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002618{
2619 char *name;
Jack Jansen95ffa231995-10-03 14:38:41 +00002620
Guido van Rossum43713e52000-02-29 13:59:29 +00002621 if (!PyArg_ParseTuple(args, "s:get_frozen_object", &name))
Guido van Rossum6ec1efb1995-08-04 04:08:57 +00002622 return NULL;
2623 return get_frozen_object(name);
2624}
2625
Guido van Rossum79f25d91997-04-29 20:08:16 +00002626static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002627imp_is_builtin(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002628{
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002629 char *name;
Guido van Rossum43713e52000-02-29 13:59:29 +00002630 if (!PyArg_ParseTuple(args, "s:is_builtin", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002631 return NULL;
Guido van Rossum50ee94f2002-04-09 18:00:58 +00002632 return PyInt_FromLong(is_builtin(name));
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002633}
2634
Guido van Rossum79f25d91997-04-29 20:08:16 +00002635static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002636imp_is_frozen(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002637{
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002638 char *name;
Guido van Rossum323bf5e1998-06-24 03:54:06 +00002639 struct _frozen *p;
Guido van Rossum43713e52000-02-29 13:59:29 +00002640 if (!PyArg_ParseTuple(args, "s:is_frozen", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002641 return NULL;
Guido van Rossum323bf5e1998-06-24 03:54:06 +00002642 p = find_frozen(name);
Guido van Rossumb8bff3f2002-04-07 06:34:38 +00002643 return PyBool_FromLong((long) (p == NULL ? 0 : p->size));
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002644}
2645
2646static FILE *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002647get_file(char *pathname, PyObject *fob, char *mode)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002648{
2649 FILE *fp;
2650 if (fob == NULL) {
Tim Peters86c7d2f2004-08-01 23:24:21 +00002651 if (mode[0] == 'U')
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00002652 mode = "r" PY_STDIOTEXTMODE;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002653 fp = fopen(pathname, mode);
2654 if (fp == NULL)
Guido van Rossum79f25d91997-04-29 20:08:16 +00002655 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002656 }
2657 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00002658 fp = PyFile_AsFile(fob);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002659 if (fp == NULL)
Guido van Rossum79f25d91997-04-29 20:08:16 +00002660 PyErr_SetString(PyExc_ValueError,
2661 "bad/closed file object");
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002662 }
2663 return fp;
2664}
2665
Guido van Rossum79f25d91997-04-29 20:08:16 +00002666static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002667imp_load_compiled(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002668{
2669 char *name;
2670 char *pathname;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002671 PyObject *fob = NULL;
2672 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002673 FILE *fp;
Guido van Rossum43713e52000-02-29 13:59:29 +00002674 if (!PyArg_ParseTuple(args, "ss|O!:load_compiled", &name, &pathname,
Guido van Rossum79f25d91997-04-29 20:08:16 +00002675 &PyFile_Type, &fob))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002676 return NULL;
2677 fp = get_file(pathname, fob, "rb");
2678 if (fp == NULL)
2679 return NULL;
2680 m = load_compiled_module(name, pathname, fp);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002681 if (fob == NULL)
2682 fclose(fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002683 return m;
2684}
2685
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002686#ifdef HAVE_DYNAMIC_LOADING
2687
Guido van Rossum79f25d91997-04-29 20:08:16 +00002688static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002689imp_load_dynamic(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002690{
2691 char *name;
2692 char *pathname;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002693 PyObject *fob = NULL;
2694 PyObject *m;
Guido van Rossum7faeab31995-07-07 22:50:36 +00002695 FILE *fp = NULL;
Guido van Rossum43713e52000-02-29 13:59:29 +00002696 if (!PyArg_ParseTuple(args, "ss|O!:load_dynamic", &name, &pathname,
Guido van Rossum79f25d91997-04-29 20:08:16 +00002697 &PyFile_Type, &fob))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002698 return NULL;
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002699 if (fob) {
Guido van Rossum7faeab31995-07-07 22:50:36 +00002700 fp = get_file(pathname, fob, "r");
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002701 if (fp == NULL)
2702 return NULL;
2703 }
Guido van Rossum79f25d91997-04-29 20:08:16 +00002704 m = _PyImport_LoadDynamicModule(name, pathname, fp);
Guido van Rossum7faeab31995-07-07 22:50:36 +00002705 return m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002706}
2707
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002708#endif /* HAVE_DYNAMIC_LOADING */
2709
Guido van Rossum79f25d91997-04-29 20:08:16 +00002710static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002711imp_load_source(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002712{
2713 char *name;
2714 char *pathname;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002715 PyObject *fob = NULL;
2716 PyObject *m;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002717 FILE *fp;
Guido van Rossum43713e52000-02-29 13:59:29 +00002718 if (!PyArg_ParseTuple(args, "ss|O!:load_source", &name, &pathname,
Guido van Rossum79f25d91997-04-29 20:08:16 +00002719 &PyFile_Type, &fob))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002720 return NULL;
2721 fp = get_file(pathname, fob, "r");
2722 if (fp == NULL)
2723 return NULL;
2724 m = load_source_module(name, pathname, fp);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002725 if (fob == NULL)
2726 fclose(fp);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002727 return m;
2728}
2729
Guido van Rossum79f25d91997-04-29 20:08:16 +00002730static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002731imp_load_module(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002732{
2733 char *name;
2734 PyObject *fob;
2735 char *pathname;
2736 char *suffix; /* Unused */
2737 char *mode;
2738 int type;
2739 FILE *fp;
2740
Guido van Rossum43713e52000-02-29 13:59:29 +00002741 if (!PyArg_ParseTuple(args, "sOs(ssi):load_module",
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002742 &name, &fob, &pathname,
2743 &suffix, &mode, &type))
2744 return NULL;
Guido van Rossum5e2c5fa2002-05-30 17:33:07 +00002745 if (*mode) {
2746 /* Mode must start with 'r' or 'U' and must not contain '+'.
2747 Implicit in this test is the assumption that the mode
2748 may contain other modifiers like 'b' or 't'. */
2749
2750 if (!(*mode == 'r' || *mode == 'U') || strchr(mode, '+')) {
Jeremy Hylton4ae6fae2002-05-30 17:15:25 +00002751 PyErr_Format(PyExc_ValueError,
2752 "invalid file open mode %.200s", mode);
2753 return NULL;
Guido van Rossum5e2c5fa2002-05-30 17:33:07 +00002754 }
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002755 }
2756 if (fob == Py_None)
2757 fp = NULL;
2758 else {
2759 if (!PyFile_Check(fob)) {
2760 PyErr_SetString(PyExc_ValueError,
2761 "load_module arg#2 should be a file or None");
2762 return NULL;
2763 }
2764 fp = get_file(pathname, fob, mode);
2765 if (fp == NULL)
2766 return NULL;
2767 }
Just van Rossum52e14d62002-12-30 22:08:05 +00002768 return load_module(name, fp, pathname, type, NULL);
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002769}
2770
2771static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002772imp_load_package(PyObject *self, PyObject *args)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002773{
2774 char *name;
2775 char *pathname;
Guido van Rossum43713e52000-02-29 13:59:29 +00002776 if (!PyArg_ParseTuple(args, "ss:load_package", &name, &pathname))
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002777 return NULL;
2778 return load_package(name, pathname);
2779}
2780
2781static PyObject *
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002782imp_new_module(PyObject *self, PyObject *args)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002783{
2784 char *name;
Guido van Rossum43713e52000-02-29 13:59:29 +00002785 if (!PyArg_ParseTuple(args, "s:new_module", &name))
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002786 return NULL;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002787 return PyModule_New(name);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002788}
2789
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002790/* Doc strings */
2791
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002792PyDoc_STRVAR(doc_imp,
2793"This module provides the components needed to build your own\n\
2794__import__ function. Undocumented functions are obsolete.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002795
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002796PyDoc_STRVAR(doc_find_module,
2797"find_module(name, [path]) -> (file, filename, (suffix, mode, type))\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002798Search for a module. If path is omitted or None, search for a\n\
2799built-in, frozen or special module and continue search in sys.path.\n\
2800The module name cannot contain '.'; to search for a submodule of a\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002801package, pass the submodule name and the package's __path__.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002802
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002803PyDoc_STRVAR(doc_load_module,
2804"load_module(name, file, filename, (suffix, mode, type)) -> module\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002805Load a module, given information returned by find_module().\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002806The module name must include the full package name, if any.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002807
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002808PyDoc_STRVAR(doc_get_magic,
2809"get_magic() -> string\n\
2810Return the magic number for .pyc or .pyo files.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002811
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002812PyDoc_STRVAR(doc_get_suffixes,
2813"get_suffixes() -> [(suffix, mode, type), ...]\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002814Return a list of (suffix, mode, type) tuples describing the files\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002815that find_module() looks for.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002816
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002817PyDoc_STRVAR(doc_new_module,
2818"new_module(name) -> module\n\
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002819Create a new module. Do not enter it in sys.modules.\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002820The module name must include the full package name, if any.");
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002821
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002822PyDoc_STRVAR(doc_lock_held,
Tim Petersa7c65092004-08-01 23:26:05 +00002823"lock_held() -> boolean\n\
2824Return True if the import lock is currently held, else False.\n\
2825On platforms without threads, return False.");
Tim Peters69232342001-08-30 05:16:13 +00002826
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00002827PyDoc_STRVAR(doc_acquire_lock,
2828"acquire_lock() -> None\n\
Neal Norwitz2294c0d2003-02-12 23:02:21 +00002829Acquires the interpreter's import lock for the current thread.\n\
2830This lock should be used by import hooks to ensure thread-safety\n\
2831when importing modules.\n\
Guido van Rossumc4f4ca92003-02-12 21:46:11 +00002832On platforms without threads, this function does nothing.");
2833
2834PyDoc_STRVAR(doc_release_lock,
2835"release_lock() -> None\n\
2836Release the interpreter's import lock.\n\
2837On platforms without threads, this function does nothing.");
2838
Guido van Rossum79f25d91997-04-29 20:08:16 +00002839static PyMethodDef imp_methods[] = {
Neal Norwitz08ea61a2003-02-17 18:18:00 +00002840 {"find_module", imp_find_module, METH_VARARGS, doc_find_module},
2841 {"get_magic", imp_get_magic, METH_NOARGS, doc_get_magic},
2842 {"get_suffixes", imp_get_suffixes, METH_NOARGS, doc_get_suffixes},
2843 {"load_module", imp_load_module, METH_VARARGS, doc_load_module},
2844 {"new_module", imp_new_module, METH_VARARGS, doc_new_module},
2845 {"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
2846 {"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
2847 {"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002848 /* The rest are obsolete */
Neal Norwitz031829d2002-03-31 14:37:44 +00002849 {"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
2850 {"init_builtin", imp_init_builtin, METH_VARARGS},
2851 {"init_frozen", imp_init_frozen, METH_VARARGS},
2852 {"is_builtin", imp_is_builtin, METH_VARARGS},
2853 {"is_frozen", imp_is_frozen, METH_VARARGS},
2854 {"load_compiled", imp_load_compiled, METH_VARARGS},
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002855#ifdef HAVE_DYNAMIC_LOADING
Neal Norwitz031829d2002-03-31 14:37:44 +00002856 {"load_dynamic", imp_load_dynamic, METH_VARARGS},
Guido van Rossum96a8fb71999-12-22 14:09:35 +00002857#endif
Neal Norwitz031829d2002-03-31 14:37:44 +00002858 {"load_package", imp_load_package, METH_VARARGS},
Neal Norwitz031829d2002-03-31 14:37:44 +00002859 {"load_source", imp_load_source, METH_VARARGS},
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002860 {NULL, NULL} /* sentinel */
2861};
2862
Guido van Rossum1a8791e1998-08-04 22:46:29 +00002863static int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002864setint(PyObject *d, char *name, int value)
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002865{
2866 PyObject *v;
2867 int err;
2868
2869 v = PyInt_FromLong((long)value);
2870 err = PyDict_SetItemString(d, name, v);
2871 Py_XDECREF(v);
2872 return err;
2873}
2874
Jason Tishler6bc06ec2003-09-04 11:59:50 +00002875PyMODINIT_FUNC
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002876initimp(void)
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002877{
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002878 PyObject *m, *d;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002879
Guido van Rossum0207e6d1997-09-09 22:04:42 +00002880 m = Py_InitModule4("imp", imp_methods, doc_imp,
2881 NULL, PYTHON_API_VERSION);
Neal Norwitz1ac754f2006-01-19 06:09:39 +00002882 if (m == NULL)
2883 goto failure;
Guido van Rossum79f25d91997-04-29 20:08:16 +00002884 d = PyModule_GetDict(m);
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002885
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002886 if (setint(d, "SEARCH_ERROR", SEARCH_ERROR) < 0) goto failure;
2887 if (setint(d, "PY_SOURCE", PY_SOURCE) < 0) goto failure;
2888 if (setint(d, "PY_COMPILED", PY_COMPILED) < 0) goto failure;
2889 if (setint(d, "C_EXTENSION", C_EXTENSION) < 0) goto failure;
2890 if (setint(d, "PY_RESOURCE", PY_RESOURCE) < 0) goto failure;
2891 if (setint(d, "PKG_DIRECTORY", PKG_DIRECTORY) < 0) goto failure;
2892 if (setint(d, "C_BUILTIN", C_BUILTIN) < 0) goto failure;
2893 if (setint(d, "PY_FROZEN", PY_FROZEN) < 0) goto failure;
Guido van Rossum0f84a341998-08-06 13:36:01 +00002894 if (setint(d, "PY_CODERESOURCE", PY_CODERESOURCE) < 0) goto failure;
Just van Rossum52e14d62002-12-30 22:08:05 +00002895 if (setint(d, "IMP_HOOK", IMP_HOOK) < 0) goto failure;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002896
Guido van Rossumaee0bad1997-09-05 07:33:22 +00002897 failure:
2898 ;
Guido van Rossum1ae940a1995-01-02 19:04:15 +00002899}
Guido van Rossum09cae1f1998-05-14 02:32:54 +00002900
2901
Guido van Rossumb18618d2000-05-03 23:44:39 +00002902/* API for embedding applications that want to add their own entries
2903 to the table of built-in modules. This should normally be called
2904 *before* Py_Initialize(). When the table resize fails, -1 is
2905 returned and the existing table is unchanged.
Guido van Rossum09cae1f1998-05-14 02:32:54 +00002906
2907 After a similar function by Just van Rossum. */
2908
2909int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002910PyImport_ExtendInittab(struct _inittab *newtab)
Guido van Rossum09cae1f1998-05-14 02:32:54 +00002911{
2912 static struct _inittab *our_copy = NULL;
2913 struct _inittab *p;
2914 int i, n;
2915
2916 /* Count the number of entries in both tables */
2917 for (n = 0; newtab[n].name != NULL; n++)
2918 ;
2919 if (n == 0)
2920 return 0; /* Nothing to do */
2921 for (i = 0; PyImport_Inittab[i].name != NULL; i++)
2922 ;
2923
2924 /* Allocate new memory for the combined table */
Guido van Rossumb18618d2000-05-03 23:44:39 +00002925 p = our_copy;
2926 PyMem_RESIZE(p, struct _inittab, i+n+1);
Guido van Rossum09cae1f1998-05-14 02:32:54 +00002927 if (p == NULL)
2928 return -1;
2929
2930 /* Copy the tables into the new memory */
2931 if (our_copy != PyImport_Inittab)
2932 memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
2933 PyImport_Inittab = our_copy = p;
2934 memcpy(p+i, newtab, (n+1) * sizeof(struct _inittab));
2935
2936 return 0;
2937}
2938
2939/* Shorthand to add a single entry given a name and a function */
2940
2941int
Thomas Woutersf70ef4f2000-07-22 18:47:25 +00002942PyImport_AppendInittab(char *name, void (*initfunc)(void))
Guido van Rossum09cae1f1998-05-14 02:32:54 +00002943{
2944 struct _inittab newtab[2];
2945
2946 memset(newtab, '\0', sizeof newtab);
2947
2948 newtab[0].name = name;
2949 newtab[0].initfunc = initfunc;
2950
2951 return PyImport_ExtendInittab(newtab);
2952}
Anthony Baxterac6bd462006-04-13 02:06:09 +00002953
2954#ifdef __cplusplus
2955}
2956#endif